The four criteria that decide it
- What does the record commit to? A record can commit to nothing (the agent's own words), to the platform's copy of events, or to the exact bytes of each call bound by a hash. Only the third survives an edit.
- Who can verify it, and do they need the vendor? A check that only runs inside the vendor's dashboard requires trusting the vendor. A check anyone can recompute from published bytes requires trusting no one.
- Does it cover a multi-step run as one unit? Real agent work is a sequence. Verification that treats each call separately, with no binding over the set and its order, cannot detect a missing step.
- What does it cost? Checking should be free or close to it. If verification is priced like a luxury, it will be skipped exactly when it matters.
The comparison
| Approach | What the record commits to | Independent verification | Multi-step workflows | Typical cost |
|---|---|---|---|---|
| Verifiable execution receipts (AER-1) | The canonical bytes of each call: tool, inputs, observed output, plus evidence, bound by SHA-256 commitments made at execution time. | Yes. Anyone recomputes the hashes from the published bytes. No account, no vendor cooperation, no trust in the issuer. | Yes. One receipt per step, the set bound under a single workflow root; a run can be sealed so its page, badge, and PDF pack stay permanent. | Free to verify. Free tier to mint; $0.99 Day Pass for a full day at Zambo, the hosted implementation. |
| Chat transcripts and run summaries | Nothing. The text is the agent's own narration of what it believes it did. | No. Checking the story means asking the same agent, or having another model grade the story. | No. A narrative has no step boundaries a checker can test. | Included with the agent. |
| Platform activity logs and traces | The platform's own event records. Useful and detailed, but held and editable by whoever controls the platform. | Only inside the vendor's dashboard. An export is the vendor's copy, checked against itself. | Partial. Traces group calls into runs, but the grouping is the vendor's record of the run. | Bundled with the platform, or per-seat pricing. |
| Evaluation suites and benchmarks | Scores on sampled test tasks. They measure how an agent performs on the test set, not what it did on your run. | The scores are reproducible on the test set. They say nothing about a specific production run. | No. Evals sample tasks; they do not bind a run's steps. | Free open source up to enterprise contracts. |
| State readback checks | A fresh read of the system of record, taken after the agent claims the work is done. | Yes, for state claims: the database, file, or API answers directly, whoever asks. | Per claim, not per run. Each claimed effect needs its own check. | Usually free. You write and maintain the checks. |
| Human review | A person's judgment, recorded as an approval. Catches wrong work that no hash can catch. | The reviewer is the check. Quality varies with attention and expertise. | Manual at any scale. Review time grows with every step. | The most expensive option per run: reviewer time. |
Two honest notes on the table. First, the approaches compose: receipts plus readback is the strongest common pattern, because the receipt proves the record was not changed and the readback proves the claimed effect exists. Second, no row in this table proves the agent's answer was correct. Verification settles what the record says and whether the state matches. Judging whether the work was good remains a human job, now standing on evidence instead of narration.
Which approach for which job
- You need proof for a client, an auditor, or a dispute: verifiable execution receipts. The check has to work for someone who trusts neither you nor your agent.
- You are debugging an agent you are building: platform traces. Nothing beats a detailed trace while you can still change the system.
- You are tracking quality across many runs: evaluation suites, with receipts underneath so a bad score can be traced to the exact recorded calls.
- The agent changes real state (records, files, money): receipts plus state readback, every time. The receipt binds the claim; the readback tests it.
- The stakes are judgment calls, not facts: human review, with receipts as the reviewer's evidence pack instead of screenshots and summaries.
Check the receipt approach yourself
- The worked example: how to verify an AER-1 receipt runs the three checks against a real public receipt, with the actual numbers.
- The companion roundup: Best AI Agent Verification Tools in 2026: What Actually Proves the Work Happened covers the same ground in article form.
- The format: AER-1 is an IETF Internet-Draft, draft-zambo-aer1-23. A draft, not a finished standard. The open conformance kit and its test corpus are on GitLab, so any implementation can be checked against the same vectors.
- See one minted: the one-click demo runs a real call and hands you the receipt, no signup.
- Keep a run permanently: a Day Pass ($0.99) seals a workflow so its page, verify badge, and PDF pack stay put after the free viewing window.
AI agent verification tools: FAQ
What are the best AI agent verification tools in 2026?
It depends on the job. For proof that a specific run happened as recorded, verifiable execution receipts in the AER-1 format are the strongest option, because anyone can recompute the commitments from published bytes without the vendor. For debugging during development, platform traces are the most useful. For quality trends across many runs, evaluation suites. For high stakes state changes, receipts plus a fresh readback of the system of record.
What should an AI agent verification tool actually prove?
At minimum, that the record of the run was not changed after the fact: which tool ran, the exact inputs, the observed outputs, and when, bound by a commitment a third party can recompute. Verification cannot prove the agent's answer was correct or the work was good. Any tool claiming to prove correctness from a record alone is overselling. Judge for yourself with the free verifier.
What is the difference between a transcript, a log, and a verifiable receipt?
A transcript is the agent narrating its own work, written by the process being checked. A log or trace is the platform's record of events, controlled by whoever runs the platform. A verifiable receipt is a commitment: the canonical bytes of the call plus a hash anyone can recompute, so the record can be checked by someone who trusts neither the agent nor the platform.
How much does AI agent verification cost?
Checking a receipt is free: the verifier at zambo.dev/verify runs in the browser with no signup, and the open AER-1 conformance kit runs the same checks offline. Minting receipts through Zambo has a free tier, and a Day Pass costs $0.99 for a full day of coverage, including sealing a workflow run permanently with its page, badge, and PDF pack.
Can I verify AI agent work without trusting the vendor?
Yes, when the verification is recomputation. An AER-1 receipt publishes its canonical bytes and its commitments, so you can hash the bytes yourself and compare, with no account and no vendor cooperation. If a tool's check only works inside the vendor's own dashboard, the check itself requires trusting the vendor. Start with a real receipt from the live demo and check it yourself.
Is there a free AI agent verification tool?
Yes. The verifier at zambo.dev/verify is a free AI agent verification tool: paste a receipt link, and the checks run in the browser with no account and no payment, because verification is recomputation over published bytes. The live demo at zambo.dev/demo mints a real receipt for free, so you can test the verifier on a record you watched being made. What free verification cannot do is check work that left no receipts: unrecorded work has nothing to recompute, whichever tool you use. Paid Zambo tiers buy the doing, the tool calls that mint receipts; the checking itself stays free.
Free AI agent verification tool
The check itself should cost nothing. A free AI agent verification tool matters because verification only works as a habit, and habits do not survive a paywall at the moment of doubt. The public verifier at zambo.dev/verify is free with no account: paste a receipt link and the checks run in the open. The live demo is also free and mints a real receipt in seconds, so you can test the verifier on a record you watched being made before you ever rely on it for someone else's work.
Zambo is the verifiable work layer for AI. The paid tiers buy the doing, a day or a month of tool calls with a receipt under each one. The checking stays free, permanently, because a receipt only a paying customer can verify is not evidence for anyone else.
How to run a free check, step by step. Take any receipt link, your own or one a contractor sent you, and paste it into the verifier. The checks recompute the commitment from the saved result and compare it with the commitment recorded when the call ran. Then read the saved result itself: the tool that ran, the inputs it received, what actually came back. Finish by writing down the split, steps that verified and steps with no receipt behind them. That split is the answer the free tool gives you, and it costs nothing to get it for every job, not just the suspicious ones.
The limit, stated plainly: free verification checks records that exist. If the work ran somewhere that left no receipts, no tool, free or paid, can check it after the fact, because there is nothing to recompute. The fix is upstream: run the next job where every call mints a receipt. For $0.99, a Day Pass covers 24 hours of tool calls with a receipt under each one, which makes tomorrow's work checkable for free, forever, by anyone you hand the links to. Ongoing use is the Zambo Pass at $29 a month or $290 a year, $19 a month for $ZAMBO holders.