The brain
The language model. It plans and asks. It runs in its own sandbox, reaches its model only through a pinned forwarder, and holds no keys.
Project Steward is an operating system built around a language model as its operator. Instead of a desktop and a terminal, you get an AI that administers the node for you. Between that AI and the kernel sits a broker that grants, refuses and records every single thing it tries to do. The design assumes the AI is the adversary, and stays safe when it is.
The fastest way to make an AI agent useful is to give it a shell. The usual safety story is a permission prompt inside the agent itself: the same process that wants to act also decides whether it may. That is a policy, not a boundary. One prompt injection, one confused plan, one hallucinated path, and the agent holds the keys to everything the account can touch.
Hardening the model does not fix this. Models will be wrong, and they can be persuaded. The question is what the machine lets them do when they are.
A node should be a domain you govern, not a computer you operate.
MODEL→TOOL CALL→BROKER→KERNEL
The language model. It plans and asks. It runs in its own sandbox, reaches its model only through a pinned forwarder, and holds no keys.
The tools that act. They run in a separate sandbox under stacked mandatory-access profiles, and can only use what the broker hands them.
The only door to the machine. Every action is a typed request: read this file, append to that one, join this network, send data out. Each one is granted or refused.
The sovereign. Approves from a trusted path the AI cannot see or forge: the console today, a phone with hardware-backed keys next.
The broker opens the resource itself and passes the sandbox a file descriptor. There is no path string for the model to bend, and nothing to escalate.
Approvals carry a lifetime. Standing approvals are per agent and per exact resource, stored tamper-evidently, and never available for the most sensitive tier.
Data marked as never-leaves cannot be released by a typed yes. It needs a fresh hardware-key signature over that exact request.
Grants, refusals and timeouts land in a hash-chained audit log with forward-secure seals. The AI can query its own history and nobody else’s.
Secrets live in a vault opened by two factors at the console. Until it is unlocked, the broker does not even listen. Lock it and the AI is inert.
There is no broker-off mode, no fallback and no maintenance backdoor. If the broker is absent, the AI can do nothing. Any shortcut around it is treated as a defect.
In the live demo, a locally hosted open-weight model was given a task and left to pick its own tool calls on real hardware. A human approved or refused from the trusted path, with a hardware security key and a real radio.
Pass or fail was decided by the contents of the hash-chained audit log, not by the model’s output. If the model wanders off script, the run fails visibly instead of passing on the wrong thing.
The same broker can govern an off-the-shelf coding agent acting as the node’s administrator. The agent runs with its own permission system switched off, inside a sandbox with a read-only view of the system and secrets masked. Every privileged command and every network host goes through the broker.
Ask it to “check the server, update anything out of date, but don’t reboot yet” and it works the way it normally would. Each change waits for a human yes. Ask for the same command often enough and it offers a standing approval. It never offers one for anything touching secrets or paths it can write itself.
Approvals are moving to a phone app with keys held in the Secure Enclave. A tap approves, Face ID covers the sensitive tier, and the link to the node runs over an encrypted local radio channel.
The broker ships as a standard package for a current Ubuntu LTS kernel. It is not a forked distribution. It uses the kernel’s own sandboxing and mandatory access control, so it inherits upstream security fixes instead of carrying its own. The model runs on a GPU in our own lab, and a bootable live image lets the team test-drive a node without installing anything.
The rule for the codebase: no change to the trust boundary merges without a short design document and a test that tries to break it.
The same pattern applies to any agent near production systems: separate the thinking from the doing, broker every act, and keep a human on a path the model cannot touch.
START A PROJECT