Verify AI work: check the record, not the summary.

Why the summary cannot verify itself

Ask an AI whether its work is done and it will tell you, fluently. The answer is produced by the same system that did the work, from the same context, with the same blind spots. When the work went wrong, the summary usually goes wrong in the same direction: steps that silently failed get described as completed, and results that were never observed get reported as facts.

Verifying AI work means stepping outside the narration. The claim is one thing. Underneath it there either is or is not a record of the calls that did the work, made when the calls ran. Verify the record, and the claim becomes checkable. Without a record, there is nothing to verify, only something to believe.

The verification loop

1. Claim. Write down what the AI says it did, step by step, in its own words.
2. Observe. For each step, find the execution record: the tool call, its inputs, and the output the system actually observed. On Zambo every call leaves one automatically, at a public receipt URL.
3. Compare. Recompute each record's hash commitment (or run it through the verifier) to confirm the record is intact, then compare the recorded output against the claim. Steps with no record, or a record that does not match the story, are exactly where the work needs a second look.

Claim, observe, compare. The loop is small on purpose: it fits in minutes, it works on work you ran and on work someone hands you, and it does not require trusting the AI, the operator, or the platform in between.

What is AER-1?

AER-1 (Agent Execution Receipt, version 1) is the open format for the receipts this page keeps pointing at: for each step of AI work it defines a verifiable receipt carrying the saved result and a digest over it, fixed at execution time, plus the workflow record that links a run's receipts in sequence. It was created by Brennan Zambo and is published as an IETF Internet-Draft, currently draft-zambo-aer1-23, so any tool can mint receipts in the format and any receiver can check them with no account on the system that produced them. The full definition, in plain words: What is AER-1?

What to demand from any AI tool

• A record per call, not a summary per session.
• Commitments made at execution time, not descriptions written afterward.
• Records a stranger can check, at public URLs, without your account or permission.
• Gaps that stay visible: a step that did not run should read as not run, never get smoothed into the narrative.

Any system that gives you those four gives you verifiable work. The open format for the records is the AI agent receipt, specified by AER-1 (draft-zambo-aer1-23). Demand the same discipline on the money side of the work: an agent that can spend should run under a cap recorded the same way, which is the problem how do I stop my AI agent from overspending answers with a live $0-cap example.

Try the loop on a real call

The live demo runs one real call and returns its receipt in about 10 seconds. Check the receipt, then check a step the demo did not take: there is no record for it, and that absence is the lesson. Work through the worked example above the same way: open receipt 588f5158-e335-4ba8-9009-72fad8410d55 and recompute its digest. Your AI said "done." For $0.99, prove it: a Zambo Day Pass puts a verifiable receipt under every call for 24 hours.

Questions, answered

AI agent output verification service

What the service has to do. An AI agent output verification service checks an agent's output against a record that was fixed when the work ran. That requirement rules out most of what is sold under the name: a second model grading the first model's answer is an opinion service, not a verification service, because both the answer and the grade can change after the fact and neither is committed to anything. A verification service worthy of the name recomputes: it takes the saved result, recomputes its digest, and compares it to the commitment recorded at execution time.

Zambo is the verifiable work layer for AI, and its verifier is public: paste a receipt link into the verifier and the checks run in the open, no account required. What it proves is narrow and stated plainly: the saved result was not changed since it was saved. Judging whether the result is good remains your job, now done against a record you checked.

AI agent work verification

The definition that holds up. AI agent work verification is the practice of checking agent work against per-step verifiable receipts instead of against the agent's own report. Each step of the work resolves to a receipt; each receipt's saved result can be recomputed and read; the sequence of steps is accounted for by a workflow record. Work that resolves this way is verified work. Work that exists only as a summary is reported work, and the two should never be priced, approved, or shipped as if they were the same thing.

The practice scales down as well as up: verifying one call takes under a minute, and verifying a hundred-step run is the same operation repeated, plus the sequence check. Start with the call a dispute or a payment turns on. Where a person had to approve the work before it shipped, the approval is a record of the same kind: what record proves a human approved AI work walks one real acceptance field by field.

Verify AI agent output

Output is the weakest thing to verify directly. A polished output proves only that something produced text, code, or numbers. To verify AI agent output, go one level down: find the receipt for the call that produced it, recompute the digest over the saved result, and confirm the output you were handed is the saved result, unchanged. If the output was edited, regenerated, or summarized on its way to you, the comparison shows it, because the saved result is fixed and the handed-over version either matches it or does not.

Where there is no receipt, there is no verification path for that output, only plausibility. That is the honest answer, and it is why receipts have to be captured at execution time rather than reconstructed later. When the output leans on sources, the check extends one level further: how do I know my AI actually opened the sources it cited is answered by the per-step source states recorded on the handover.

Agent execution verification

Verifying the execution, not the story about it. Agent execution verification asks a narrower question than output review: did this call actually run, with these inputs, and is this the result it produced at the time? A verifiable receipt answers exactly that, because it is minted at execution time and commits to the saved result. The chat transcript, the final summary, and the dashboard all answer a different question: what does the agent, or its operator, say ran? Those accounts are produced after the fact by interested parties, and they can be edited without leaving a mark.

Keep the claim narrow while you verify: a receipt proves the saved result was not changed since it was saved. It does not prove the call was the right call or the result was correct. Execution verification is the floor, not the ceiling, and it is the floor most agent work currently lacks.

Independent verification of AI agent work

Independent means the checker needs nothing from the checked. Independent verification of AI agent work is possible only when the evidence was fixed at execution time in a form a stranger can recompute: a public receipt, its saved result, and a digest over that result. The verifier needs no account on the producing system, no cooperation from the operator, and no trust in either. If checking the work requires asking the agent's platform whether the work is genuine, the verification is not independent, whatever it is called.

That independence is the reason the receipt format is an open draft, AER-1, IETF Internet-Draft revision 23, rather than a proprietary report: any implementation can mint receipts and any receiver can check them, so verification survives the producer disappearing, being acquired, or simply being wrong. The same independence is what a client gets at delivery time: disclose the AI use with the record attached, and the client checks it without asking the producer for anything.

How to verify AI agent work

Start from the problem: the summary is the claim, not the check. You asked an AI agent to do a job and it handed back a confident summary. Learning how to verify AI agent work means refusing to grade that summary on how it sounds and checking it against a record instead. Split the summary into individual claims: each file it says it wrote, each message it says it sent, each number it says it pulled. Every claim either has a record underneath it or it does not, and that split is the whole method.

For each claim, open the verifiable receipt for the call that supposedly did the work. Recompute the hash commitment over the saved result and confirm it matches the commitment fixed at execution time, then read the saved result itself rather than the agent's description of it. Claims that recompute and match are verified. Claims with no receipt, or a saved result that does not match the summary, are unverified, and unverified claims get redone or repriced, not believed. When the work also has to satisfy an auditor later, the same receipts serve as the AI agent audit receipt record for the run.

The reason most agent work cannot be verified is that nothing was recorded while it ran, and a check that starts after the fact has nothing solid to start from. Zambo is the instrument that fixes that: calls made through Zambo at zambo.dev/mcp leave a verifiable receipt as they run, so verification becomes recompute and read instead of reconstruct and guess. A $0.99 Day Pass turns that on for 24 hours, which solves the problem this page started with: the next job your agent runs arrives with its evidence attached. Keep the claim narrow: a receipt proves the saved result was not changed since it was saved. It does not prove the agent picked the right tool or the right answer, and that judgment stays with you, now made against a record you actually checked.