~/designswheelhouse
Wheelhouse
A design for teams of people and AI agents who work from one shared record. People set the course and the limits, agents do the work, and every claim says how it's known.
- Status
- Concept
- Version
- 0.1
- Published
- Reading
- 28 min
On this page
- Why a record
- Principles
- A day with it
- The model
- Entries
- How an entry is known
- Participants
- Dockets: where the work lives
- Tasks, and many agents at once
- The brief
- Living artifacts
- Questions and decisions
- Multiplayer: channels, dockets and inboxes
- Steering: how people govern
- Intents
- Boundaries
- Standing orders
- Loosening takes a countersign
- Variants
- Hold
- Verification: done is earned
- Witnessed checks
- Independence
- Verdicts and lanes
- Checks with teeth
- Results follow the patch
- The rule for done
- Claims, protocols and the audit
- The record format
- Runtimes: four verbs
- A team
- Surfaces
- Where it came from
- Open questions
- Known limits
- Glossary
Wheelhouse is a design for how a team of people and AI agents work together. All of their work goes into one shared record. People steer by writing to it: what the work must achieve, what agents may not touch, what was decided and why. Agents work from the record and add to it. Every entry says who wrote it and how it’s known, so the team can check the work instead of taking an agent’s word for it.
The work is organized three ways. A docket holds one piece of work, from the first ask to the last merge. A channel is where people and agents talk. Each person’s inbox holds only what needs them.
Kubernetes for Agents makes the case for this in plain terms. This page is the design underneath: the ideas, the parts, how people steer, how work gets verified, and how a team shares it. It describes the system as a whole, not a plan for building it.
Why a record
Agents are good at the work. What they lack is a shared place to work from. Each one holds its own version of the task: what it was asked, what it tried, what it assumed. The people hold more versions in chat threads, terminal tabs and their heads. So “where are we?” gets answered by hand, and “tests pass” gets taken on trust.
An inbox fixes part of this. rex-inbox shows what needs you right now: a permission prompt, a question, an agent that finished or failed. But it forgets on purpose. An alert clears itself, and a message is done once it’s answered. Nothing says why a piece of work exists, what was decided along the way, or whether “tests pass” was true.
Wheelhouse adds the memory and makes it checkable. The idea is borrowed from Kubernetes: write down what should be true in one shared record, and have everything read from it and report back to it. People steer by changing the record. Agents work by reading it and adding to it.
The name works two ways. A wheelhouse is the room where a ship’s crew steers together, and Kubernetes is Greek for helmsman. In baseball, the wheelhouse is the zone where a hitter is strongest.
Principles
Seven ideas carry the design. The rest of this page is how each one is built.
- The record is the truth, and everything else is a view of it. A docket is a list of entries. Its status, owner, open questions and links are worked out from those entries, never stored as facts of their own. Two people looking at the same record see the same thing, and the record can be replayed as it stood at any point.
- Every claim says how it’s known. Each entry is said (someone claimed it), witnessed (a runtime saw it happen and kept the evidence) or checkable (anyone can look it up again). “Tests pass” from an agent is a claim. A test run that a witness watched, with its output kept, is evidence. The two never look alike.
- People govern. Agents propose and build. People write and sign what the work must achieve, what’s off limits, and what agents may do without asking. Agents draft plans, attempt the work, ask questions and propose rules, and a person confirms them.
- Done is earned, not claimed. Work closes on evidence: checks that pass on the code that merged, and a verdict from someone who didn’t write it. Skipping a check is allowed, and that’s a decision a person signs.
- Talk is the interface, but talk isn’t a record. People direct agents by talking to them, in a docket, in a channel or out loud. Nothing said counts until it’s an entry, and an entry drafted from talk counts only once the person who said it confirms it.
- Files and git stay the ground truth. Wheelhouse is a layer over a repository, not a replacement for one. Diffs, review,
git blame, every editor and every CI system keep working. Agents work on branches, and their work reaches the code people stand on only through checks and a person’s merge, or a standing order that allows it. A team can adopt it one docket at a time, and leaving costs nothing. - The format is open. The record is a format, not a feature of one app. Anything can take part by playing one of four roles, and a runtime joins by implementing four verbs.
A day with it
Here’s one day for a made-up team of three engineers and their agents. Every step below leaves an entry in the record.
- 2:14 a.m. A library update breaks the tests on
main. Priya wrote a standing order for this last month: an agent may pin the last version that worked and open a pull request, but may not merge. The hub opens a docket under that order and starts an agent with its brief. The agent pins the version, the tests pass under a witness, and it opens the pull request. Then it stops. - 2:40 a.m. The order also calls for a verifier. Sam’s Codex agent checks the patch. It wrote none of the patch and runs on a different model from the agent that did, so the record counts its verdict as independent.
- 8:05 a.m. Priya’s inbox has one item: the pull request, with its checks and the verdict. Priya merges it from a phone.
- 9:30 a.m. In a huddle in the #reliability channel, the team talks through a slow reconnect. A listening agent drafts an intent (“a client that loses its connection is back within 30 seconds”) and a decision. Each speaker confirms the lines that are theirs, and the intent opens a new docket.
- 10:00 a.m. Sam starts three agents on the same task with
/variants 3. One stops at a boundary, because it wanted to add a new library. Sam picks one of the other two, and the record keeps what was passed over and why. - 11:40 a.m. An agent asks: fixed delay or jitter? The question goes to Priya, who made the last call on retries. Priya taps “jitter.” The agent gets the answer without ever having stopped work.
- 4:00 p.m. Lee joins the team and reads the docket. It says why a client has to be back within 30 seconds, who chose jitter, what was tried instead, and which checks prove it.
The model
| Part | What it is |
|---|---|
| Workspace | One team’s record. A person working alone has one on their own machine. |
| Docket | One piece of work, numbered like D-12, from the first ask to the last merge. It’s named after a court’s docket: the ordered record of every filing, ruling and piece of evidence. |
| Entry | One thing that happened in a docket: a note, a decision, a check’s result. Entries are never edited or removed. A correction is a new entry that names the one it replaces. |
| Channel | Where people and agents talk. Talk can become a docket; the work and its proof live in dockets. |
| Inbox | One person’s list of what needs them now: questions, permission prompts, picks, pull requests to merge. |
| Hub | A program on each person’s machine. It watches their agents, writes down what it saw, and serves their inbox. |
Entries
An entry is a small, signed JSON object (see The record format). There are about two dozen kinds, in four groups:
| Group | Kinds | Mostly written by |
|---|---|---|
| Talk | note, question, decision, proposal |
People and agents. A proposal is an agent’s draft, waiting for a person. |
| Work | task, claim, release, turn, artifact, variant, link |
Agents and people. The hub writes turns, releases and variants itself. |
| Governance | intent, boundary, order, set, loosen, hold, protocol, step |
People. An agent may ask to loosen a gate; only the person who set it can agree. |
| Evidence | check, lane, verdict, approval, observed |
Witnesses and sources. A verdict is a verifier’s judgment of one patch. |
The hub writes a turn each time an agent working on a docket finishes a turn. It holds the agent’s last message, the branch, the commit, whether the tree had uncommitted changes, and a hash of the full transcript. That is how a docket fills itself with no change to the agent.
How an entry is known
Every entry carries a mark, worked out from its kind and its writer:
| Mark | Meaning | Examples |
|---|---|---|
| said | An actor wrote it. It’s true if you trust them. | A note, a decision, an agent’s summary of its turn |
| witnessed | A runtime did it or saw it happen, and kept the evidence. | A check’s run and its output, an approved permission prompt, a file whose bytes match its hash |
| checkable | Read from a source anyone can read again. | A pull request’s state, a commit |
One rule follows from the marks: a docket can’t be closed on what was said.
The mark says how a fact is known. Claims about work carry three more properties, each worked out from the record: whether the verifier is independent of whoever wrote the code, whether a check has teeth (it has been seen to fail), and the exact patch a result covers. Verification covers all three.
Participants
Anything takes part by playing one of four roles:
| Role | Who | What it does |
|---|---|---|
| Actor | People, and agents like Claude Code, Codex and goose | Holds a key and signs what it says: notes, questions, decisions, artifacts. |
| Witness | Runtimes, such as Rex, tmux, Zellij, Herdr or CI | Watches agents work and signs what it saw: a turn ended, a prompt was approved, a session closed, a check exited 0. It also puts a docket’s entries in order. |
| Source | GitHub, rex-reviewer, Linear | Holds facts anyone can read again: a pull request’s state, a commit, a review round. |
| Client | Apps, the command line, MCP | Reads dockets and writes to them. |
Identity. Every participant has its own key pair. A person’s key is theirs alone. An agent’s key is issued by its owner, with an entry that says so, and stays with the agent across machines and runtimes. That gives each agent a history: turns, checks passed and failed, decisions a person later replaced. A witness signs only what it saw. It never signs on an agent’s behalf.
Dockets: where the work lives
A docket lasts as long as the work does: through many agents, many versions of a plan or prototype, many decisions, and as many pull requests as it takes. It has what an issue in a tracker like Linear has (status, priority, an assignee, labels, a project, sub-dockets, list and board views), plus three things no tracker has:
- It fills itself. The runtime already knows when an agent finishes, gets blocked, fails, or has a permission prompt approved. For an agent working on a docket, each of those becomes an entry, with no change to the agent.
- It briefs the agent. A docket compiles to a brief, which an agent reads whenever it starts or loses its memory. The work outlives the agent that began it.
- It can be checked. Every entry is signed, chained to the one before, and marked by how it’s known.
Here’s a docket, shown as text:
D-12 Fix the flaky retry test active · held by studio:inbox/claude
~/code/acme-api · opened by priya 2h ago · head 9f2c41ab
Checks
✓ tests cargo test witnessed at 4e1d9a0, 3m ago
· lint cargo clippy -- -D warnings not run
Decisions
#9 Back off with jitter, not a fixed delay priya, 1h ago answers #8
#14 Keep the 30s ceiling (standing for acme-api) sam, 40m ago
Links
PR acme/api#212 open · checks passing · head 4e1d9a0 checked 1m ago
Timeline
#1 priya opened: The retry test fails about 1 run in 20…
#8 claude said asked: Fixed delay or jitter?
#9 priya said decided: jitter. A fixed delay only moves the race.
#11 hub witnessed approved Bash: cargo test -- --ignored (priya)
#15 claude said turn: Replaced the sleep with a mock clock. Tests pass…
#16 hub witnessed check tests: exit 0 at 4e1d9a0 (clean), 41s, output a81f…
#17 hub checkable PR acme/api#212 opened at 4e1d9a0
A docket isn’t closed by its first pull request. The loop it’s built for is: ask, artifact, feedback, decision, pull request, check, and round again.
Tasks, and many agents at once
A docket has tasks. An agent claims a task, not the whole docket, so one agent can build the prototype while another writes the migration and a third reviews. A second agent that tries to claim a task someone already holds is refused and told who holds it. A docket with no tasks has one unnamed task, which keeps the simple case simple.
A claim lasts as long as the agent’s session. When the runtime sees the session close or fail, the hub writes a release with the reason. A task that was claimed, isn’t done and has no holder is stalled. It shows up in an inbox with Restart and Open, so nothing is quietly dropped. A task whose holder has done nothing a witness saw (no turn, check, push or artifact) for longer than usual is quiet. “Usual” comes from the record: how long the same step has taken before.
A task’s holder is the only one who pushes to its branch. A push from anyone else becomes an entry and an inbox item.
The brief
The brief is what an agent reads. It’s compiled from the record, within a size budget, and holds what the agent needs and no more:
- The intent, the opening ask, the repository and the status.
- The boundaries in force.
- The checks, and which of them pass.
- The decisions in force for this docket, then the standing decisions for its repository. Replaced decisions are left out.
- Directives: instructions given to this task’s agents that haven’t been done or replaced.
- Open questions, and who they wait on.
- Where the last holder stopped: its last turns, its branch and its head commit.
- How to write back.
An agent gets the brief when it starts, and again each time it summarizes its own conversation to keep going (compaction). Those are exactly the moments it has just lost its memory. Each claim records a hash of the brief the agent was given, so “was the agent told?” always has an answer.
Living artifacts
An artifact is a named file with versions: a plan, a prototype, a screenshot, a diff. Attaching retry-design.md again makes version 2. A person comments on a line of version 2, the comment goes to the agent that made it, and version 3 appears beside it. The docket then reads: v2, your comment, v3. Plannotator has this loop for plans. A docket has it for every artifact.
Files are stored under a hash of their contents, so the bytes can’t change without the docket showing it. An HTML prototype runs in a sandboxed frame on the docket page, so a prototype an agent built on a desktop machine opens on your phone.
Questions and decisions
An agent’s question goes to the person who can answer it: whoever the agent named, or else the docket’s assignee. It arrives in that person’s inbox with the options as buttons. Tapping one writes a decision that names the question, and delivers the answer to the agent. The agent didn’t have to stop and wait.
A decision can be standing for a repository, so it goes into every later brief there, and a team answers a question once. Agents look up the decisions in force before they ask. Agents may record decisions too. Theirs are marked with the agent as the actor and shown apart from people’s in the brief, and any person can replace one.
Multiplayer: channels, dockets and inboxes
A workspace is a room where people and agents are both members, each with its own key. That idea comes from Buzz, Block’s open-source workspace for people and agents. Wheelhouse adds the record. A workspace has three kinds of place, each with one job:
| Place | Holds | Belongs to |
|---|---|---|
| Channel | Talk: questions, ideas, huddles | Everyone in it |
| Docket | Work, decisions and proof | The team |
| Inbox | What needs one person now | That person alone |
From talk to work. A message in a channel is talk. Any message can be made a docket in one step, and the docket then shows as a card in the channel it came from, with its status kept current.
Talking to the work. The docket’s composer is how people direct agents. A plain message is a note. @claude sends it to that agent as an instruction, delivered once the agent is idle. @sam puts it in Sam’s inbox. /start staffs a task with an agent and its brief, and /decide, /ask, /task and /check write those entries. Any note can be made a decision afterward.
Huddles. Talk out loud is transcribed on each speaker’s own machine. A listening agent drafts entries from it: intents, decisions, tasks, questions, boundaries. They show in the docket as proposals, marked as an agent’s reading of what was said. Each becomes a real entry only when the person who said it confirms it with a tap, and a correction is the same tap after an edit. The transcript stays with the speaker; only its hash is shared. Capture is off until each person turns it on for themselves.
Focus. Whatever a person has selected on the docket page, such as a line of an artifact or one variant, goes with their next message to an agent, so “make this one async” is clear. Nothing else is tracked.
Inboxes stay private. A question for Sam is an item on Sam’s own hub, which follows the workspace. A teammate can read your dockets and write to them, but can never type into your agent, see its screen, or approve its permission prompts.
Steering: how people govern
People don’t steer by watching every agent. They write a few kinds of entry that agents work within, and the brief carries those entries to every agent on the docket.
| Lever | What it says | Example |
|---|---|---|
| Intent | What must be true, and the checks that will show it | “A client that loses its connection is back within 30 seconds, and retries from many clients don’t arrive together.” |
| Boundary | What agents may not do without asking | No changes under src/auth/, no new dependencies, no more than $20 of model spend |
| Decision | What was chosen, and why | “Jitter, not a fixed delay. A fixed delay only moves the race.” |
| Standing order | What an agent may do unasked, within which boundaries, and the checks that say it’s done | “When the tests on main fail after a dependency update, an agent may pin the last good version and open a pull request. It may not merge.” |
| Hold | Stop | One tap, on a docket, a project or the whole workspace |
Intents
An intent says what the work must achieve, in words a person would use, and names the checks that show it holds. So done means the intent was shown, not only that some commands passed. An agent can draft intents from the opening ask or a conversation, as proposals, and a person confirms them. The brief leads with them.
Boundaries
A boundary is a decision that gets enforced. It names what agents may not do without asking:
- paths they may not change, like
src/auth/**ormigrations/; - capabilities, like network access in tests, new dependencies or force-pushing;
- limits on model spend, time on a run or the size of a diff.
Every brief carries the boundaries in force. Runtimes enforce what they can see. A diff that crosses a path boundary fails a check named after it, and a standing order never answers a permission prompt that crosses one. Crossing a boundary becomes a question for the person who set it, and the answer is a decision. Agents can propose boundaries, and only people set them.
Standing orders
Agents that fix things on their own need permission given ahead of time. A standing order is a person’s decision with this shape: when this happens, an agent may do that, within these boundaries, and it’s done when these checks pass.
The hub’s watchers notice what an order names, such as the tests failing on main, a merge conflict on an open pull request, or a review that asks for changes. They open a docket under the order and staff it. Each such docket names its order, so its record says on whose authority it began. Revoking the order stops new dockets. An order can also start on a signed entry, like “when the triage agent writes bug.” An unknown signer, conflicting entries or a timeout stops the line.
Loosening takes a countersign
The agent that wants its checks to pass is the one most likely to ask for them to be relaxed. So anything that weakens a gate is a loosen entry: waiving a check, changing a pinned command, dropping a verification lane, raising a budget or widening a boundary. It takes effect only when the person who set the gate countersigns, and that person is never the one who asked. A waiver covers one patch and lapses when the patch changes. Every loosening carries a reason and an expiry.
Variants
/variants 3 on a task starts three agents, with different models or different instructions. Each works in its own git worktree, on its own branch, and runs the task’s checks. The docket shows them side by side: the size of each diff, the checks, any benchmark numbers, each agent’s summary, any prototype. A person picks one, or asks an agent to combine two. The pick is a decision that names the variants it passed over, so the reasons stay in the record.
Hold
A hold is a person’s signed order to stop writing, on a docket, a project or the whole workspace. Runtimes enforce what they can see: agents get nothing new except the hold itself, standing orders answer no prompts, and pushes to held branches are flagged. Each agent reports where it stands. Releasing the hold is one more tap.
Verification: done is earned
Once a team stops reading every line, “the agent says it’s done” isn’t enough. Cursor’s pstack, the skills Cursor’s engineers use to run fleets of agents, comes down to four questions about any claim that work is done. Wheelhouse turns each answer into a fact in the record. That’s the difference between one person trusting their own agents and a team trusting each other’s.
| Question | How the record answers it |
|---|---|
| Who checked it? | A verdict counts only from a verifier the record shows is independent of the patch’s authors. |
| Could the check have failed? | A check has teeth once a witness has seen it fail on code known to be broken. |
| What does it cover? | Every result names the patch it covered. A clean rebase carries it, and any change voids it. |
| Was it done the way the team agreed? | The steps of a docket’s protocol are checked against the record. |
Witnessed checks
A check is a name and a pinned command, like tests: cargo test. The agent decides when to run it, never what runs, so a result means the same thing every time. The witness runs it and records the exit code, the commit, whether the tree was clean, the duration, the machine, and the output, stored by its hash. A one-off command can be recorded too. It’s witnessed, but it satisfies no check.
Independence
The hub witnessed every turn on the docket, and each turn records the commit it left behind. So the record knows who wrote each commit in a patch, and the hub works out how independent a verifier is instead of taking it on trust:
| Level | Meaning |
|---|---|
| Self | The verifier wrote part of the patch. |
| Same family | It didn’t, but it runs on the same family of model as an author. |
| Independent | It wrote none of the patch, and runs on a different model family. |
| Person | A person who isn’t an author ran the checks or read the evidence. |
By default, a merge needs a verdict at independent or person. A team can change that rule with a standing decision. Across a team, the verifier is usually someone else’s agent: Sam’s Codex checks the patch Priya’s Claude Code wrote. Neither person has to trust the other’s setup. Both trust the record.
Verdicts and lanes
A verdict is one verifier’s judgment of one patch: pass, pass with notes, or fail. It names the patch, its findings, the hash of the brief the verifier was given, and the lanes it rests on. A lane is one run, with a scenario, a test for passing, and receipts such as output, screenshots or video:
| Lane | What it does | Mark |
|---|---|---|
| Gates | Runs the docket’s pinned checks at the head of the branch. | witnessed |
| Live | Drives the real app or command line through a script, the way a user would. | witnessed |
| Regression | Runs the same scenario before and after the patch. | witnessed |
| Perf | Measures one number before and after, interleaved, with the run count and range. | witnessed |
| Audit | An agent reads the diff and the receipts, and distrusts the pull request’s description. | said |
A lane that didn’t run is a gap, and a gap isn’t a pass. A finding blocks the merge only with proof: a witnessed failing run, or a line of documentation the patch made wrong. Anything else is a note. Passing CI and an approving review are inputs to a verdict, never a verdict on their own.
Checks with teeth
A check you’ve never seen fail proves nothing. A check has teeth once a witness has seen it fail on code known to be broken and then pass on the fix: the regression lane failing before the patch, a reproduction failing before the fix, or a deliberately broken copy of the code. A check without teeth shows as never seen to fail. A bug fix’s reproduction must have teeth before its docket is done.
Teeth don’t prove the tests are good ones. They prove each one can catch something.
Results follow the patch
Every check, lane and verdict records the patch it covered, as git identifies it (git patch-id), along with the commits at both ends.
- A rebase that leaves the patch unchanged carries every result forward, and the record says so.
- A changed patch makes the verdict stale. A small fix gets one fresh verifier, and new behavior gets every lane again.
- Before a merge, if
mainchanged a file the patch touches, the checks run again on the merged result.
The rule for done
A docket is done when every required check was witnessed passing on the patch that merged, with teeth where the docket asks for them, and a verdict at the required independence covers that patch. A person can waive a check, and the waiver is a signed decision. With no checks and no pull request, a person may close a docket, and an agent’s “done” becomes a question for a person: Close or Reopen.
Anyone can check a docket again later: its chain, its signatures, its artifacts, and the state of what it links to.
D-12 Fix the flaky retry test head 9f2c41ab
✓ 23 entries, chain intact, 23 signatures good (2 keys: priya's hub, sam's hub)
✓ 4 artifacts match their hashes
✓ PR acme/api#212 is merged at 4e1d9a0, as recorded
✓ check tests: passed at 4e1d9a0 (clean)
! check lint: waived by priya (#19: "clippy is broken on nightly")
✓ the PR's footer pins 9f2c41ab; 2 entries since, both observed
Claims, protocols and the audit
The record can also show how the work was done, not only whether the tests passed.
- Claims. When an agent’s summary says “tests pass,” “CI is green” or “merged,” the hub labels the claim backed (a witnessed or checkable entry since the last commit agrees), unbacked (nothing shows it) or contradicted (the latest witnessed run says otherwise).
- Protocols. A docket can run under a playbook, pinned by its hash: pstack’s Bug fix, Feature, Prototype and Shipping playbooks, or a team’s own. Steps the record can show are checked. “Reproduce first” means a witnessed failing reproduction before the first change to the code. Each step shows as followed, skipped with a reason, out of order, or not shown.
- The audit. An Attention list is worked out from the record, with no model involved. It lists a pull request head the docket has no entry for, a verdict that no longer covers the head, a required check without teeth, unbacked or contradicted claims, decisions agents made that no person confirmed, waivers in force, protocol steps out of order, and quiet tasks.
Wheelhouse ships no playbooks of its own. pstack, or a team’s own version of it, is how agents work. Wheelhouse records that work and checks it.
The record format
An entry is a JSON object:
{"v":1,"docket":"D-12","kind":"decision","at":"2026-11-09T18:04:11Z",
"actor":{"type":"person","id":"[email protected]"},
"body":"Jitter. A fixed delay only moves the race.",
"data":{"answers":"sha256:5be0…","choice":"jitter","standing":null},
"blobs":[]}
- Exact bytes. The hub stores the exact bytes that were signed and hashes those, so there are no rules about canonical form to get wrong.
- Signatures. The actor signs with its own key. Entries a witness writes, such as turns, approvals, checks and observations, are signed with the witness’s key.
- The chain. The hub that holds a docket numbers each entry and chains it to the one before: each new link is a hash of the previous link and the entry’s own hash. The newest link is the docket’s head, and eight hex characters of it name the docket’s exact state.
- The pull request pins the record. A pull request’s description carries a footer like
Docket: D-12 @ 9f2c41ab, which fixes what was known and decided when the code merged. Verifying later reports whether anything changed since. - Private evidence, shared hash. An agent’s full transcript stays on its owner’s machine. Its hash goes in the docket, so it can be produced and proven later.
- Replay. A docket’s state is computed from its entries, so it can be shown as it stood at any entry.
- The trace. Commits carry a
Docket:trailer. For any line of code,git blamegives a commit, the commit gives a docket, and the docket says why: the intent, the decision, who made it, and what was checked. Read the other way, an intent lists every file and pull request that serves it.
What a signature proves, and what it doesn’t: it proves who wrote an entry and that nothing has changed since. It doesn’t prove the agent was right, and any program running in an agent’s session can write as that agent. That’s why checks and observations come from witnesses, not from agents.
Runtimes: four verbs
A runtime, such as a terminal multiplexer like Rex or tmux, a CI system or a sandbox, becomes a witness by implementing four verbs:
| Verb | Meaning |
|---|---|
identify |
Which agent is running where. |
observe |
Whether it’s working, blocked, done, failed or gone. |
deliver |
Put a message in front of an agent once it’s idle. |
brief |
Give an agent its docket’s brief when a session starts or compacts. |
Supporting a new runtime means implementing those four verbs, not rebuilding the system.
An agent outside any runtime can still work from a docket through MCP. Everything it writes is said, because nothing watched it work.
A team
Everything above works for one person with many agents across machines. For a team, a workspace is one record that several people’s hubs write to. One hub holds the workspace, and everyone else’s hub is a client of it:
- The workspace lives on an always-on machine on the team’s private network.
- Joining registers a member’s public key under their login.
- A member’s hub signs each entry and sends it. The workspace hub checks the signature, gives the entry its place in the chain, and streams it to the other members. An entry written offline waits in an outbox, and its own timestamp says when it was written.
- Members share dockets, decisions and artifacts, and nothing else. Agents’ sessions, screens, permission prompts and alerts stay on each person’s own hub, along with starting new agents, and only the owner can reach them.
- When a permission prompt is approved inside a shared docket, the record says that it was approved, and by whom. The prompt’s text stays on the approver’s hub unless they choose to share it.
- Team dockets get the workspace’s prefix, like
ACME-12, so they’re never confused with a localD-12.
Surfaces
People work with agents on the docket page. It’s a web page, so the same page works on a phone, in a desktop browser, for teammates, and inside a desktop app’s window. Notifications stay native.
- Lists and boards of dockets, filtered to mine, waiting on me, stalled, or by project.
- The docket page, with its properties editable in place and tabs for Activity, Artifacts, Decisions, Agents and Verify.
- The composer, with
@mentions and/commands. - The trace view, which draws the repository’s modules with what’s live laid over them: the dockets touching each one, the agents working there now, the boundaries around it, and the questions waiting.
- A command line for agents and for people who prefer it, and a command palette (⌘ K) for everyone else.
Where it came from
Wheelhouse is mostly other people’s good ideas, put into one record:
- Kubernetes: write the desired state in one shared record and let everything else work against it. Kubernetes for Agents tells that part.
- Linear: the rigor of a well-made issue tracker, with its properties, views and keyboard.
- Buzz: a room where people and agents are both members, each with its own key.
- pstack: the discipline of verifying agent work. Verifiers who didn’t write the code, checks that have been seen to fail, verdicts tied to one patch, and playbooks.
- Plannotator: the inbox that rex-inbox grew from, and comments on a plan that go straight back to the agent.
Open questions
- Can talk be read reliably? The design depends on a listening agent drafting the right decision from a huddle often enough that confirming it is quicker than writing it.
- What can a runtime enforce? A witness sees diffs and permission prompts, 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 variants pay off? Three attempts cost about 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, and people have to approve them.
- Who governs whose agents? On a team, which limits may a teammate set on your agents?
Known limits
- A hub is trusted by its owner. Someone with their hub’s key can write any said entry as themselves or their agents. Signatures stop anyone else from doing that, and stop anyone from rewriting history once someone else holds a copy of the head.
- A witnessed check proves less than it sounds. It proves the pinned command exited 0 at that commit on that machine, not that the tests are good ones. Teeth narrow the gap.
- Independence is only as good as what was witnessed. A commit pushed from outside any watched session counts its git author as an author, but its model is unknown, so the verifier must be a different person too.
- An agent’s model family is declared by its owner. A person can lie about their own agent. They can’t make it pass as someone else’s, because the keys differ.
- Work outside a docket stays outside. An agent’s session that isn’t attached to a docket writes nothing until someone attaches it.
Glossary
| Term | Meaning |
|---|---|
| Artifact | A named, versioned file in a docket, stored by its hash. |
| Boundary | A rule agents may not cross without asking. A person sets it, and runtimes enforce it where they can see. |
| Brief | What an agent reads when a session starts and after compaction, compiled from the record. |
| Checkable | Read from a source anyone can read again. |
| Docket | One piece of work and its full record, from the first ask to the last merge. |
| Entry | One signed item in a docket. It’s never changed or removed. |
| Head | The newest link in a docket’s chain. It names the docket’s exact state. |
| Hold | A person’s signed order to stop writing. |
| Hub | The program on each person’s machine that watches their agents, writes what it saw, and serves their inbox. |
| Intent | What the work must achieve, with the checks that show it. |
| Lane | One verification run, with a scenario, a test for passing, and receipts. |
| Said | Written by an actor. It’s true if you trust them. |
| Standing order | Permission given ahead of time for an agent to act without being asked. |
| Teeth | What a check has once it has been seen to fail on broken code. |
| Verdict | A verifier’s signed judgment of one patch. |
| Witnessed | Done or seen by a runtime, with the evidence kept. |
| Workspace | One team’s record, held by one hub. |