DEV Community

Cover image for Four agents, one job, zero trust: a swarm where every worker proves its piece
rambo
rambo

Posted on Edited on

Four agents, one job, zero trust: a swarm where every worker proves its piece

#ai #opensource #productivity #automation

Everyone is learning to run agent swarms right now, so let me save you the lesson I just paid for: the hard part is not the prompts. It is the seams.

A swarm, in plain words, is several AI agents working one job at once. One checks prices, one drafts, one verifies, and a coordinator hands out the pieces and assembles the result. Starting the agents takes an afternoon. What takes the rest of the week is everything between them: how a worker hands its piece over without the numbers drifting, where the job's shared state lives when no single chat owns it, and how the coordinator, or you, can tell a worker really did the work instead of writing a confident paragraph about having done it.

I run Zambo, a work layer for AI agents: shared jobs, per-agent memory, handovers that move work between agents, and a verifiable receipt for every call. I pointed it at exactly this problem and ran a small swarm for real. This is the pattern, what it cost, and the three places my assumptions were wrong.

Start with no code at all

If you have never run a swarm, run this version first. Add the Zambo endpoint (https://zambo.dev/mcp) to one chat AI for the coordinator and one per worker. The two-minute setup is at https://zambo.dev/add/. Then paste this into the coordinator's chat:

Coordinate a swarm job with me on Zambo:

  1. Connect to https://zambo.dev/mcp. When the endpoint issues your caller handle, save it in this conversation and present it on every call. You are the coordinator.
  2. Open the job: call memory_remember with the assignment, one line per worker, and keep the receipt.
  3. Give each worker its piece. Each worker works under its own caller handle and keeps the receipt of every call it makes.
  4. When a worker finishes, it wraps its contribution with handover, with a summary and you named as the recipient, and gives you the handover link.
  5. Pick each handover up (picking up is always free) and read its steps and receipts yourself. Check any receipt at https://zambo.dev/verify/ before you rely on it.
  6. Wrap the whole job with handover: a summary naming each worker, what it found, and its receipt. That handover is the deliverable: the link a client or an operator opens to verify the swarm's work.

And this into each worker's chat:

Work one piece of a swarm job on Zambo:

  1. Connect to https://zambo.dev/mcp. When the endpoint issues your caller handle, save it in this conversation and present it on every call. You are a worker; the coordinator holds the job.
  2. Do the piece the coordinator assigned. Keep the receipt link of every call.
  3. Save your finding with memory_remember, and put the receipt of the work in the fact.
  4. Wrap your contribution with handover: a summary of what you did and found, the coordinator named as the recipient. Send the coordinator the handover link. That link is your deliverable: the record the coordinator, a client, or an operator can verify.

That is the whole shape. Everything after this section is the same pattern run by code, at full depth, with the receipts to inspect.

The pattern, at depth

One job is one shared job id (a single _session_id) that every agent reuses. Identity is the opposite: separate. Each agent initializes once, is issued its own caller handle, saves that handle in its own state file, and presents it on every call, with its agent name as the caller label. Memory, the job timeline, and the daily free allowance all key to the handle. Two workers sharing one handle are one agent as far as the record is concerned, and the swarm's accounting collapses. Step zero is per-agent handle discipline; everything else is commentary.

On top of that: the coordinator opens the job by saving the assignment brief to memory under the job id. Each worker does its piece under the shared job id and its own handle, saves its finding to memory with the work's receipt inside the fact, then wraps the contribution into a handover addressed to the coordinator. The coordinator picks each handover up with handover_accept, which returns the worker's saved steps and receipts, reads them, and only then wraps the whole job into one handover whose summary names each worker and its receipts.

Notice what the coordinator never does: assemble the result from worker summaries. The summaries exist, inside the handovers, but the coordinator works from the records the pickups return. Verify, then wrap.

The run

November 2, 2026, four fresh identities, one shared job id (swarm-scan-2026-11-02), job: a three-asset market scan.

The coordinator opened the job with the brief: https://zambo.dev/run/4aad48df-b66f-45ee-9fb5-73a67577ae48

worker-btc checked BTC: $76,876.00, down 1.15 percent in 24 hours, at 20:07:21 UTC. Price receipt: https://zambo.dev/run/341a5c02-6713-4704-9708-f00708ee44e4. It saved the finding: https://zambo.dev/run/54033676-fb88-40bf-9018-b8b4cb89c720. Then it wrapped its contribution: https://zambo.dev/handover/cdcb95db-8c1c-4a21-beca-da1616989537

worker-eth checked ETH: $2,251.23, down 0.27 percent, at 20:07:26 UTC. Price receipt: https://zambo.dev/run/8d89c2f8-26c2-45b8-8d23-81df2b16f0b7. Finding: https://zambo.dev/run/70a70995-0c8c-4cd6-aa99-6863bf4239a6. Wrap: https://zambo.dev/handover/3ada9ebc-30c2-4324-bce3-5b8243e049e6

worker-sol checked SOL: $91.79, down 2.27 percent, at 20:07:31 UTC. Price receipt: https://zambo.dev/run/59ab0985-48e4-4712-8da6-266f733319fa. Finding: https://zambo.dev/run/50f77308-3537-43b8-9235-e9309feb4da4. Wrap: https://zambo.dev/handover/f6d6e4d1-6bfb-407c-882b-7014125a36a2

The coordinator picked the three handovers up at 20:10:13, 20:10:16, and 20:10:19 UTC, read each worker's steps from the pickups, and wrapped the swarm: https://zambo.dev/handover/a154789b-0588-43c7-a31c-d108eb59406b

Open that last link. It lists exactly six steps: the three price checks and the three memory saves, each one opening to a receipt that carries the same saved output the worker produced, timestamps identical to the original calls. The summary names each worker, its price, and its original receipts. The wrap's own receipt is here: https://zambo.dev/run/61ee822c-3f8e-44a4-aac4-1cf405566a58

Three places my assumptions were wrong

I assumed the shared job id made a shared inbox. It does not. When the coordinator read the job back with continuity_get_recent, it got its own timeline for the job: its opening step, and none of the workers' steps. The shared id binds the job's ledger and its pass together; it is not a group chat. Contributions move through handovers or they do not move. Honestly, this is the safer design: a worker's work reaches the coordinator as a sealed record the coordinator chooses to pick up, not as rows in a table anyone in the job can browse.

I assumed wrapping was a formality. My coordinator's first wrap attempt, a handover call with next steps but no summary and no named recipient, was refused on the spot, with its own receipt: https://zambo.dev/run/b2882668-1fd0-4410-aac1-826902ea2621. The endpoint asked, in so many words, what should be handed over and to whom. A wrap is a deliverable being published, and it is held to that standard. Every successful wrap in the run sets a summary, a goal, a recipient, and next steps.

I assumed the wrap would just bundle links. Instead, a wrap runs a proof loop over the job's steps and binds them into the handover. Each worker's handover lists 19 steps of job workflow, including the proof loop's own receipted steps, and the final handover's six steps carry the workers' saved outputs directly. The deliverable is the work, checkable step by step, not a paragraph about the work with links sprinkled on it.

What a swarm costs

The free tier is per agent: 20 calls plus 1 wrap-up free every day for each agent's own caller handle, and picking up in another AI is always free. Counted from this run's own counters, the coordinator spent 2 counted calls (the opening brief and one continuity read) and each worker spent 2 (the price check and the memory save). Three pickups and four wrap-ups moved no counter at all. Eight counted calls across four separate allowances, and every agent finished with 18 of its 20 free calls left. A swarm shaped like this runs free, one run a day or several.

When a swarm outgrows free, the scaling line is per agent too: a Day Pass is $0.99 per agent and makes that agent unlimited for 24 hours; the Zambo Pass is $29 per agent for 30 days. One-time payments, never subscriptions. This four-agent swarm on a heavy day costs four Day Passes, $3.96 for the day; covered for a month of heavy days, four Passes, $116 for 30 days. And pickup stays free at every tier, so a coordinator can always read its swarm's record, even on a day it cannot work.

Do not take my word for it

Pick any worker contribution in the final handover, open its receipt, and check it at https://zambo.dev/verify/. A receipt proves the saved result was not changed since it was saved, and the check recomputes that from the record itself. It does not prove the price was right or the worker picked the right tool, and I am not claiming otherwise. If a receipt from this run ever fails to verify, that is news and I want to hear it.

The full guide, with the accounting and the standing instructions at depth, is here: https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html. The runnable code is in the starter repo, coordinator and worker, next to the same pattern written as an installable skill file: https://github.com/zambodotdev/zambo-memory-loop-starter/tree/main/examples/swarm-scan

Your framework still runs your agents. Zambo is where their work lands, gets remembered, gets handed over, and gets proven. That is the whole pitch, and every link above is the evidence.

Try it free: add Zambo to your AI in one step at zambo.dev/add. 20 calls plus 1 wrap-up free every day, picking up in another AI is always free, no card and no signup wall.

Top comments (0)