AI Agent Receipt API: every tool call returns a verifiable receipt

The live API surface

The API is live right now at zambo.dev/api, which returns a JSON status document: service name, version, the MCP endpoint, and the current tool inventory. Tool calls go over HTTPS as JSON-RPC to the canonical MCP server at zambo.dev/mcp, which any MCP-compatible client can connect to directly.

{
  "status": "ok",
  "service": "zambo-api",
  "mcp": "https://zambo.dev/mcp"
}

That response is the whole pitch in miniature: a healthy service, a machine-readable tool list, and a receipt for everything.

What happens on every call

1. You call a tool. Any agent, any client, over HTTPS JSON-RPC or MCP. No signup needed to try it.
2. The execution is recorded. The system captures the tool name, the canonical bytes of the result, a SHA-256 output commitment, the timestamp, and the provenance class (who ran or reported the action). The provenance class and verification status are included in the hashed payload, so verification confirms them too.
3. You get a receipt URL. Every call returns a public receipt page at zambo.dev/run/<id>, retrievable without an account, wallet, or token.
4. Anyone can verify it. Paste the receipt into zambo.dev/verify and the verification procedure recomputes the commitment from the canonical bytes. If the saved result was changed, the receipt does not verify.

A receipt answers one narrow question: what did this system record for this execution? It proves the saved result was not changed. It does not prove the model was correct about the outside world, and the format is explicit about that limit.

What a receipt contains

Receipts follow AER-1, an open IETF Internet-Draft (draft-zambo-aer1-23) for portable execution receipts. Each receipt carries:

• A stable UUID identifying the receipt
• The tool name and caller scope
• The canonical bytes the output commitment was computed over
• The output commitment: sha256: followed by the lowercase hex digest
• An RFC 3339 timestamp
• A provenance class recording who ran the action, bound inside the receipt hash
• A stable public URL where the receipt resolves

Receipts can also be anchored to public relays with an envelope binding the receipt identifier, the output hash, and the evidence hash, and multi-step sessions get workflow receipts sealed under a single Merkle root.

AI agent receipt API

The problem: your agent works through APIs, and when something downstream goes wrong, the only witness is a log you cannot check. An AI agent receipt API removes the witness problem by returning a verifiable receipt with every call: the result and the record of the result arrive together, the record is fixed at execution time, and anyone can recompute it later. No separate logging project, no export step someone can forget, and no summary standing in for the work.

That is the API on this page. Call a tool through zambo.dev/mcp and the response carries the result plus a receipt at a public URL: the tool, the time, the recorded inputs, and the saved output under a hash commitment. When a client asks what the agent did, you send receipt links, not screenshots. When a pipeline step looks wrong, you open that step's receipt and read what it actually returned. Need one receipt for one job first? The AI agent receipt generator page walks the one-job path. Need to judge another vendor's receipts? The AI agent receipt template lists the fields to demand.

AI agent receipt service

Put plainly: this API is an AI agent receipt service. Every tool call an agent makes through it returns a verifiable execution receipt, a receipt a stranger can check without trusting the agent. The service part is the point: you do not build the capture, the canonicalization, or the verification yourself. You call the tool, you get the receipt, and the receipt checks out anywhere the open format is understood.

Access and pricing

Agents pay with $0.99 USDC on Base for a 24-hour Day Pass, handled automatically through the x402 payment flow: the API answers with a 402 challenge, the agent pays, the agent gets access and a receipt for the payment itself. Humans can use the same pass through PayPal. There is no signup wall between a curious developer and their first receipt.

Build on the same format

The receipt format is not locked to Zambo. AER-1 is an open draft with a public conformance suite, and there are verifier-first starter kits for Kotlin, C, and C++, plus runners in Rust, Go, TypeScript, Python, Java, C#, and Swift. If you emit receipts in your own system, the same verification procedure checks them. Cross-vendor checking is already proven: the AER-1 x Tanilo interop ran a full receipt chain with real values, verified end to end and double-verified by both sides.

AI agent receipt for data pipelines

Pipelines are where receipts pay for themselves. An AI agent receipt for data pipelines is the per-step record of what an agent-driven pipeline actually did: which source it read, what the tool returned, what was written downstream, each fixed at execution time. Pipeline failures are usually silent and downstream: a source returned less than expected, a transform quietly dropped rows, an agent summarized instead of copying. By the time anyone notices, the pipeline's own logs have rotated and the run exists only as a success message. Receipts change the postmortem: each step's saved result can be recomputed and read, so the step where the data changed is findable.

Zambo is the verifiable work layer for AI: pipeline steps run as tool calls, every call leaves a receipt, and the workflow record binds the steps in order at close. When a number downstream looks wrong, you do not re-run and hope. You open the receipts and find the exact step whose saved result diverges.

The check, step by step: list the run's receipts in order, recompute the commitment on the steps around the suspect number first, and read the saved outputs on both sides of it. The first step whose saved output no longer matches what the next step recorded as its input is where the data changed. Everything upstream of it is verified as recorded; everything downstream gets rerun from that step, not from the top.

Pipeline steps leave receipts only when they run where calls are recorded at execution time. Run the pipeline's steps through Zambo at zambo.dev/mcp and each step returns its result with its receipt attached, the run closing under one workflow record. For $0.99, a Day Pass covers 24 hours of calls with a receipt on every one. Ongoing use is the Zambo Pass at $29 a month or $290 a year, $19 a month for $ZAMBO holders. Humans pay by PayPal or card through PayPal; agents pay USDC on Base through x402.

Questions, answered