How to make your AI agent show its work

Why the summary cannot show the work

The summary is a retelling. It is produced after the job, by the same model that ran the job, from the same context that may already contain the mistake. That is why the failure is so hard to see from the reader's chair: in a controlled study built around 90 traps where a tool result only looks like success (272 runs per model), Claude Sonnet reported work as finished that had never happened in 21 of 272 runs, and Claude Haiku in 56 of 272 runs. The single biggest source was a write that answered ok and changed nothing, never re-read before the success report went out. The full figures are in false completion, measured.

No prompt fixes that, because the prompt is read by the same process that writes the summary. What fixes it is changing what a finished job is made of: records saved by the run itself, which the retelling can point at but cannot rewrite.

The setup: three moves

1. Run the work where every call saves its result

Route the job through an endpoint that records at execution. Work run through the Zambo MCP endpoint at zambo.dev/mcp saves its result the moment the call runs and returns a verifiable AER-1 receipt inside the response: the receipt id, the public run URL, and the digest of the saved result. 153 tools, 35 on the default surface, a free tier on every tool. Any stack that saves step records at execution works for the method; this is the one the worked example below ran on.

2. Give the agent the reporting instruction

Paste this into the job brief, the system prompt, or the handoff request, word for word:

For every step of this job, report:
- the tool you used,
- the input you gave it,
- the record link for the saved result.
Report the steps in the order they ran.
If a step has no saved record, write "no record for this step"
instead of describing it as done.
End with the list of record links, not a summary paragraph.

Prefer the habit installed permanently over a paste per job? The free check-any-agents-work skill loads this reporting and checking discipline into the agent itself, so it triggers whenever work is reported as finished.

3. Read the trail, not the retelling

When the job lands, open the step records, two or three at minimum, and read the saved results against the claims. For a multi-step job, have the steps packaged as a handover: the steps in sequence under one link, where your decision, accept it or flag the exact step whose record does not hold up, is itself recorded. The reviewer time goes to the records, which is where the truth of the job lives.

Worked example: a two-step job, shown

This job was run for this page, minutes before it was written: get the current price of BTC, then the current price of ETH, saving each step separately. The agent's report, in the format move 2 demands, is two lines long:

• Step 1, live_price, input BTC: zambo.dev/run/2a24a899
• Step 2, live_price, input ETH: zambo.dev/run/b1d7daee

Open either record and you see the tool, the input, the saved result, and the time it ran. Prices move, so the number you see is the number that call returned at that moment, which is exactly what a record is for: it settles what the run actually produced, in a form a second person can recompute at zambo.dev/verify. The job is trivial on purpose. At two hundred steps the trail reads the same way, one record per step, and a summary that disagrees with any of them loses to the record.

The CRM case: prove exactly what changed

The sharpest form of this question arrives after the fact: an AI agent updated our CRM, and now someone needs to prove exactly what changed. Work it from the trail:

1. Find the record of the update call. Its saved input is the change as it was sent: the record it targeted, the fields, and the values the agent wrote.
2. Read the saved result next to it. That is what the CRM answered when the write landed, the system's own account of what it accepted.
3. Set the pair against the record before it, then read the record again after the write. Save that after-read as its own record. The before record, the update pair, and the after record together are the proof of the change, field by field. An update with no after record proves the send and the answer, not the change.

And the honest limit, stated plainly: if that update ran somewhere that saved nothing, there is no proof of what changed, only the agent's account of the change. A chat transcript is an account, not a change record, and no amount of re-reading it turns it into one. The fix is upstream, move 1, not forensic: run updates on a recorded path and the next change carries its own record.

If the job already ran somewhere that saved nothing

Then there is nothing to check, and a page that pretended otherwise would be selling you the same confidence trick as the summary. The three honest moves: re-run the job on a recorded path and check that run; accept the claim knowingly, as a decision, for work where the stakes allow it; or change the default upstream so the next job runs recorded. The full treatment of the trail an agent leaves, and how a reviewer uses it, is the AI agent audit trail page. Showing a client the same trail, on one link, is covered in show a client every step your AI took.

Run your next job so it shows its work

The setup above is free to try: the endpoint's free tier covers recorded calls on every tool. When the job is real work that runs all day, the $0.99 Day Pass unlocks the metered tools for 24 hours, every call recorded, every step carrying its receipt, the whole trail ready to hand over. The Pass is $29 a month for the same thing without the clock. Checking any receipt, yours or anyone else's, is always free at zambo.dev/verify.

What showing work does not prove

A verified record proves one narrow thing: the saved result is the result that was saved when the call ran, unchanged since. It does not prove the work was good, the price was fair, or the update should have been made. Judgement stays with the reviewer. What changes is the object of the judgement: a fixed record anyone can open, instead of a confident summary only its author can vouch for. The receipt format is an open draft, draft-zambo-aer1-24, with a public conformance kit, so the checking never depends on Zambo's say-so.

Frequently asked questions