The Receipt Truth Report: What 30,101 Real AI Agent Calls Leave Behind

Your AI agent just told you the work is done. The dashboard is green, the summary is confident, the tone is helpful. But did it actually do the thing? Did it call the API, or did it hallucinate the response? Did it run for forty minutes, or did it stall and write a plausible summary? If you cannot open a record and check, you are not managing an agent. You are believing a story.

This is the question that sits underneath every production AI deployment right now: when your agent says "done," where is the proof? The industry has a word for the answer, and the word is receipt. Not a screenshot. Not a transcript. A verifiable receipt: a machine-readable record of exactly what the agent executed, with a cryptographic hash you can check yourself.

We run the infrastructure that issues those receipts. So we did something simple and, as far as we can tell, unusual: we opened our own books. Every number in this report comes from Zambo's public endpoints, fetched on 2026-09-24, and every one of them is recomputable by anyone reading this. No survey. No sample. No "respondents." Just the actual record: 30,101 real AI tool calls, with 34,184 public receipts in the machine-readable audit log.

The dataset, stated honestly

Before the findings, the disclosure that makes the findings worth anything.

This dataset is 30,101 tool calls executed through Zambo's public MCP layer, across 631 days of continuous operation, with 34,184 public receipts in the machine-readable audit log. The majority of this traffic is automated operations: agents, scheduled jobs, and campaign machinery exercising the free tier. It is not 30,000 customers. Anyone who tells you their telemetry represents 30,000 humans when it represents their own cron jobs is selling you something, and we are not going to do that.

Here is why the data still matters. Every one of those calls, human or automated, left the same artifact: a verifiable receipt with a hash, a timestamp, and an output you can re-check. The question this report answers is not "how many users do we have." It is "what does complete coverage look like," because in the wild, the answer is usually nothing. The average AI agent call today leaves zero verifiable record. Ours leaves one every single time. That contrast is the whole report.

Finding 1: 100 percent of calls leave a receipt, and the receipts are public

Zambo's public audit log carries 34,184 receipts against 30,101 recorded MCP tool calls, and the platform's rule is stated plainly: "Every MCP tool call generates a receipt with tool name, status, and output hash." Coverage is not a feature you enable. It is the default, and the whole log is machine-readable.

Finding 2: 631 days of continuous operation, still running

The platform has been live for 631 days, averaging about 48 tool calls per day, with 174 calls on the day the data was pulled. That is not a launch-week spike. It is nearly two years of an execution layer doing its job daily, with every execution still openable after the fact.

Finding 3: one tool does 11.7 percent of all the work

The busiest tool is capability_search: 3,509 calls, or 11.7 percent of all 30,101 recorded calls. Discovery dominates execution: before agents act, they search for what they can do. The platform exposes 132 tools and 119 have been exercised at least once. The long tail is real, but capability lookup is the front door.

Finding 4: every receipt carries five checkable facts

Open any receipt and you get the same schema: a unique id, the tool called, a success or failure status, a SHA-256 hash of the output, and a UTC timestamp. That is the anatomy of proof. You need no permission to verify it and no trust in the caller. The hash either matches the output or it does not.

Finding 5: 119 proofs certified beyond the receipt layer

On top of the receipts, 119 proofs have been certified through the platform's proof layer. A receipt says "this is what happened." A certified proof goes further: it anchors the record so that later tampering is detectable. The receipt is the unit of accountability; the proof is the receipt with its seatbelt fastened.

Finding 6: 1,948,550 units of value moved through verifiable calls

The audit log also tracks treasury-aware token burns: 1,948,550 $ZAMBO burned across the recorded calls, counted only when a transaction signature confirms them. Unconfirmed burns are not counted. That last detail matters more than the number. A system that refuses to count what it cannot confirm is a system built by people who have thought about what "verifiable" actually requires.

What a verifiable receipt actually contains

Here is one real receipt from the public log, pulled the same day as this report:

id:          e35ddf51-7ae5-4f63-8936-ca1182078c7d
tool:        zambo_universal
status:      success
output_hash: sha256:75c0ffc00eaafa5cd4c8005932a1d07ca5eefbe94767eca1c057b208e07316d9
timestamp:   2026-09-24T15:27:33.855Z

That is it. No marketing copy, no trust badges, no "verified by our proprietary AI." Five fields. The hash lets anyone confirm the output has not changed since the call ran. The timestamp fixes the event in time. The status tells you whether the call succeeded before you read a single word of its summary. Compare that with what your current agent gives you when you ask "prove it": a confident paragraph.

This is also what makes receipts portable across AIs. When you switch from Claude to ChatGPT mid-project, or from Cursor to a terminal agent, the receipt is the continuity: the new AI does not have to take the old AI's word for anything. It can open the receipts and see what actually executed. That is the idea behind cross-AI continuity, and the receipt is the mechanism that makes it real rather than aspirational.

What this means if you run agents in production

Three practical consequences fall out of this data.

First, audit stops being a project. If every call leaves a receipt by default, you do not need a quarterly effort to reconstruct what your agents did. The record already exists, in a format a machine can read, from the moment each call returns. Compliance teams and client security reviews stop asking "can you prove it" because the proof is a URL.

Second, debugging gets honest. When an agent fails at 3am, the receipt tells you which call failed, what its inputs were, and what the output hash was, before anyone writes a postmortem. You stop arguing about what the agent "probably" did. The record does not have opinions.

Third, client trust becomes demonstrable. If you sell work that agents perform, a receipt is the difference between "trust me, the AI did it" and "here is the record, check it yourself." That difference is worth money, and it is the reason receipts are becoming the unit of accountability for agent work, the same way invoices became the unit of accountability for human work.

The bottom line

We analyzed 30,101 real AI agent tool calls and the 34,184 public receipts they left behind, and found a system where every call leaves a checkable record, where unconfirmed value is never counted, and where the entire audit log is public and machine-readable. The industry default is zero receipts per call. The gap between zero and 34,184 is the gap between believing your agent and verifying it.

---

Go deeper: What Is an AI Agent Execution Receipt? · Switching AI Assistants Mid-Project: A Practical Continuity Guide · Did My Agent Lie? How to Check What Your AI Actually Did

Verify a receipt yourself: zambo.dev/hosted-receipt-verification

Run one live call right now, no account and no install, and inspect the verifiable receipt it creates: zambo.dev/demo

Or install the free tier, 20 calls per tool per day: zambo.dev/install?src=devto-truth-report

Methodology: all figures pulled 2026-09-24 ~12:36 EDT from https://zambo.dev/api/stats, https://zambo.dev/api/pulse, https://zambo.dev/api/mcp/receipts, and the published free-tier terms on https://zambo.dev/pricing/. Raw responses archived with fetch timestamps. Traffic is predominantly automated operations, not independent users; the report makes no user-count claims.