ZAMBO.

Direct answer

Haystack Agent Receipts

Add verifiable receipts to Haystack agent tool calls and every call your agent makes through the Zambo MCP leaves a record anyone can check. Connect the Haystack Agent component to the Zambo MCP at https://zambo.dev/mcp through MCPToolset, or add one Zambo tool at a time with MCPTool, and close the run with workflow_close so the step receipts bind into one chained record. Capture happens when the call runs, outside the agent's control, so a claim with no receipt behind it is visible as a gap instead of being smoothed over by a final answer.

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 Haystack agent calls will return.

Updated November 10, 2026.

Install: two routes to receipts

Route 1, the toolset. Install Haystack's own MCP integration, mcp-haystack, and connect the Zambo MCP as an MCPToolset. MCPToolset connects to an MCP server over Streamable HTTP and dynamically discovers its tools, and the Agent component accepts a toolset directly in its tools list: the only mandatory Agent parameter is a chat_generator that supports tools. Filter the toolset with tool_names, because loading every tool on a large server can overwhelm the model's tool selection.

pip install haystack-ai mcp-haystack

from haystack import Pipeline
from haystack.components.agents import Agent
from haystack_integrations.tools.mcp import MCPToolset, StreamableHttpServerInfo

zambo_toolset = MCPToolset(
    server_info=StreamableHttpServerInfo(url="https://zambo.dev/mcp"),
    tool_names=["capability_search", "workflow_close"],
)

agent = Agent(chat_generator=your_chat_generator, tools=[zambo_toolset])

pipeline = Pipeline()
pipeline.add_component("agent", agent)

The Agent is itself a Haystack component, so it sits inside a Pipeline alongside deterministic steps, and it runs its loop, calling tools and updating state, until one of its configurable exit_conditions is met. The Agent warms up the toolset automatically before a run. There is no Zambo package for Haystack and none is needed: the connection is the MCP integration Haystack already ships.

Route 2, one tool at a time. If the job needs a single Zambo tool, for example the closing call, wrap just that tool with MCPTool and pass it in the same tools list.

from haystack_integrations.tools.mcp import MCPTool, StreamableHttpServerInfo

server_info = StreamableHttpServerInfo(url="https://zambo.dev/mcp")
close_tool = MCPTool(name="workflow_close", server_info=server_info)

agent = Agent(chat_generator=your_chat_generator, tools=[close_tool])

Wire the Haystack agent's tools through Zambo

The Zambo MCP at zambo.dev/mcp carries 153 tools total, 37 on the default surface, and every call through it returns its result plus a verifiable receipt, captured server side at execution. Zambo is the verifiable work layer for AI: 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 the agent did, in the order it did it.

Your existing Haystack tools keep working alongside it. Haystack builds tools from a Python function with the Tool class or the @tool decorator, wraps a single component with ComponentTool, and wraps a whole Pipeline with PipelineTool so an agent can call it as one step. Receipts cover the calls routed through Zambo, so route the work you need to prove through the Zambo toolset and keep local, deterministic steps in the Pipeline where they belong.

Whichever route you take, two properties do the work. Capture happens when the call runs, not when somebody later exports a log. And the receipt states its own limit plainly: it describes what the endpoint recorded and observed, and it does not claim an outside outcome the endpoint did not observe.

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. In an Agent run, put the search first in the task itself: tell the agent to run capability_search before any other Zambo tool, then do one worked call. When you call a Zambo tool directly, outside the Agent loop, pass the label arguments through a raw MCP session, 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",
})

The run's first receipts then show the job as searched, the tool picked, and the result returned, in order, under one label the second day can pick back up.

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 pipeline owner an acceptance check with teeth, the Walk-Away Test: set the agent a countable multi-step job inside a Pipeline, walk away, and on return read the record before the final answer. Claimed steps versus recorded steps is the whole audit. A tool call an agent claims but never made has no receipt to point to.

Close the run with one workflow receipt

When the run finishes, call workflow_close. 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.

If the job continues in another AI, hand it over instead of restarting it: handover moves the job, with its record, to the next AI, and picking up a job in another AI is always free.

Cost

The free tier is 20 calls plus 1 wrap-up free every day, and picking up a job in another AI is always free. 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 card or 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 agent's 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 pipeline 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 Haystack agent?

Install the mcp-haystack integration and connect the Zambo MCP as a toolset: create an MCPToolset with StreamableHttpServerInfo pointing at https://zambo.dev/mcp, filter it with tool_names to the tools the job needs, and pass the toolset in the Agent component's tools list. The Agent warms up the toolset automatically before a run, and every call the agent then makes through Zambo comes back with a verifiable receipt at a public https://zambo.dev/run/ URL. Call workflow_close at the end of the run so the step receipts bind into one chained record. There is no Zambo package for Haystack and none is needed: the connection is the MCP integration Haystack already ships.

Can I verify what my Haystack agent did?

Yes, tool call by tool call. Every call routed through the Zambo MCP becomes its own receipt: the tool that ran, what it was given, and the output the endpoint recorded and 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. The Agent's own messages and last_message are the run's account of itself. A tool 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 a final answer.

Do Haystack agent outputs come with proof?

Not by default. Haystack gives you the Agent's messages, run metadata such as step counts and token usage, standard library logging, and tracing, including a LoggingTracer that shows data flowing through a Pipeline in real time. All of those are records the run itself controls: a log or an output can be edited, trimmed, or regenerated later and nothing in the framework marks the change. Proof appears when the result 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 a Zambo MCP call adds. It proves the saved result is the result that was recorded when the call ran; whether the result was any good remains a judgment the receipt does not make for you.

What does a Haystack run receipt contain?

One receipt per Zambo tool call, in the AER-1 format: the tool name, the inputs the call was given, the output the endpoint recorded and observed, a timestamp, and the SHA-256 commitments (the canonical bytes and the output hash) that make the record checkable by recompute. When the run closes with workflow_close, the step receipts bind into one 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. AER-1 is an open IETF Internet-Draft (draft -26), so the format is public text, not a vendor schema.

What does it cost to receipt a Haystack run?

The free tier is 20 calls plus 1 wrap-up free every day, and picking up a job in another AI is always free, so you can wire the toolset 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. Humans pay by card or PayPal; agents pay USDC on Base via x402. 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 agent's 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.