Direct answer

Check AI code changes

To check AI code changes, you match the claim against the record, not against the pull request description. The AI says it edited three files, ran the tests, and fixed the bug. Each of those is a call, and each call that ran through Zambo left a verifiable receipt: check that the receipt exists, that it names the right tool and run, that its fingerprint still matches the saved result, that its fields agree with the claim, and that the chain of steps is complete. Then read the saved results and the diff yourself, on evidence.

Try the loop on one call first: run the live demo, check its receipt at zambo.dev/verify, then apply the same five checks to the next change your coding agent claims it made. The general method is on verify AI work.

Updated October 20, 2026.

The situation

A coding agent finishes a session in Claude Code, Cursor, Copilot, or Codex and reports success: the bug is fixed, the refactor is done, tests pass, and a pull request is ready. The description reads well because the same model that made the changes also wrote the description. You, the reviewer, now have to decide whether to merge, and the honest question is not whether the summary sounds right. It is which files actually changed, which commands actually ran, and what those commands actually returned.

This is where AI code review quietly fails today. A test run that failed can be summarized as passing. An edit that touched one file can be described as a codebase-wide fix. A step the agent skipped, a migration, a lint pass, a type check, leaves no trace in the summary at all. The searcher here is the reviewer, the tech lead, or the developer who will own this code next month, and they need the record of the session, not another summary of it.

Why screenshots and chat logs fail as evidence

Terminal screenshots are the standard evidence in this workflow, and they are nearly worthless. A screenshot of green test output shows one run, at one moment, of tests the viewer cannot identify. It does not show the failing run before it, the test that was deleted to make it pass, or whether the output came from this branch at all. Scrollback and chat transcripts have the same flaw: the operator controls them, and they record what the agent said it ran.

A screenshot shows what a screen looked like at a moment someone chose. It can be cropped, staged, retaken after an edit, or taken from a different run entirely, and nothing inside the image lets a checker tell the difference. A chat log is weaker still: it is a transcript the operator controls, it can be edited or regenerated before it is handed over, and it records what the AI said, which is the claim, not the work. Logs kept by the tool itself are better, but they are usually private, mutable by whoever runs the system, and written for debugging rather than for a stranger to check.

A receipt-based check removes the reviewer dependence on the agent account. The receipt for the test call carries its saved result, fixed when the call ran. If the summary says the suite passed and the saved result says two tests failed, the record wins, because the record was made at execution time and its fingerprint still recomputes. The reviewer needs no access to the agent session, the developer machine, or the chat history to reach that verdict.

The check, step by step

First, set the work up so there is something to check. Connect your AI client to the Zambo MCP at https://zambo.dev/mcp: one URL, no key, and it works with the clients and frameworks people already use, including ChatGPT, Claude, Claude Code, Cursor, Gemini, Grok, Codex, Copilot, VS Code, Windsurf, Cline, Zed, n8n, CrewAI, and LangChain. Zambo is the verifiable work layer for AI: 153 tools in total, 35 on the default surface, and every call made through it leaves a verifiable receipt as it runs, fixed at execution time instead of written up afterward. Then work through these steps:

Split the claim into steps. List the claims in the session summary one per line: each file edited, each command run, each test result quoted. Code claims are unusually checkable, because every line either points at a call that ran or it does not.
Run the work through the MCP. Each tool call saves its result and mints its receipt at the moment it runs. Work done outside the record leaves no receipt, so route the steps that matter through Zambo from the start.
Collect the receipts. Keep the receipt for each step with the deliverable, or gather the whole job into one handover link that carries the goal, the steps, the outputs, and the receipts together.
Open the free verifier. Go to zambo.dev/verify, enter the receipt, and run the check. It costs nothing and needs no signup, so the person checking never has to take the word of the person or the AI being checked.
Apply the five checks below to each step, then read the saved result itself instead of the summary written about it.
Decide from the record. Merge decisions follow the record. Changes whose receipts pass and whose saved results match the diff can be reviewed on their merits. Claimed steps with no receipt, or a saved result that contradicts the summary, go back to the agent or the author as unverified, with the specific step named.

The five checks

Existence: a receipt exists for the call that supposedly did this part of the work. If there is no receipt, this step is unverified, whatever the summary says. Existence is the first gate when you check AI code changes, because a check cannot start from a story.

Identity: the receipt names the tool that ran, when it ran, and which run it belongs to. That stops a receipt from a different job, a different day, or a different tool being offered as evidence for this claim, and it ties each claim to one specific call.

Fingerprint: the digest recorded over the saved result recomputes from the result itself. If anyone changed the saved result after the fact, even by one character, the recomputed digest will not match the recorded one, and the check fails in the open instead of passing quietly.

Self-consistency: the parts of the receipt agree with each other and with the claim: the tool on the receipt is the tool the claim needs, the time falls inside the run window, and the saved result is the result the claim describes. A receipt can be intact and still be the wrong receipt for this claim.

Chain: the receipts for a multi-step job link in sequence, each one pointing back to the step before it. A missing step shows as a gap in the chain and a reordered step shows as a break, so the sequence itself is checkable, not just the individual calls taken one at a time.

The whole loop is the same one described on the family anchor page, verify AI work, and the receipt underneath it is defined on what is a verifiable execution receipt. For a finished run read as one ordered record, see the AI agent audit trail. Those three pages and this one describe one method from four angles: run the work so it leaves receipts, then check the receipts instead of the story.

A worked review, in miniature

Say the summary claims three things: a function was rewritten, a regression test was added, and the full suite passes. The record should show three corresponding sets of receipts: the edit calls for the rewrite, the edit call that created the test, and the terminal call that ran the suite, in that order in the chain. Check the suite receipt last and hardest: its saved result is the one the merge decision leans on. If the chain jumps from the rewrite straight to the summary with no test call between them, the claim about passing tests is unverified, and the right response is not suspicion, it is a named gap: this step has no record, run it again through the record.

Ways people mean this

Check AI code changes through an API: receipt checks can be scripted into review: a small program pulls the receipts for a session, recomputes each fingerprint, and flags any claimed step with no receipt or a mismatched result, so a large agent-written change set gets the same check as a small one.

Check AI code changes with open source checking: AER-1, the receipt format, is an open IETF Internet-Draft, so the checker does not have to trust a dashboard owned by the tool that wrote the code. An independent implementation can recompute the same receipts, which matters most exactly when the change is disputed.

Check AI code changes without screenshots: replace the terminal screenshots in the pull request with receipt links, or one handover link for the whole session. The reviewer opens the verifier, runs the five checks on the test call and the edit calls, and reads the saved results directly.

Check AI agent actions: a coding session is a chain of agent actions: searches, reads, edits, terminal runs, and retries. Checking agent actions means each one resolves to its receipt, so a claim like the agent searched the codebase before editing is itself checkable, not just the final edit.

Check agent task completion: a task is complete when every claimed step has a receipt and the chain has no gaps, not when the agent says it is finished. Check agent task completion by walking the task list against the record: done means recorded, and anything else means open, however the summary phrases it.

Check tool calls: each tool call is the atomic unit: the tool that ran, when it ran, and the result it saved. To check tool calls, recompute the fingerprint on each receipt and read the saved result, especially for the calls the summary leans on hardest, like the final test run.

What the check proves, and what it costs

For code, this discipline pays off immediately. Review gets faster, because the reviewer starts from what ran instead of reconstructing it. Disputes get shorter, because the saved result of the test call settles what the summary argued about. And the next developer inherits a record of how the change was actually made, which tools ran in which order, instead of a commit message written to sound tidy. The diff still gets read. The code still gets judged. It just gets judged against the truth about how it was produced.

What it proves is narrow and useful: the saved result on the receipt was not changed after the fact, the call it records is the call the claim points to, and a multi-step job ran in the order its chain shows. That is the floor every argument about AI work currently lacks. Run the loop once on a real call first: the live demo runs one call and hands you its receipt, free, in about ten seconds.

The Day Pass is the fix for a day of unverifiable work

One day of agent coding can touch hundreds of files and leave nothing behind but summaries. That is a day of unverifiable work, and the Day Pass is priced for exactly that day: for $0.99, route the day of work through the Zambo MCP so each call leaves a receipt, and the evening review checks the record instead of interrogating the chat. If the day goes well, you have spent less than a dollar to make every change from it checkable by anyone, forever.

For $0.99, a Day Pass covers 24 hours of recorded work through the Zambo MCP at https://zambo.dev/mcp. Ongoing use is the Zambo Pass at $29 a month or $290 a year, and $19 a month for $ZAMBO holders. Public handovers are free to send and free to open. Humans pay by PayPal or card through PayPal; agents pay USDC on Base through x402. Checking any receipt at zambo.dev/verify stays free either way.

Honest limits

Three edges, stated plainly. First, A verifiable receipt proves the saved result was not changed after the fact; it never proves the result was right, the work was well done, or the price was fair. That judgment stays with the checker, now made against a record that was actually checked. The record also only covers steps that ran through connected tools: work done entirely outside it has no receipt, and an honest record lists that work as unverified instead of smoothing it over. AER-1, the receipt format underneath, is an IETF Internet-Draft (draft-zambo-aer1-24), not a finalized standard. Second, a receipt for a test call proves what that run returned; it does not prove the tests were the right tests, that coverage was adequate, or that the code is well designed. Review judgment stays human. Third, the record covers calls made through connected tools: a manual edit in an editor outside the record has no receipt, and an honest session record lists it as unchecked.

Frequently asked questions

How do I check AI code changes before I merge?

Split the session summary into claims, one per edit, command, and test result. For each claim, open the receipt for the call behind it and run the five checks: existence, identity, fingerprint, self-consistency, and chain. Read the saved result of the test calls yourself instead of trusting the summary line about them. Claims that pass get reviewed on their merits. Claims with no receipt go back as unverified before the merge, not after the incident.

How can I check tool calls an AI coding agent made?

Each tool call made through the Zambo MCP leaves a verifiable receipt naming the tool, the run, and the saved result. Paste the receipt into zambo.dev/verify and the check recomputes its fingerprint over that result: if the result was changed afterward, the check fails. Work through the calls in chain order and you have checked the session itself, not the story the agent told about the session.

Does checking a receipt prove the code is correct?

No. A receipt proves the saved result of a call was not changed after the fact, and it shows you exactly what ran and what came back. Whether the code is correct, well designed, or adequately tested is a review judgment, and it stays yours. The difference is that you now make it against the real record of the session, including the test results the agent actually got, instead of against its summary of them.

Can I check agent task completion without screenshots of a terminal?

Yes. Task completion is a record question: every step the agent claims either has a receipt whose fingerprint recomputes and whose saved result matches the claim, or it does not. Send the reviewer the receipt links or one handover link for the session. They check them free at zambo.dev/verify with no account and no access to your machine. A step evidenced only by a terminal screenshot counts as unverified, and naming it that way is the useful outcome.

How much does it cost to check a day of AI code changes?

Checking receipts is free at zambo.dev/verify, and the live demo is free. For $0.99, a Day Pass covers 24 hours of recorded work through the Zambo MCP at https://zambo.dev/mcp, 153 tools in total with 35 on the default surface, so a full day of agent coding leaves receipts a reviewer can check. Ongoing use is the Zambo Pass at $29 a month or $290 a year, and $19 a month for $ZAMBO holders.