The coding-agent trust gap
A coding agent finishes and reports what it did. The report is the agent's own account of its own work: files it claims to have edited, tests it claims to have run, commands it claims succeeded. "Done" is a claim, and the evidence for the claim is the claimant's testimony. When something is wrong, the debugging starts from a record nobody can check.
Verifiable receipts close the gap at the source. Instead of the agent telling you what it did after the fact, each tool call mints a receipt at the moment it runs, with the execution layer as the witness. The report becomes checkable: recompute, confirm, move on.
What a coding receipt covers
- File writes, with a commitment over the exact bytes written. Diff the recorded bytes against your repository and confirm the edit is really there.
- Test runs, with a commitment over the exit code and the output. A green test in the receipt chain means the test actually ran and passed, not that the agent said it did.
- Shell commands, with the command and what came back recorded canonically. The migration that "definitely ran" is now checkable.
- API calls and dependency changes, each as its own receipt in the same chain, sequenced so nothing can be quietly skipped.
Every receipt carries canonical input and output bytes, a SHA-256 commitment, a timestamp, and a sequence position. A gap in the sequence is visible, so a skipped step cannot hide.
The verify loop for developers
- Recompute. Each receipt's commitment is recomputed from its canonical bytes. A match means the recorded action is exactly what executed.
- Diff. Compare recorded file writes against your repository state. The code on disk should be the code in the receipts.
- Confirm the sequence. Check for gaps: every step the agent claims should have a receipt, and every receipt should be one the agent claims.
The loop takes minutes and replaces the most expensive part of working with coding agents: figuring out what actually happened. When the receipts check out, the only remaining question is whether the code is good, which is the review you were going to do anyway.
The honest boundary
Receipts prove execution, not correctness. A test-run receipt proves the test ran and passed, not that the test was a good one. A file-write receipt proves the bytes landed, not that the change was wise. An agent can faithfully execute a bad refactor and mint perfect receipts for it.
Verify execution with the receipt, and keep reviewing the code on its merits. The receipts move "did it happen" from a question to a fact, which leaves "is it right" as the only question that needs your judgment.
Start in one command
JavaScript and TypeScript agents start here:
npm install aer-1Python agents have collectors for the major frameworks on PyPI: aer1-smolagents, aer1-openai-agents, aer1-crewai, aer1-langgraph, aer1-autogen, and more. Each one turns the framework's own execution events into verifiable receipts with no change to how the agent is written.