Direct answer

Validate AI work

To validate AI work, you check each claimed result against two things: the criteria the work was supposed to meet, and the record of what actually ran. The record half is mechanical: for each step, a verifiable receipt must pass the five checks, existence, identity, fingerprint, self-consistency, and chain, and its saved result is the result you judge against the criteria. Work validated this way, through Zambo receipts that anyone can check free, is validated on evidence. Work validated from the agent summary alone is merely approved.

Validate one call end to end: run the live demo, then validate its receipt at zambo.dev/verify against the claim the demo makes about it. The general method is on verify AI work.

Updated October 20, 2026.

The situation

Validation is what happens in the last hour before acceptance. A deliverable built with AI, research, code, content, data work, is ready according to the agent that produced it, and someone has to decide whether it meets the brief before it goes to a client, into production, or onto an invoice. The agent claims the task is complete and the output is correct. The validator, a reviewer, a client, an agency lead, or the freelancer who will put their name on it, has to turn that claim into a decision they can defend.

The failure mode is familiar: validation collapses into reading the output and nodding, because there is nothing else available to validate against. The output reads well, so it ships, and the defect, the invented source, the skipped step, the wrong number, surfaces later at a worse address. Real validation needs the layer under the output: which calls produced it, what those calls returned, and whether the chain of steps the brief required is actually complete.

Why screenshots and chat logs fail as evidence

Screenshots and logs cannot support validation, because validation is comparative: claim against criteria against record. A screenshot contributes no record, only an image of a state. A log contributes a self-description the producing system can edit, with no commitment tying an entry to the result it describes. Neither lets a validator detect the most common AI work defect of all: the step that never ran, silently absorbed into a summary that reads as if everything 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.

Receipts support validation precisely where screenshots and logs collapse. Existence exposes the skipped step. Identity stops a result from a different run being validated against this brief. The fingerprint fixes the result so the thing validated is the thing that was produced, not a later cleanup. Self-consistency ties the receipt to the claim being validated, and the chain shows the required sequence is complete. Five checks, each aimed at a way validation gets fooled.

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. Write the validation list from the brief, not from the agent summary: each deliverable element, each required step, each number that must trace to a source. Then map each item to the call that was supposed to produce it. Items with no call to map to fail validation before the checking even starts.
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. Validate per item: pass when the receipt passes the five checks and the saved result meets the criterion, fail by name when either side fails, and send failures back as specific items to rerun through the record, not as a general request to try again.

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 validate AI 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.

Ways people mean this

Validate AI work through an API: validation scales when it is a program: recompute the receipt fingerprints for a run, test the chain, and return a per-claim verdict list a human then judges against the criteria. The mechanical half runs in seconds, which moves human time to the judgment half, where it belongs.

Validate AI work for agencies: an agency validates work it did not personally watch, across clients and freelancers and agents. One record format across all of it means one validation routine: receipts under every deliverable, a sample deep-checked per client, and a handover link the client can validate from as well.

Validate AI work for freelancers: a freelancer validating AI work before delivery is protecting their name. Run the five checks on the steps behind the deliverable, read the saved results for the claims the client will repeat, and deliver with the record attached, so the client validation starts from your evidence instead of your assurance.

Validate AI work for a small business: a small business has no QA department, so validation has to be a short checklist one person can run: the receipts exist, the fingerprints pass at the free verifier, the saved results match the summary, and the gaps are named. Fifteen minutes against the record beats either blind trust or redoing the work in house.

Validate AI work for teams: a team validates against a shared record: the same receipts, the same criteria list, the same verdict per step, visible to everyone. That kills the common team failure where two reviewers validate two different versions of what the AI did, from two different chat threads, and both sign off.

Validate agent task completion: a task validates as complete when every required step maps to a receipt, the chain has no gaps, and each saved result meets its criterion. Anything less is a partial task with a confident label, and validation is the moment to relabel it accurately, by step.

Validate AI agent actions: actions validate individually and in sequence: each action receipt confirms the tool and its result, and the chain confirms the order the brief required. An out-of-order or missing action is a validation failure with a name and a position, not a suspicion.

Validate AI output: output validates by comparison and by criteria: the shown output must equal the saved result on the receipt, and the saved result must satisfy what the brief asked for. The first half is mechanical and the fingerprint settles it. The second half is judgment, and it should be exercised on the proven result, not on a regenerated cousin of it.

Validate tool calls: validating tool calls means the calls themselves were the right calls, made with the inputs the brief implies, returning results the record preserves. Check the high-stakes calls first: the data pull behind the headline number, the send behind the claimed outreach, the write behind the claimed update.

Validate what my AI did: the retrospective form: reconstruct the run from its receipts in chain order and validate the reconstruction against the original ask. What your AI did, in order, with results, is the chain. What it claimed beyond the chain is the validation report's most honest sentence.

What the check proves, and what it costs

Validation on a record proves the decision was earned. When the client questions the deliverable, when the number turns out wrong, when the agency reviews the freelancer, the validation trail shows what was checked and what the record said at the time. That trail also improves the next job: the steps that fail validation repeatedly are the steps the brief, the prompt, or the tooling needs to change, and the record says which ones, with receipts, instead of leaving the lesson as a feeling.

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

The work most likely to be validated hard is the work done under deadline pressure, which is also the work least likely to be recorded unless someone decides in advance. The Day Pass is that decision, for $0.99: one day of AI work, run through the Zambo MCP, every call receipted as it runs, so the validation at the end of the day is a checklist against a record instead of an excavation. You are not buying tool access. You are buying a day of work that can survive being validated by a stranger.

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, validation against criteria is only as good as the criteria: a receipt can prove a result matches the brief while the brief itself was wrong, and no record fixes a bad brief. Third, validated-as-recorded is not the same as safe or compliant: regulated work may need retention, access, and review controls beyond receipts, and the record should be one layer in that stack, not the whole stack.

Frequently asked questions

How do I validate AI work before I accept it?

Build the validation list from the brief, not from the agent summary. For each item, find the receipt for the call that was supposed to produce it and run the five checks: existence, identity, fingerprint, self-consistency, and chain. Then judge the saved result against the criterion for that item. Items pass only when both halves pass. Items that fail go back by name, with the failed check or the unmet criterion stated, to be rerun through the record.

How do agencies and freelancers validate AI agent work for clients?

By making the record part of the deliverable. The agency or freelancer runs the work through the Zambo MCP so each step leaves a receipt, validates the steps against the brief before sending, and delivers a handover link carrying the goal, steps, outputs, and receipts. The client can revalidate any step free at zambo.dev/verify with no account. One routine serves both sides, which is why the client argument about AI quality gets shorter.

Can a small business or a team validate AI output without new software to install?

Yes. Validation here is a browser habit, not a platform project. The checker opens the receipt or the handover link, runs the fingerprint check free at zambo.dev/verify, reads the saved result, and compares it with the output and the brief. A team shares the same link so every validator checks the same record. The only setup is upstream: the work has to run through the MCP once, at https://zambo.dev/mcp, so the receipts exist.

Does validating tool calls prove the output is correct?

No. Validating a tool call proves the call ran as recorded and its saved result was not changed after the fact. Correctness is the second half of validation: judging that saved result against the criteria in the brief. The receipt guarantees you are judging the real result, fixed at execution time, rather than a summary or a regenerated version. It does not make the judgment for you, and validation that skips the judgment half is only bookkeeping.

How much does it cost to validate a day of AI agent work?

Validating is free on the checker side: any receipt can be run 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.