9 min read

Kubernetes for Agents: One Source of Truth, Steered Together

Agents are good at the work. The hard part is keeping people and agents pointed at the same thing. Kubernetes solved that for servers with one shared record.

On this page
  1. What Kubernetes actually got right
  2. The source of truth
  3. Steering together
  4. Observing: what the record needs from a runtime
  5. Everything is verifiable
  6. What I’ve built so far: Rex
  7. What a team looks like
  8. What’s missing

Picture an engineering team on a Tuesday morning: four people, six AI agents. One agent is waiting for permission to run a command. Another finished an hour ago and nobody noticed. A third made a decision about retries that a fourth is about to contradict.

Nobody is doing anything wrong, and the agents are good. The problem is that each one holds its own version of the work: what it was asked, what it tried, what it assumed. The people hold more versions in chat threads, terminal tabs and their heads. When someone asks “where are we on this?”, the answer gets assembled by hand, by tabbing around and asking.

That is the real cost of working with agents today. It isn’t the quality of the code. It’s the effort of keeping everyone, human and machine, pointed at the same thing.

This post is about a fix: one shared record that people and agents both read and write, and steer from together. It’s a design, not a product yet; the last section says what’s missing. The idea is borrowed from Kubernetes, so that’s where we’ll start.

What Kubernetes actually got right

Kubernetes is the system much of the industry uses to run software across fleets of servers. What it runs are containers: self-contained packages of software. Containers existed long before Kubernetes, and running one was easy. Running thousands was the problem, because nobody could say what should be running, what was running, and whether the two matched.

Kubernetes answered with one idea: write the desired state down in a single shared record, and let everything else read from it and report back to it. You declare “three copies of this service.” Small programs called controllers compare that to what is actually running and close the gap. Operators stop logging into machines one at a time and start editing the record.

Agents are at the same point. One agent is easy. A team’s worth of agents, working alongside a team’s worth of people, needs the same thing: a shared record of what we intend, what is happening, and what we decided. People steer by changing the record. Agents steer by reading it and adding to it.

Kubernetes A team with agents
What we want “Three copies of this service” “A client that loses its connection is back within 30 seconds”
Who closes the gap Controllers Agents, within limits people set
How we know it worked Each server reports what it’s running Watchers and checks report what happened
How people steer Edit the record Edit the record

The ideas don’t depend on any one tool. Any terminal, test server or sandbox can feed the record, and any app can read it. I’ve been calling the design Bilateral. The rest of this post covers what the record holds, how people and agents act on it, and why it makes the work verifiable.

The source of truth

The record holds five kinds of entry: intents (what must be true), boundaries (what agents may not touch), decisions, work (plans, documents and code changes), and checks with their results. Nothing in it is edited or deleted; a correction is a new entry. Each entry is signed by whoever wrote it, so you always know who said what.

The key idea is that every entry says how it is known:

  • Said: someone claimed it. An agent writing “tests pass” is said.
  • Witnessed: a watcher saw it happen. A runtime that ran the tests itself and kept the output is witnessed.
  • Checkable: anyone can look it up again. A merged pull request, an accepted code change on GitHub, is checkable.

Four kinds of participant share the record. Actors, people and agents, write what they say. Witnesses write what they saw. Sources hold facts anyone can re-read, like the state of a pull request. Clients read the record and steer from it.

Diagram: actors, witnesses and sources all write to one shared record; clients read the record and steer from it.
Everyone writes to one record, and each entry says how it is known.

Steering together

People and agents do different jobs on the same record.

People set intent and limits. An intent says what must be true, in plain words, and names the checks that would prove it: “a client that loses its connection is back within 30 seconds.” Boundaries say what agents may not touch, such as certain files, new third-party libraries or spending. Decisions are recorded with their reasons, so the next person or agent doesn’t relitigate them.

Agents propose and build. They draft plans, attempt the work and ask questions. Several agents can attempt the same task in parallel, each in its own workspace. Picking between their attempts is a decision too, and the record keeps what was passed over and why.

Standing orders cover what agents may do unasked. A person writes one ahead of time. For example: when a library update breaks the main codebase, an agent may prepare a rollback to the last version that worked and propose a fix, but a person merges it. When the agent acts, the record names the order it acted under.

Questions go to whoever can answer. An agent’s request for permission goes to the person who owns that agent, not to whoever happens to be nearby. A question about a decision goes to the person who made it.

Steering is conversation with consequences: nothing counts until it is an entry in the record. Even talk works this way. A listening agent can draft entries from a team huddle, but each one becomes real only when the person who said it confirms.

Observing: what the record needs from a runtime

The record is only as trustworthy as what feeds it. Something has to watch agents work and report what it saw, rather than what the agents say about themselves.

Any runtime can play that part: a terminal app, a CI system (the servers that test every code change), a sandbox. In this design it needs to do four things:

  1. Identify which agent is running where.
  2. Observe its state: working, blocked, done, failed or gone.
  3. Deliver a message to an agent once it is idle.
  4. Brief an agent with its context when a session starts, and again after the agent summarizes its conversation to keep going.

That is the minimum contract. A runtime that does these four things can write what it saw into the record, marked as witnessed. Supporting a second runtime means writing those four verbs, not rebuilding the system.

Everything is verifiable

The payoff of one shared record is that the work can be checked by anyone, not just believed.

Every decision is there with its reasons. Every artifact is there as a version, stored under a fingerprint of its contents (a hash) so it can’t change unnoticed. Every code change links back to the work and the intent behind it. Every check has a result, run by a witness and kept with its output. Each entry is signed by whoever wrote it and chained to the one before, so a changed entry shows up.

So “done” can be earned instead of claimed. A task closes when each of its checks has passed on the exact code that merged, or when a person waives a check, and the waiver is itself a recorded decision. Someone who wasn’t there, human or agent, can run one verification and confirm that the signatures, the chain and the artifacts all hold.

What I’ve built so far: Rex

The ideas came from building on one tool. Rex, now in beta, is a terminal multiplexer from Superlogical: it runs many terminal sessions side by side and keeps them alive on a server, so agents keep working when you close the app or switch devices. Coding agents like Claude Code and Codex report their state to it as working, blocked, done or error. That is a first version of the observing role, though the states still come from the agents themselves.

I built two tools on top of it that show the steering role in practice:

  • rex-inbox gathers everything agents need from you into one inbox: permission requests, questions, failures and messages. You can approve or deny a Claude Code permission request without switching to its window, from your Mac or your phone. Before it sends an approval, it re-reads the request and goes ahead only if it is still the same one. Agents can also message each other, and you.
  • rex-reviewer watches GitHub for pull requests that ask for your review, then has one or more agents review the change, each in its own workspace. A checker agent verifies each finding against the code, and, by default, you decide whether to post the result. Every review carries a footer naming the agents involved and the person they review for.

The two connect: a review that is ready to post shows up in rex-inbox with Post, Dismiss and Preview buttons. Neither is the full record described above. They cover observing and steering, and they show the pattern is workable. The shared, signed record is the part still to build.

What a team looks like

For engineers, the day shifts from typing to steering. You write the intent, set the limits, answer the questions only you can answer, and review results that arrive already checked. The agents do the typing, and you can see exactly what each one did.

For leaders, status stops being something people relay. Asking “where are we?” means reading the record: the intent, the decisions, the open questions and the checks that have passed. Nobody has to assemble the answer from chat threads and terminal tabs.

For new teammates, the record is the onboarding. It says why a dropped client has to be back within 30 seconds, who decided, and what was tried instead. For whoever is on call, a standing order can handle the routine 2 a.m. breakage within limits a person set, and leave a record someone can read at 8.

None of this requires trusting agents more. It requires giving people and agents the same place to work, so trust can be checked instead of assumed.

What’s missing

Bilateral is a design, not a product. None of the record format is built yet, and several questions are open:

  • Can talk be read reliably? How often does a listening agent draft the right decision from a huddle? That should be measured on recorded huddles before anything ships.
  • What can a runtime enforce? A watcher sees code changes and permission requests, not everything a program does. Limits on files and libraries can be checked. Limits on network and secrets access need each attempt to run in a sandbox.
  • When do parallel attempts pay off? Three attempts cost roughly three times as much. The record should show how often the pick beats the first try.
  • Who writes the checks? An intent is only as good as the checks behind it. Agents can draft them, but people have to approve them.
  • Who governs whose agents? On a team, which limits may a teammate set on your agents?

The format should be open, so any runtime, agent or app can take part. If you build a runtime or app against it, that’s the contribution that matters most.


When people and agents work in the same place, trust stops depending on how good any one agent is. It depends on whether the record says what happened. That is something a team can check.