Direct answer

Audit AI generated work

To audit AI generated work, you do not read more summaries. You sample the record underneath the outputs: pick outputs at random or by risk, open the receipt for the call that produced each one, and run the five checks: existence, identity, fingerprint, self-consistency, and chain. Outputs whose receipts pass are audited as recorded. Outputs with no receipt are findings, not footnotes. Run the work through Zambo and every call leaves the receipt an audit needs, checkable free by the auditor, the client, or you.

Run one audit check now: take the receipt from the live demo and audit it at zambo.dev/verify with the five checks below. The underlying method is on verify AI work.

Updated October 20, 2026.

The situation

The audit request arrives at the end of the month, the end of the quarter, or the end of the relationship. A client wants to know what the AI actually produced before the final invoice is paid. A manager wants a sample of the team AI output checked before the process is renewed. An agency wants to audit agent work across accounts before a problem in one account becomes a problem in all of them. In each case the AI claims the work was done, and someone with no stake in that claim has to check it.

Ordinary review cannot carry that weight. Reading a sample of outputs tells the auditor the outputs read well, which was never the question. The question is whether the outputs are the ones the system produced when it ran, whether the steps behind them happened, and whether anything was edited, regenerated, or quietly dropped between the run and the report. An audit answers those questions from records fixed at execution time, or it honestly reports that no such records exist.

Why screenshots and chat logs fail as evidence

Most AI audits today are really log reviews, and logs fail an auditor in specific ways. They live on the producer infrastructure, they can be filtered before export, they rotate away, and an entry proves only that a line was written in a file, not that the result attached to it is the result that came back. An auditor who accepts logs is accepting the audited party word, formatted as data.

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.

Screenshots fail an audit even faster, because an audit needs coverage and a screenshot folder has none: no way to know which outputs were not photographed, no way to recompute anything from an image, and no chain to test for gaps. An audit built on receipts is different in kind. The auditor picks the sample, the receipts recompute or they do not, and the gap rate, steps claimed with no receipt underneath them, becomes a number the report can state plainly.

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. Define the audit population first: the outputs, code changes, or agent actions claimed in the period. Then draw the sample, random plus risk-weighted, and write each sampled claim as one line the record either supports or 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. Report by the record: sampled steps that pass are verified as recorded, steps with no receipt or a broken fingerprint are findings with the step named, and the unverified share of the sample is stated in the report instead of buried under the outputs that passed.

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 audit AI generated work, 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.

How to sample an audit

Take three slices. A random slice of claimed steps, chosen by the auditor and not the producer, tests the whole population honestly. A risk slice covers the steps money or safety turns on: payments prepared, messages sent, code merged, data changed. A boundary slice covers the first and last steps of each run, where chains most often break and where work done outside the record most often hides. If all three slices pass the five checks, the audit can say so with numbers. If the random slice shows gaps, widen it before writing the report, and report the gap rate you found, not the one you hoped for.

Ways people mean this

Audit AI generated work through an API: an audit over hundreds of outputs cannot click through them one by one. Because receipts are structured records, a program can recompute fingerprints and test chain order across the whole population, and reserve human reading for the saved results behind the failures and the high-risk sample.

Audit AI generated work with open source checking: the receipt format is AER-1, an open IETF Internet-Draft, so an auditor can recompute receipts with an independent implementation rather than a dashboard supplied by the audited party. Independence of the checker is the difference between an audit and a guided tour.

Audit AI work vs logs: use logs for debugging and receipts for audit. Logs tell you what the system recorded about itself, in its own words, on its own storage. Receipts commit to a saved result at execution time and recompute in a stranger's hands. An audit opinion should rest on the second and cite the first only as context.

Audit AI work without screenshots: an audit package of screenshots cannot be sampled, recomputed, or chain-tested. An audit package of receipt links can: the auditor opens the verifier, runs the checks on the sample they chose, and extends the sample the moment a gap appears. No image folder survives that comparison.

Audit AI work: the short form covers the everyday case: a body of AI output, a claim that it was produced as described, and a checker who was not there. The method does not change with scale: population, sample, receipts, five checks, findings named by step.

Audit AI code changes: for code, audit the calls behind the diff: the edits, the commands, and above all the test runs. A change set whose test receipts recompute and match their saved results is audited as recorded; a change set with summaries instead of test records is a finding about process, whatever the code looks like.

Audit AI agent actions: agents act in sequence, so audit the sequence: every action resolves to a receipt and the chain has no gaps. Missing actions show as breaks, and an action that appears in the report but not in the chain is exactly the kind of finding an audit exists to produce.

Audit agent work: when the worker is an agent run by a contractor, a teammate, or your own automation, audit agent work the same way: sample the claimed outcomes, check the receipts underneath them, and let the record, not the relationship, decide what the report says.

What the check proves, and what it costs

A receipt-based audit proves a specific, reportable set of facts: these sampled outputs match the saved results fixed when the calls ran, these steps happened in this order, and this share of claimed steps has no record underneath it. That is a stronger audit opinion than most AI work can currently support, and it is honest about its own boundary: the audit verifies the record, and the auditor still judges quality, policy fit, and value against that verified record.

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

Audits usually fail for a boring reason: the period being audited was never recorded. The Day Pass is the forward fix for one high-stakes day at a time: for $0.99, run the client deadline day, the release day, or the overnight agent run through the Zambo MCP, and that day arrives at its audit with receipts already attached. You are not buying tool access for a day. You are making one day of work auditable by a stranger, which is the day that was always going to be questioned.

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, an audit can only sample or recompute what was recorded: a low recorded share is itself the headline finding, and no audit method turns unrecorded work into verified work after the fact. Third, receipts do not judge policy: whether the AI should have been used for a task at all is a governance question the record informs but does not settle.

Frequently asked questions

How do I audit AI generated work?

Define the population of claimed outputs, draw a sample the producer does not choose, and check the receipt under each sampled output: existence, identity, fingerprint, self-consistency, and chain. Read the saved results behind the sample instead of the summaries. Steps that pass are verified as recorded. Steps with no receipt or a broken fingerprint are findings, named by step, and the unverified share of the sample belongs in the audit report.

What is the difference between an audit of AI work and reading logs?

Logs are the audited system describing itself, on its own storage, in a form its operator can edit, filter, or rotate away. A verifiable receipt commits to its saved result at execution time, so an auditor can recompute its fingerprint at zambo.dev/verify and detect any later change. Audits rest on records a stranger can recompute. Logs are context for an audit, never its foundation, however complete they look.

Can I audit AI code changes and AI agent actions from the same record?

Yes, because both reduce to the same unit: a call with a receipt, in a chain. Code changes audit through their edit, command, and test call receipts. Agent actions audit through the receipts for each action in sequence. The auditor runs the same five checks on both, reads the saved results, and reports gaps the same way, which is why one recorded workflow can serve a code review, a client audit, and an internal review at once.

Does an audit prove the AI work was correct?

No. An audit of this kind proves the record is intact: the sampled outputs match the saved results fixed at execution time, and the steps ran in the order the chain shows. Correctness, quality, and policy fit are judgments the auditor makes against that verified record. The audit makes those judgments possible on evidence and makes the unverified share visible. It does not outsource the judgment to the receipt, and a report that claims otherwise overclaims.

How much does it cost to audit a day of AI generated work?

The checking side is free: any auditor can run any receipt through zambo.dev/verify with no signup, and the live demo is free. Recording the work costs $0.99 for a Day Pass covering 24 hours through the Zambo MCP at https://zambo.dev/mcp, 153 tools in total with 35 on the default surface. Ongoing use is the Zambo Pass at $29 a month or $290 a year, and $19 a month for $ZAMBO holders.