How agent output is trusted¶
I design the checks so that an agent can't approve its own change.
Status: in daily use · checked Oct 23, 2026
In plain terms
Changes in the main repositories require independent review and checks against the resulting code or running system. Every change is asked three questions, and a different mechanism answers each one.
change] --> A[Is it allowed?
guards on commands
and pushes] A --> R(Is it reviewed?
an independent reviewer,
a separate AI agent):::guard R --> T[Is it true?
evidence,
not assertion] T --> M[Merge]
commands and pushes] A --> R(Is it reviewed? An
independent reviewer, a
separate AI agent):::guard R --> T[Is it true? Evidence,
not assertion] T --> M[Merge]
I ask three things of every change.
| Question | Answered by | What makes it hard to get around |
|---|---|---|
| Is it allowed? | guards on commands and pushes | the guards sit in the tool and in git, so a forgetful agent is stopped anyway, and each guard is checked to be alive |
| Is it reviewed? | every pull request in the main repositories must pass an independent AI review gate | the result can be posted by exactly one identity, and administrators can't skip it |
| Is it true? | evidence, not assertion | "done" is the worker's own result event, never an exit code, and closing a task needs a record of why |
Is it allowed?¶
Before an agent runs a command or pushes code, hooks and git-level backstops decide whether that action is permitted at all: destructive commands need a written reason, history-destroying operations are refused, and a push is a two-step handshake with a checklist. The guards themselves are checked to be alive, and real refusals are logged. That layer is described in Guard rails.
Is it reviewed?¶
Every pull request in the main repositories has to pass the independent reviewerIn the main repositories, a separate agent whose recorded decision is a required pull-request check; only its identity can post it. Glossary before it can merge. It is a separate agent role, not the agent that wrote the change. It reads the change against its briefThe bounded instructions given to a dispatched worker before it edits or runs commands. Glossary and against the checks that ran on that exact version, and decides pass or fail.
The reviewer is a separate agent with its own prompt and guardrails. It comes from the same vendor family as the authors, so it is independent in role, not in training.
The reviewer exists because of an incident. In September a worker agent merged its own pull request with no review at all. Nothing mechanical stood in the way, so I added a required review check that blocks a merge without the reviewer's recorded decision:
- One identity can post the result. The review result is a required status check on the pull request, and it can only be posted by one dedicated reviewer identity. No other account, token or application can satisfy it, and administrators can't skip it.
- Workers can't post it. The posting step refuses to run inside a dispatched worker, so the agent that wrote a change has no way to approve it.
- The decision is written down first. The reviewer records its decision in its own ledgerThe run ledger: relational records of dispatched runs, with reapers and stall timers. Glossary before anything is posted. The step that posts to GitHub refuses to post anything the ledger doesn't already say, for that exact version of the change.
The ordinary automated checks still run on every pull request as well: the test suites, the documentation checks and the leak scans. The reviewer is an addition to them, not a replacement.
Is it true?¶
An agent saying it finished is a claim, not evidence. The rules below turn it into something checkable.
"Done" means the worker's own result. Dispatched work is recorded in a run ledger, and a run counts as done only when the worker's own result event says so. A process that exits cleanly proves nothing. The ledger tells false-doneA worker reports success but nothing useful landed; the ledger makes this class visible. Glossary (it reported success and nothing landed) and hollow-doneA worker exits cleanly with an empty result; treated as a failure class in the ledger. Glossary (it exited cleanly with an empty result) apart from done. How that works is in Lanes and the run ledger.
Closing a task needs evidence. A task that moves to a closed state should carry a typed record of why: which change landed, which named set of checks ran, who closed it, and when. The named set matters. A change once merged with every check that ran green while other required checks had been skipped, which is why "CI is green" isn't evidence about a particular closure.
Where each part stands¶
Here is where each part stands.
| Part | Status |
|---|---|
| Guards on commands and pushes | running; each is checked to be alive |
| Independent review of every pull request in the main repositories | built and running |
| Closing a task with evidence | built, rolling out |
The reviewer closes the failure I actually had: a change can no longer merge into a main repository without the independent reviewer's recorded decision.
What this costs¶
More moving parts: a reviewer role, its decision log, a relay, and the discipline of keeping workers out of all of them. Each of them exists because of one incident, which is the same reason the guards exist. The incidents are in Incidents and the fixes they produced, and the habit of proving a check can fail is in the verification standard.