ZAMBO.

Direct answer

LangGraph Agent Receipts

Add verifiable receipts to LangGraph tool calls and every tool call your graph makes leaves a record anyone can check. A graph's checkpoints show what the graph believed at each step: the state it carried, the messages it kept. They do not show what the tools actually did, because the tool results enter state as claims the graph stores about itself. Load the graph's tools from the Zambo MCP at https://zambo.dev/mcp instead and each tool call returns its result plus a verifiable receipt, captured server side at execution, outside the graph'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 LangGraph runs will publish.

Updated November 9, 2026.

Load the graph's tools from Zambo

LangGraph reaches MCP servers through langchain-mcp-adapters: a MultiServerMCPClient connects to the server and returns its tools as LangChain tools you can hand to a node or an agent factory, and a remote server is configured with its URL and the streamable HTTP transport:

pip install langchain-mcp-adapters langgraph

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

client = MultiServerMCPClient({
    "zambo": {
        "url": "https://zambo.dev/mcp",
        "transport": "streamable_http",
    }
})
tools = await client.get_tools()
agent = create_react_agent(model, tools)

Match the adapter and agent-factory names to the versions 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 a node 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.

Checkpoints and receipts answer different questions, and a serious run wants both. The checkpoint says the graph reached this state; the receipt says this tool call ran, with these inputs, and this is the result the endpoint recorded. When the two disagree, the receipt is the one a third party can check.

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 LangGraph graph?

Connect a MultiServerMCPClient from langchain-mcp-adapters to https://zambo.dev/mcp over the streamable HTTP transport, load its tools with get_tools, and hand them to your node or agent factory. Every tool call the graph 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 what each node in my LangGraph graph actually did?

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 step the graph claims but never ran has no receipt to point to, and that absence is visible in the run's record instead of hidden in the state history.

Do LangGraph checkpoints prove what the tools did?

Not by themselves. A checkpoint preserves the graph's state, and the tool results inside it are values the run itself wrote down: a result can be edited, trimmed, or replayed differently later and nothing in the checkpoint marks the change. Proof appears when the call is captured at execution time by a layer outside the graph'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 LangGraph 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 LangGraph 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.