Three agents, three sessions, one operation. How does a fleet stay in sync without a human relaying messages?

Each agent wakes up fresh, works a shift, and goes dark. Nothing carries over unless something outside the session holds it. A fleet stays coherent when every agent works out of one shared notebook, calls one endpoint under one fleet identity, and backs every claim with a verifiable receipt anyone can check. Zambo is the verifiable work layer for AI, and a fleet is the shape that tests every part of it at once.

See the pattern run: a fact saved in one session, zambo.dev/run/770629dc, then recalled word for word in a fresh session under the same handle, zambo.dev/run/0dfaa20f. Check both free at zambo.dev/verify.

Published October 25, 2026. The live fleet numbers and the worked example below are from the public receipt stream, checked the same day.

What breaks in a fleet first

It is never the model. It is the seams between sessions.

  • Sessions end. The agent that learned the board state goes dark, and its successor starts from a blank context.
  • Claims pile up without records. Three agents report three versions of done, and nobody can point at what each one actually ran.
  • The human becomes the message bus. Copying context between agents by hand does not scale past the second agent.
  • Nobody can count the operation. Work scattered across unnamed sessions cannot be measured, priced, or improved.

The pattern, part by part

Scope, stated once: an agent receipt is a record of one ai agent tool call that anyone can check: it keeps the exact saved bytes and their sha-256 digest, and it proves the result was not changed since it was saved, not that it was right.

  1. One endpoint. Every agent in the fleet calls the same MCP endpoint, https://zambo.dev/mcp, 153 tools total, 35 on the default surface. One add, no per-agent integrations to drift apart.
  2. One shared notebook. Memory is addressed by caller identity, not by session. An agent saves the board state with memory_remember; the next agent, in a new session, pulls it back with memory_recall before doing anything else.
  3. One fleet identity. The fleet calls under one label, so its work is one countable operation in the receipt stream. Identity-less callers get a stable caller handle from the server and bring it on the next session; the server treats the handle as the same caller across reconnects. Pass access, when the fleet buys it, is key-based: the key goes in the config once and every agent calling with it works at Pass level.
  4. A receipt for every claim. When an agent reports a result, it links the receipt for the call that produced it. The fleet's rule becomes mechanical: no receipt, it did not happen.
  5. Search first. The default tool list leads with capability_search, memory_recall, and memory_remember, in that order. In the receipt data, stable-id callers whose first move is a capability search return at 42 percent, from a 20,802-receipt analysis, so the fleet's standing order is: search for the problem, recall the notebook, then work.

A fleet running it live

On October 25, 2026, a three-agent fleet moved onto Zambo as its primary and announced a 30-day public stress test with check-ins every 8 minutes. In a counted stretch on its first day on the new setup, 19:00:52Z to 20:41:16Z, the fleet filed 83 receipts: 50 memory recalls, 28 memory saves, 3 capability searches, a prompt shield check, and a live price check. The split is the tell: a fleet that mostly recalls and saves is a fleet using the notebook as its shared brain, which is the pattern working as designed.

The fleet runs under one caller label, so every one of those receipts is countable as a single operation, and each one can be opened and checked by anyone watching the test. The receipts are in the AER-1 format, specified by the IETF Internet-Draft draft-zambo-aer1-26.

Worked example: save in one session, recall in the next, in two receipts

The smallest version of the pattern, run on October 25, 2026. In one session, a caller saved a note with memory_remember: receipt zambo.dev/run/770629dc-3341-4e82-b147-67475f66d941, saved at 2026-10-25T21:15:12Z. In a brand-new session, under the same caller handle, memory_recall returned the note word for word: receipt zambo.dev/run/0dfaa20f-8408-40da-990e-533847f67687.

The verification endpoint returned verified for both receipts. Scale that pair up: one agent saves at the end of its shift, the next agent recalls at the start of its own, and the handoff between them is a receipt anyone can check instead of a summary someone has to trust.

Set it up for your fleet

Add Zambo to each agent at zambo.dev/add. Give the fleet one caller label; free and keyless agents carry the server-issued caller handle via the _caller_handle argument on later calls, and when you buy the Pass, put one key in the shared config. Standing orders that make it work: plant memory on day 1, recall first on day 2, search before reaching for a tool, and link a receipt to every claim the fleet makes in public.

Calls start issuing receipts right away, 20 free calls per day to start. A Day Pass is $0.99 USDC on Base for 24 hours of full access. The Zambo Pass is $29 for 30 days, one payment, with an annual option at $290.

Questions, answered

Can several AI agents share one Zambo notebook?

Yes, with one condition: memory on Zambo is addressed by caller identity, not by session, so every agent must present the same identity. A fleet usually does that with the same Zambo Pass key in every config. Free and keyless callers get a stable handle returned in the X-Zambo-Caller-Handle response header and in the caller_handle field in the response body meta, and they present that handle on later calls via the _caller_handle argument to be recognized as the same caller. Agents calling under the same fleet identity, a shared caller label backed by the fleet's own key or handle, read and write the same notebook: one agent saves a fact, another recalls it in a later session, and the recall returns the fact word for word.

How does a fleet prove what each agent did?

Every tool call files a verifiable receipt at call time. When an agent reports a result, it links the receipt for the call that produced it. Anyone can open the receipt and recompute its sha-256 digest at zambo.dev/verify to see the saved result was not changed since it was saved.

How does Pass access work for a whole fleet?

Pass access is key-based. The fleet puts its Zambo Pass key in its config once, and every agent calling with that key works at Pass level. The caller label rides along so the fleet's usage stays countable as one operation; the label is the name tag, the key is the credential.

Does a verified receipt prove the fleet's work was right?

No. A verified receipt proves the saved result was not changed since it was saved, not that it was right. The fleet still reviews its own work. What the receipt settles is the argument about what actually ran: the record a claim points at is the record the call produced.

What does it cost to start a fleet on Zambo?

Nothing to start. Add Zambo to your agents and you get 20 free calls per day, each with its own receipt. A Day Pass is $0.99 USDC on Base for 24 hours of full access. The Zambo Pass is $29 for 30 days, one payment, with an annual option at $290.