Verification
The checks between “finished” and merged.
Tested by the agent that wrote it, at every commit.
The engineer agent writes the unit and integration tests the change needs. It runs your project’s quick checks before every commit and the full suite before the change merges. You set the commands once per project, so every agent meets the bar your team already keeps.
- Unit and integration tests, written with the change
- Your project’s checks before every commit
- The full suite once more before it merges

Every screen it touched, checked at phone and desktop widths.
You see every screen the change touched, as the agent saw it. It opens each one in a real browser on its own running copy of your app, at phone and desktop widths, and checks that the text is readable, every line is whole and the layout is what the task asked for. The screenshots go into the task’s report next to its judgement.
- A real browser on a running copy of your app
- Phone and desktop widths
- Screenshots in the report

Read by a security reviewer, the way an attacker would.
A security reviewer reads every change the way an attacker would, looking for untrusted input, leaked secrets and access a person should not have. The agent fixes each blocker it raises before the change moves on. The verdict and the advice it acted on go into the report, next to the independent review’s.
- Input, secrets and access, read for holes
- Every blocker fixed before it merges
- The verdict in the report

The bug, reproduced first. Then fixed.
Hand over a bug and the agent makes it happen before it touches the code. It reproduces the failure on a running copy of your app and writes down what happened and why. The fix is checked against that same reproduction, and the report shows the failure, its cause and the fix.
- The failure, reproduced on your app
- Its cause, written down
- The same check again after the fix

Built by one agent, read cold by another.
The engineer agent that built the change checks the whole of it before anyone else sees it. A second, independent agent then reads it cold, from the change and the ask alone, and a verifier checks the fixed result against the ask before it merges. Every point raised is fixed, or left as built with the reason written down. Agents work in parallel, around the clock, and a change handed over at night is reviewed the same way.
- One full-stack engineer, start to finish
- A second agent reviews it cold
- A verifier signs off before it merges

A signed record of every check it passed.
When the task is done, what it passed is sealed into its compliance manifest and signed: the sessions that ran, the commits they made and the checks those commits passed. Anyone you hand it to can verify the signature with the published key, in the console or offline.
- Every check it passed, sealed
- Signed, with the key published
- Anyone can verify it, even offline

What “done” means
What every change clears on the way to done.
A task reaches done once its change clears every item that applies to it, and the report shows each one.
- Unit and integration tests written, and your checks passing at every commit
- Each screen it touched seen in a browser at phone and desktop widths, with screenshots in the report
- A security review, with every blocker fixed
- For a bug, the failure reproduced before the fix and checked again after it
- A review by a second, independent agent, and a verifier’s sign-off against the ask
- A signed record of all of it that anyone can verify
Hand over a change. Get back a verified one.
Every change comes back tested, reviewed and signed. Start free, and pick the plan once you know how many agents you want running.