Skip to content

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.

flowchart LR C[An agent's
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]
flowchart TD C[An agent's 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]

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 reviewer before it can merge. It is a separate agent role, not the agent that wrote the change. It reads the change against its brief 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 ledger 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-done (it reported success and nothing landed) and hollow-done (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.