Skip to content
SELECTED WORKCASE_02 // PROJECT STEWARD

The AI runs the machine.
The human runs the AI.

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.

PRODUCT
Project Steward, a governed AI operating system
DOMAIN
AI safety · OS security · infrastructure
TEAM
The Genevity Labs founders
STATUS
Alpha, live on lab hardware
01 // THE PROBLEM

Agents are being handed root and asked to behave.

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.

02 // THE ARCHITECTURE

Four layers. One door.

MODELTOOL CALLBROKERKERNEL

L_01

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.

L_02

The hands

The tools that act. They run in a separate sandbox under stacked mandatory-access profiles, and can only use what the broker hands them.

L_03

The broker

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.

L_04

The human

The sovereign. Approves from a trusted path the AI cannot see or forge: the console today, a phone with hardware-backed keys next.

03 // THE GUARDRAILS

Padded walls for accidents, not a cage for intent.

G_01

The handle is the permission

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.

G_02

Once, session or always

Approvals carry a lifetime. Standing approvals are per agent and per exact resource, stored tamper-evidently, and never available for the most sensitive tier.

G_03

Crown jewels need a touch

Data marked as never-leaves cannot be released by a typed yes. It needs a fresh hardware-key signature over that exact request.

G_04

Every act, chained

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.

G_05

Locked means nothing moves

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.

G_06

No bypass. Ever.

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.

04 // THE PROOF

Let the model choose. Grade the audit log.

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.

  1. GRANTED Join the trusted Wi-Fi network. The station associated for real.
  2. REFUSED Join a rogue network. Denied at the broker before the radio was touched.
  3. GRANTED + TOUCH Read a classified file. A typed yes was not enough. It took a physical key tap, signed over that request.

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.

05 // GOVERNED OPERATOR

The broker is sudo. Your approval is the password.

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.

06 // BY THE NUMBERS
0ways to run the AI without the broker
2sandboxes, brain and hands, never sharing a key
3/3governed acts held in the live demo, graded against the audit chain
46trust-boundary tests, plus a design review before any boundary change
07 // ENGINEERING

Stock Linux, owned hardware, no cloud in the loop.

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.

  • Rust
  • Ubuntu 26.04 LTS
  • Linux 7.0
  • bubblewrap
  • AppArmor
  • Ed25519
  • BLAKE3
  • Argon2id
  • XChaCha20-Poly1305
  • vLLM
  • Swift · Secure Enclave
WHAT IT MEANS FOR YOU

Give your AI real work, without giving it the keys.

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