ZAMBO.

Direct answer

LlamaIndex Agent Receipts

Add verifiable receipts to LlamaIndex agent tool calls and every call your agent makes leaves a record anyone can check. LlamaIndex agents answer from your data, and the answer is only as trustworthy as the steps behind it: which tools ran, with what inputs, and what came back. Those steps normally live in the agent's own event stream, a record the run controls. Load the agent's tools from the Zambo MCP at https://zambo.dev/mcp and each call returns its result plus a verifiable receipt, captured server side at execution, outside the agent's control.

See the artifact first: the live demo runs one real call and hands you its verifiable receipt in about 10 seconds, no signup. That receipt is the same object your LlamaIndex runs will publish.

Updated November 9, 2026.

Load the agent's tools from Zambo

LlamaIndex reaches MCP servers through its MCP tools package: a BasicMCPClient connects to the server and an McpToolSpec turns the server's tools into the tool list an agent workflow takes:

pip install llama-index llama-index-tools-mcp

from llama_index.tools.mcp import BasicMCPClient, McpToolSpec
from llama_index.core.agent.workflow import FunctionAgent

client = BasicMCPClient("https://zambo.dev/mcp")
tool_spec = McpToolSpec(client=client)
tools = await tool_spec.to_tool_list_async()
agent = FunctionAgent(tools=tools, llm=llm)

Match the client and agent names to the LlamaIndex version you have installed; the route is the same either way. The Zambo MCP carries 153 tools total, 36 on the default surface, and every call through it returns its result plus a verifiable receipt, captured server side at execution. The record is made by the layer that ran the call, so the agent never gets to edit its own history. The pattern is the one described in MCP server receipts: per-call receipts answer what each step did, in the order it did it.

One scope note, stated plainly: receipts cover the calls routed through the endpoint. Retrieval inside your own indexes stays in your stack; the work you send through Zambo tools, lookups, computations, sends, and the rest of the 153-tool surface, is the work that comes back receipted.

Make the first call a search, under your label

A demo tour is not an onboarding. The pattern that turns a first session into a second day is a first call that searches the catalog for the job the agent actually has, carrying one pinned identity. Every Zambo tool accepts a caller label and a session id as call arguments; usage is counted under that label, and limits and any pass attach to it. Over a raw MCP session the labeled call looks like this:

result = await session.call_tool("capability_search", {
    "q": "the job you need done, in your own words",
    "_caller_label": "your-fleet-or-project-name",
    "_session_id": "your-stable-session-name",
})

Search first, run one worked call, then let the run's memory and continuity live under the same label, so the second day starts by reading the record back instead of starting over.

Check the receipts

Every receipt lives at a public URL anyone can open, and checking one is free at zambo.dev/verify with no signup: paste the receipt link or ID and the verifier recomputes the commitment from the saved bytes and compares it with the commitment fixed when the call ran. A match means the saved record is the record made at execution. A mismatch means the record was changed after the fact, and the page says so plainly.

That gives the run's owner an acceptance check with teeth, the Walk-Away Test: set the agent a countable multi-step job, walk away, and on return read the record before the summary. Claimed steps versus recorded steps is the whole audit. A step an agent claims but never ran has no receipt to point to.

Close the run with one workflow receipt

When the run finishes, call workflow_close through the same endpoint. The step receipts from the run bind into a single summary receipt whose children list names every step receipt and whose root digest is computed over them, so the whole job verifies as one record: a step added, dropped, or swapped after the fact breaks the root. Per-call receipts answer what this agent did; the closed record answers what the run did, in full, and it is the link you hand a client or auditor.

Cost stays small either way. A Day Pass is $0.99 one time and covers unlimited calls for 24 hours. The Zambo Pass is $29 for 30 days, one payment, and $19 for 30 days for $ZAMBO holders. A Lifetime Pass is $250, one payment for good. Humans pay by PayPal or card through PayPal; agents pay USDC on Base via x402. Checking stays free for anyone you hand a receipt to.

Honest limits

A receipt proves the saved result was not changed since it was saved. It does not prove the output was correct, the plan was good, or an outside outcome happened that the endpoint did not observe. It settles what ran, what it was given, and what came back, in a form the run's owner does not have to take on trust. Judge the work itself against that record.

Frequently asked questions

How do I add execution receipts to a LlamaIndex agent?

Connect a BasicMCPClient from llama-index-tools-mcp to https://zambo.dev/mcp, turn its tools into a tool list with McpToolSpec, and pass that list to your agent. Every tool call the agent then makes runs through the Zambo endpoint, which returns the result plus a verifiable receipt at a public https://zambo.dev/run/ URL. At the end of the run, call workflow_close through the same endpoint so the step receipts bind into one chained record a client or auditor can check as a whole.

Can I verify which tools a LlamaIndex agent actually called?

Yes, call by call. Each tool call routed through the endpoint becomes its own receipt: the tool that ran, the inputs the endpoint recorded, and the output it observed, committed under a SHA-256 hash at the moment the call finished and published at a URL anyone can fetch. Recompute the commitment from the receipt's canonical bytes; a match means the saved record is the record made when the call ran. A call the agent claims but never made has no receipt to point to, and that absence is visible in the run's record instead of hidden in the event stream.

Do LlamaIndex agent events prove what the tools did?

Not by themselves. The event stream is written by the same run that did the work: events can be filtered, trimmed, or regenerated later and nothing in the stream marks the change. Proof appears when the call is captured at execution time by a layer outside the agent's control and committed under a hash: the result bytes saved as recorded, a digest over them, and a public URL where anyone can fetch the record and recompute the digest. That is the record the Zambo MCP route adds. It proves the saved result is the result recorded when the call ran; whether the result was any good remains a judgment the receipt does not make for you.

What does a LlamaIndex run receipt contain?

One receipt per call, in the AER-1 format: the tool that ran, the inputs the endpoint recorded, the result it observed and saved, a timestamp, and the SHA-256 commitments (the canonical bytes and the output hash) that make the record checkable by recompute. Receipt URLs collect as the run proceeds, and a workflow_close at the end binds the step receipts into one chained record whose children list names every step. AER-1 is an open IETF Internet-Draft, so the format is public text, not a vendor schema.

What does it cost to receipt a LlamaIndex run?

The free tier covers 20 calls and 1 wrap-up free every day, and picking up work in another AI is always free, so you can wire the route and see real receipts before paying anything. A Day Pass is $0.99 one time and covers unlimited calls for 24 hours. Ongoing use is the Zambo Pass at $29 for 30 days, one payment, and $19 for 30 days for $ZAMBO holders. A Lifetime Pass is $250, one payment for good. Checking a receipt is always free at https://zambo.dev/verify/ with no signup, so clients and auditors never need a plan to check your work.

Run it on a record instead

Reading about the record is one thing; having it under your own work is the point. Work run through the Zambo MCP endpoint at zambo.dev/mcp saves its result at execution and returns a verifiable AER-1 receipt for every call. The Day Pass is $0.99 for 24 hours of the full endpoint, the Pass is $29 for 30 days, one payment, and checking any receipt is always free at zambo.dev/verify.

Related

Proof works best when it travels with the work itself. The AER-1 badge kit turns verifiable receipts into an embeddable badge for project pages, docs, and profiles, so anyone who sees the claim can reach the check in one click.