Mission Control · In development
Agents you can
leave in a role.
Mission Control is our harness for building deterministic, specialist agents, and for the part everyone skips: proving one is good enough to hand a job to, and keeping it that way.
The board
Open a ticket, watch the rules prove themselves.
A board of what the agents are doing, and any one of them opened up. Inside, the checks re-read the finished work line by line, and the same rules are replayed over every case the agents have ever been corrected on.
The hard part
Anyone can run an agent. Almost nobody can tell you whether the one they are running is still doing its job properly.
Most agent platforms model the ticket, not the run.
They are good at tracking work: queues, assignees, statuses, a tidy history of what was asked for. The run itself, the bit where the agent actually does the job, is left unmodelled.
The run is a black box
You can see that a job started and that it finished. What the agent actually read, which tools it called, and what came back is not kept. So when the output is wrong, there is nothing to look at.
Instructions, but no enforcement
A rule written into a prompt is a hope. Nothing re-reads the finished work and checks it against the rule. A rule can be present, carried into every run, and still be quietly ignored.
Improvement means rewriting the prompt
Feedback goes into a message and evaporates. The same mistake comes back a month later, and nobody can prove it was ever fixed in the first place.
We built Mission Control because tracking the work was never the hard part.
The seven pieces
A small vocabulary, and then it all follows.
Seven ideas hold the whole system up. Each one only needs the ones above it, so you can read them in order and the picture builds as you go.
Run.
One go at one job, recorded in full.
Read the workbook, check 124 rows, write a reply. 3 minutes.
Most tools record that a job happened. A run records what happened inside it, which is the only part you can learn from.
Skill.
Something the agent is supposed to know or do.
Every item in the source has to be addressed in the reply.
This is the part every tool already has. On its own it is a wish, which is why the next two exist.
Check.
Code that re-reads the finished work and decides if the skill was honoured.
Search the reply for all 7 items. Found 5. Fail.
The agent does not get to mark its own homework. The check reads the output, not the agent's account of it.
Tier.
How much a skill is allowed to claim, worked out from what is attached to it.
No check attached, so it can only ever be advisory.
Nobody types this in. A skill with nothing enforcing it cannot be labelled enforced, so the label can never be more confident than reality.
Gate.
A check standing at the exit, deciding whether work goes out.
Coverage failed, so this reply is held and a person is told why.
This is the only point in the whole system where something is genuinely guaranteed. Everything before it is intent.
Case.
A past run, frozen, with a person's verdict attached to it.
Run 412, marked wrong, kept forever as an example of wrong.
Corrections normally live in someone's memory. A case is a correction that outlives the conversation, and can be re-run any time.
Level.
How much rope the agent has, from shadowing to holding the role.
L2: output goes out, checks run on everything, a person spot-checks.
Trust becomes a setting with evidence behind it, rather than a decision somebody made once and never revisited.
How they fit together
A skill says what matters. A check proves it on the finished work. That pairing sets the tier, and at the exit it becomes a gate. When a person disagrees with a run, it is kept as a case, and enough cases are what move an agent up a level.
The harness
The trust lives above the runtime.
Whatever executes the agent is a detail. It sits behind one contract, and every guarantee, every record and every check sits above it. Change the engine without losing the evidence.
Mission Control
claimed once, leased
warm, in a clean worktree
every call, streamed and kept
re-read the output, then publish
Everything that makes an agent trustworthy lives above that dashed line. The thing actually running the agent sits below it and can be replaced without giving any of it up.
Every part is simple. The fit is the hard bit.
Drag to turn it over. Six faces, nine parts each — individually simple, and the whole difficulty is the fit.
Three verbs
Most tools do the middle one. The other two are where an agent stops being a demo and becomes something you can rely on.
Build.
Define what the agent must never get wrong, then attach something that checks it.
Skills with attached checks
An instruction is intent. A check is a guarantee. Every rule an agent follows can carry a deterministic check that re-reads the finished output and verifies it, not the agent's claim about it.
Tiers that cannot overstate themselves
A rule's enforcement level is derived from what is actually attached to it: a check, a failing test case. Never from a label someone typed. A rule cannot claim to be enforced if nothing enforces it.
Run.
Watch the work happen, in full, while it happens.
Full run visibility
Every tool call, every argument, every result, streamed live and retained afterwards. Nothing truncated, because truncation is how the detail that mattered goes missing. You can always answer the question: what did this run actually see?
Progress you can read
A run that shows nothing for two minutes gets abandoned, even when it was about to finish. Elapsed time against a real estimate, and the checks that will run on the output, are on screen from the first second. Never a spinner pretending to be progress.
Train.
Turn corrections into something permanent, and keep proving it still holds.
A corpus that compounds
Every piece of human feedback becomes a frozen test case before anyone argues about a rule. Feedback that never becomes a rule still becomes a test. The agent's knowledge turns into an asset that accumulates, rather than a prompt someone rewrites.
Evidence-gated promotion
New enforcement ships in observe-only. It logs real hits against real work, and it is promoted on that evidence, not on confidence. A rule that starts blocking good work is demoted automatically and raised for review.
Drift detection
Fixes decay quietly. Context gets evicted, a model changes underneath you, someone weakens a rule on a bad day. So the guarantees re-prove themselves on a schedule, instead of being trusted to still hold.
What an agent is, and how it earns more rope.
On the left, everything the agent knows and whether anything actually enforces it. On the right, how a rule stops being advice and becomes a guarantee.
- source-resolutionenforced31
- output-verificationenforced12
- coverageobserved7
- value-sanityadvisory·
- legacy-ruleunreachable·
- 7 clean observations (minimum 5)
- 0 overruled by a human
- 1 case that must trip it (required)
- 3 past results change (1 outside this rule's scope)
Illustrative. Enforcement level is worked out from what is actually attached to a rule, a check or a test case, so a rule cannot claim to be enforced when nothing enforces it.
And this is where a correction sticks.
The agent's work arrives as a run, with its checks attached. One click turns a correction into a permanent test case.
Can you check coverage on this one?
source_workbook.csvuploaded by a person
“7 items identified, 7 addressed. One line needs a second look.”
Row 6 missed the fixtures line.
marked wrong, saved as test case 3662
An agent earns its role.
You would not hand a new starter the keys on their first morning. An agent is deployed into a role at a level, and it moves up on measured performance, never on a good feeling about the last few runs.
Shadow
Posts nothingWorks the real queue alongside whoever does the job today, and is compared against them. All of the evidence, none of the risk.
Draft
Every output approvedProduces real work. A human signs off on each piece before it goes anywhere.
Supervised
Spot-checkedOutput goes out. The checks enforce on every run; a human samples the rest.
Autonomous
Exceptions onlyHolds the role. A human reviews what the checks flag, and little else.
Promotion is checkable, not a judgement call. A minimum amount of history at the current level, a pass rate on the checks, a ceiling on how often those checks block good work, no unresolved regressions in the corpus, plus a human's approval at the end. Demotion runs on the same numbers in reverse. A level drop is not a failure, it is the mechanism working.
Putting an agent into a role.
This is the sequence we use on our own engagements. It is deliberately slow at the start, because the first version of an agent is never the one you want holding the job.
Start with a role, not a tool
We start from a job somebody actually does: what it has to get right, where judgement is needed, and what “wrong” looks like. One job per agent. An agent that does one thing can be measured; an agent that does everything cannot.
Write the rules down as checks
Everything the job requires that a machine can verify becomes a check. Everything else is written plainly and marked advisory, so nobody mistakes a preference for a guarantee.
Run it in shadow first
It works the real queue and posts nothing. You get a side-by-side against how the job is done today, on your own work, before anything is riding on the answer.
Feed it the corrections
Every correction becomes a permanent test case. The agent stops repeating that mistake, and you can show that it stopped rather than assuming.
Promote on the numbers
When the evidence holds, it moves up a level and takes on more of the role. When it does not, it moves back down. Either way the decision is made on measurements, not on how the last few runs felt.
Have a role in mind?
Mission Control is the harness we are building to run our own specialist agents on, and the way we decide when one is ready to hold a job.
Tell us about a job in your business you would want an agent to hold, and we will walk you through what deploying it would actually involve, including the parts that are harder than they sound.