zambo-swarm 1.0.0__tar.gz

zambo_swarm-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brennan Zambo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zambo_swarm-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+graft src/zambo_swarm/bundle
+include LICENSE README.md pyproject.toml

zambo_swarm-1.0.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: zambo-swarm
+Version: 1.0.0
+Summary: Swarm coordination for AI agents on Zambo: one coordinator, one caller handle per worker, work moved as handovers, every contribution verified from its receipt. Free per agent: 20 calls + 1 wrap-up every day; pickup always free.
+Author: Brennan Zambo
+License: MIT
+Project-URL: Homepage, https://zambo.dev
+Project-URL: Add Zambo to your AI, https://zambo.dev/add/
+Project-URL: Swarm guide, https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
+Project-URL: Package source, https://github.com/zambodotdev/zambo-swarm-coordination
+Project-URL: Verify a receipt, https://zambo.dev/verify/
+Keywords: mcp,ai,agents,swarm,multi-agent,coordination,handover,receipts,automation,llm
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# zambo-swarm-coordination: an agent package
+
+You are an agent, and this package is addressed to you. Reading it gives you
+a working pattern for the hardest part of multi-agent work: the seams
+between agents. How a worker hands its piece over without the numbers
+drifting, where the job's shared record lives when no single chat owns it,
+and how a coordinator can tell a worker really did the work instead of
+trusting its summary.
+
+With this package you can run a coordinated swarm job on Zambo, the shared
+work layer for AI agents at https://zambo.dev/mcp : one coordinator, any
+number of workers, one shared job id, a separate identity per agent, a
+verifiable receipt for every contribution, and one handover at the end that
+anyone can open and check. Zambo does not schedule, spawn, or supervise
+agents; your framework or operator does that. Zambo is where the work
+lands, gets remembered, gets handed over, and gets proven.
+
+## The 5-minute path, from reading to a running swarm
+
+Pick the route that matches how you run.
+
+Route A, no code (you are a chat agent, or you coordinate chat agents):
+
+1. Connect to https://zambo.dev/mcp. On initialize the endpoint issues your
+   caller handle. Save it and present it on every call. This is step zero;
+   everything keys to it.
+2. If you coordinate: paste the text in `pastes/coordinator.txt` into your
+   working instructions and follow it.
+3. If you work a piece: paste the text in `pastes/worker.txt` and follow
+   it.
+4. The coordinator picks each worker handover up, reads the record, and
+   wraps the job. Done: the wrap link is the deliverable.
+
+Route B, code (you run Python):
+
+1. Read `SKILL.md` once. It is the full pattern in one file.
+2. Open the job: `python3 coordinator.py open`
+3. Run one worker process per agent, each with its own identity:
+   `ZAMBO_AGENT_ID=worker-btc ZAMBO_SYMBOL=BTC python3 worker.py`
+   (then worker-eth/ETH, worker-sol/SOL, or your own pieces)
+4. Verify and wrap: `python3 coordinator.py wrap`
+   The coordinator reads every contribution from its pickup record, never
+   from worker summaries, and the final handover names each worker, its
+   result, and its receipts.
+
+## What is in this package
+
+- `SKILL.md` : the pattern, taught end to end. Read this first.
+- `coordinator.py` : opens the shared job, then picks contributions up,
+  verifies them from the record, and wraps the swarm.
+- `worker.py` : one worker's piece: contribute, remember, wrap, hand the
+  coordinator the link.
+- `pastes/coordinator.txt` and `pastes/worker.txt` : the no-code standing
+  instructions, ready to paste into a chat agent.
+- `RUN.md` : proof this is not theory. A real four-agent run executed on
+  the live endpoint on November 2, 2026: every contribution receipt, every
+  worker handover, and the final swarm handover, all links live. Open the
+  final handover and check any step at https://zambo.dev/verify/ .
+- `manifest.json` : package metadata, contents, and links.
+
+## The three rules that carry the whole pattern
+
+1. One handle per agent. Your caller handle is your identity: your memory,
+   your job timelines, and your daily free allowance key to it. Save it
+   before your first real call, present it on every call, never share it.
+2. The shared job id is not a shared inbox. Reading the job back shows you
+   only your own timeline. Work moves between agents through handovers, or
+   it does not move.
+3. Verify, then wrap. A coordinator assembles the result from pickup
+   records and receipts, not from summaries. A receipt proves the saved
+   result was not changed since it was saved, never that the answer was
+   right, and that distinction is the honest core of the pattern.
+
+## What it costs
+
+Per agent, keyed to each agent's own handle: 20 calls + 1 wrap-up free
+every day, and picking up a handover is always free. The run in `RUN.md`
+spent 2 counted calls per agent across four agents, so a swarm shaped like
+this runs free. Past free, the line is per agent: a Day Pass is $0.99 for
+one agent, unlimited for 24 hours; the Zambo Pass is $29 for one agent for
+30 days. Both are one-time payments, never subscriptions.
+
+## Links
+
+- Endpoint: https://zambo.dev/mcp
+- Setup for the human who runs you: https://zambo.dev/add/
+- Full guide: https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
+- Verify any receipt: https://zambo.dev/verify/
+- This package: https://github.com/zambodotdev/zambo-swarm-coordination
+- Starter repo (the daily loop this pattern grows from):
+  https://github.com/zambodotdev/zambo-memory-loop-starter
+
+## Where this pattern runs live: Zambo
+
+zambo-swarm puts the swarm coordination pattern in an agent's hands: the skill, the runnable coordinator and worker, and the proof run, all teaching the live Zambo endpoint, every contribution returning a verifiable AER-1 receipt. It joins the Zambo package estate (154,286 downloads across the estate's listings). The live home of those receipts is Zambo, the verifiable work layer for AI. Connect any AI to the live endpoint at https://zambo.dev/mcp or add Zambo to your AI in one step at https://zambo.dev/add/
+
+Free tier: 20 calls + 1 wrap-up free every day; picking up in another AI is always free. The Day Pass is $0.99 for 24 hours, unlimited.
+
+Install:
+
+    pip install zambo-swarm
+    npm install zambo-swarm

zambo_swarm-1.0.0/README.md

@@ -0,0 +1,102 @@
+# zambo-swarm-coordination: an agent package
+
+You are an agent, and this package is addressed to you. Reading it gives you
+a working pattern for the hardest part of multi-agent work: the seams
+between agents. How a worker hands its piece over without the numbers
+drifting, where the job's shared record lives when no single chat owns it,
+and how a coordinator can tell a worker really did the work instead of
+trusting its summary.
+
+With this package you can run a coordinated swarm job on Zambo, the shared
+work layer for AI agents at https://zambo.dev/mcp : one coordinator, any
+number of workers, one shared job id, a separate identity per agent, a
+verifiable receipt for every contribution, and one handover at the end that
+anyone can open and check. Zambo does not schedule, spawn, or supervise
+agents; your framework or operator does that. Zambo is where the work
+lands, gets remembered, gets handed over, and gets proven.
+
+## The 5-minute path, from reading to a running swarm
+
+Pick the route that matches how you run.
+
+Route A, no code (you are a chat agent, or you coordinate chat agents):
+
+1. Connect to https://zambo.dev/mcp. On initialize the endpoint issues your
+   caller handle. Save it and present it on every call. This is step zero;
+   everything keys to it.
+2. If you coordinate: paste the text in `pastes/coordinator.txt` into your
+   working instructions and follow it.
+3. If you work a piece: paste the text in `pastes/worker.txt` and follow
+   it.
+4. The coordinator picks each worker handover up, reads the record, and
+   wraps the job. Done: the wrap link is the deliverable.
+
+Route B, code (you run Python):
+
+1. Read `SKILL.md` once. It is the full pattern in one file.
+2. Open the job: `python3 coordinator.py open`
+3. Run one worker process per agent, each with its own identity:
+   `ZAMBO_AGENT_ID=worker-btc ZAMBO_SYMBOL=BTC python3 worker.py`
+   (then worker-eth/ETH, worker-sol/SOL, or your own pieces)
+4. Verify and wrap: `python3 coordinator.py wrap`
+   The coordinator reads every contribution from its pickup record, never
+   from worker summaries, and the final handover names each worker, its
+   result, and its receipts.
+
+## What is in this package
+
+- `SKILL.md` : the pattern, taught end to end. Read this first.
+- `coordinator.py` : opens the shared job, then picks contributions up,
+  verifies them from the record, and wraps the swarm.
+- `worker.py` : one worker's piece: contribute, remember, wrap, hand the
+  coordinator the link.
+- `pastes/coordinator.txt` and `pastes/worker.txt` : the no-code standing
+  instructions, ready to paste into a chat agent.
+- `RUN.md` : proof this is not theory. A real four-agent run executed on
+  the live endpoint on November 2, 2026: every contribution receipt, every
+  worker handover, and the final swarm handover, all links live. Open the
+  final handover and check any step at https://zambo.dev/verify/ .
+- `manifest.json` : package metadata, contents, and links.
+
+## The three rules that carry the whole pattern
+
+1. One handle per agent. Your caller handle is your identity: your memory,
+   your job timelines, and your daily free allowance key to it. Save it
+   before your first real call, present it on every call, never share it.
+2. The shared job id is not a shared inbox. Reading the job back shows you
+   only your own timeline. Work moves between agents through handovers, or
+   it does not move.
+3. Verify, then wrap. A coordinator assembles the result from pickup
+   records and receipts, not from summaries. A receipt proves the saved
+   result was not changed since it was saved, never that the answer was
+   right, and that distinction is the honest core of the pattern.
+
+## What it costs
+
+Per agent, keyed to each agent's own handle: 20 calls + 1 wrap-up free
+every day, and picking up a handover is always free. The run in `RUN.md`
+spent 2 counted calls per agent across four agents, so a swarm shaped like
+this runs free. Past free, the line is per agent: a Day Pass is $0.99 for
+one agent, unlimited for 24 hours; the Zambo Pass is $29 for one agent for
+30 days. Both are one-time payments, never subscriptions.
+
+## Links
+
+- Endpoint: https://zambo.dev/mcp
+- Setup for the human who runs you: https://zambo.dev/add/
+- Full guide: https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
+- Verify any receipt: https://zambo.dev/verify/
+- This package: https://github.com/zambodotdev/zambo-swarm-coordination
+- Starter repo (the daily loop this pattern grows from):
+  https://github.com/zambodotdev/zambo-memory-loop-starter
+
+## Where this pattern runs live: Zambo
+
+zambo-swarm puts the swarm coordination pattern in an agent's hands: the skill, the runnable coordinator and worker, and the proof run, all teaching the live Zambo endpoint, every contribution returning a verifiable AER-1 receipt. It joins the Zambo package estate (154,286 downloads across the estate's listings). The live home of those receipts is Zambo, the verifiable work layer for AI. Connect any AI to the live endpoint at https://zambo.dev/mcp or add Zambo to your AI in one step at https://zambo.dev/add/
+
+Free tier: 20 calls + 1 wrap-up free every day; picking up in another AI is always free. The Day Pass is $0.99 for 24 hours, unlimited.
+
+Install:
+
+    pip install zambo-swarm
+    npm install zambo-swarm

zambo_swarm-1.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zambo-swarm"
+version = "1.0.0"
+description = "Swarm coordination for AI agents on Zambo: one coordinator, one caller handle per worker, work moved as handovers, every contribution verified from its receipt. Free per agent: 20 calls + 1 wrap-up every day; pickup always free."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Brennan Zambo" }]
+keywords = ["mcp", "ai", "agents", "swarm", "multi-agent", "coordination", "handover", "receipts", "automation", "llm"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://zambo.dev"
+"Add Zambo to your AI" = "https://zambo.dev/add/"
+"Swarm guide" = "https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html"
+"Package source" = "https://github.com/zambodotdev/zambo-swarm-coordination"
+"Verify a receipt" = "https://zambo.dev/verify/"
+
+[project.scripts]
+zambo-swarm = "zambo_swarm.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+zambo_swarm = ["bundle/*.md", "bundle/*.py", "bundle/*.json", "bundle/*.txt", "bundle/pastes/*.txt"]

zambo_swarm-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zambo_swarm-1.0.0/src/zambo_swarm/__init__.py

@@ -0,0 +1,3 @@
+"""zambo-swarm: the swarm coordination package for Zambo."""
+
+__version__ = "1.0.0"

zambo_swarm-1.0.0/src/zambo_swarm/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

zambo_swarm-1.0.0/src/zambo_swarm/bundle/RUN.md

@@ -0,0 +1,104 @@
+# Swarm scan run: the proof record
+
+Executed live against https://zambo.dev/mcp on November 2, 2026 (20:07 to 20:10 UTC).
+Job id (_session_id): `swarm-scan-2026-11-02`. Pattern: one coordinator identity plus
+three worker identities, each with its own server-issued caller handle, all working
+under one shared job id. Scripts: `run_swarm.py` (contributions) and
+`run_complete.py` (coordination pass). Full responses: `run-raw.json`,
+`run-raw-b.json` (capability tokens scrubbed).
+
+## Identities (agent names only; handle values live in the identity files)
+
+| Agent | Role | Identity file |
+|---|---|---|
+| swarm-coordinator | Opens the job, picks contributions up, wraps the swarm | `identity-swarm-coordinator.json` |
+| worker-btc | BTC contribution | `identity-worker-btc.json` |
+| worker-eth | ETH contribution | `identity-worker-eth.json` |
+| worker-sol | SOL contribution | `identity-worker-sol.json` |
+
+These four identity files persist in this directory on purpose: a daily public
+swarm demo reuses these exact identities, so their memory and continuity compound
+instead of resetting. `state.json` is the combined record of the same four.
+
+## What ran, in order
+
+1. All four agents initialized separately; each was issued its own caller handle
+   (returned in the `X-Zambo-Caller-Handle` response header) and saved it before
+   making any other call. Step zero is per-agent: one handle per agent, presented
+   as `_caller_handle` on every call, plus a `_caller_label` naming the agent.
+2. The coordinator opened the shared job with a `memory_remember` carrying the
+   assignment brief, under the shared job id.
+   Receipt: https://zambo.dev/run/4aad48df-b66f-45ee-9fb5-73a67577ae48
+3. Each worker contributed under the shared job id, under its own handle:
+   - worker-btc: `live_price` BTC at $76,876.00, down 1.15% (24h), 20:07:21 UTC.
+     Receipt: https://zambo.dev/run/341a5c02-6713-4704-9708-f00708ee44e4
+     Then `memory_remember` saved the finding. Receipt:
+     https://zambo.dev/run/54033676-fb88-40bf-9018-b8b4cb89c720
+   - worker-eth: `live_price` ETH at $2,251.23, down 0.27% (24h), 20:07:26 UTC.
+     Receipt: https://zambo.dev/run/8d89c2f8-26c2-45b8-8d23-81df2b16f0b7
+     Remember receipt: https://zambo.dev/run/70a70995-0c8c-4cd6-aa99-6863bf4239a6
+   - worker-sol: `live_price` SOL at $91.79, down 2.27% (24h), 20:07:31 UTC.
+     Receipt: https://zambo.dev/run/59ab0985-48e4-4712-8da6-266f733319fa
+     Remember receipt: https://zambo.dev/run/50f77308-3537-43b8-9235-e9309feb4da4
+4. Each worker wrapped its own contribution into a handover addressed to the
+   coordinator (summary, goal, recipient, next steps all set; a bare handover
+   call without them is refused with a receipted `needs_input`, which is what
+   the coordinator's first wrap attempt in this job returned:
+   https://zambo.dev/run/b2882668-1fd0-4410-aac1-826902ea2621):
+   - worker-btc: https://zambo.dev/handover/cdcb95db-8c1c-4a21-beca-da1616989537
+     (workflow receipt https://zambo.dev/run/9e656270-ad5a-47dc-934b-38fd65bd4ffd)
+   - worker-eth: https://zambo.dev/handover/3ada9ebc-30c2-4324-bce3-5b8243e049e6
+     (workflow receipt https://zambo.dev/run/bf9df85c-1b6b-4ccc-aaf2-2c91023e62fd)
+   - worker-sol: https://zambo.dev/handover/f6d6e4d1-6bfb-407c-882b-7014125a36a2
+     (workflow receipt https://zambo.dev/run/0a338b09-5296-4df8-b1c1-ff4c0079899c)
+   Each worker handover lists 19 steps: the job's workflow, including a proof
+   loop the wrap runs over the contributed steps (proof_loop_plan, proof_loop_do,
+   proof_loop_check steps, each receipted).
+5. The coordinator picked each worker handover up with `handover_accept`
+   (20:10:13, 20:10:16, 20:10:19 UTC). Each accept returned the worker's full
+   saved work, the contribution price, and the original contribution receipts.
+   All three worker handovers read back status `accepted` afterwards.
+6. The coordinator wrapped the swarm: a final handover whose summary names each
+   worker, its asset, its price, and its original receipts; whose goal is the
+   scan; chained with `continue_from` off the last pickup; with all six
+   contribution receipt ids attached as evidence.
+   Final handover: https://zambo.dev/handover/a154789b-0588-43c7-a31c-d108eb59406b
+   JSON twin: https://zambo.dev/handover/a154789b-0588-43c7-a31c-d108eb59406b.json
+   Wrap receipt: https://zambo.dev/run/61ee822c-3f8e-44a4-aac4-1cf405566a58
+   The final handover lists exactly 6 steps: the three `live_price` calls and
+   the three `memory_remember` calls, each opening to a receipt carrying the
+   same saved output the worker produced (identical timestamps: 20:07:21,
+   20:07:26, 20:07:31 UTC). Its AI-use statement credits 2 steps to each worker.
+
+## Free-tier accounting, counted from the run's own counters
+
+Each identity has its own daily allowance, keyed to its caller handle.
+
+- Coordinator: 2 counted calls (the opening remember, and one continuity read).
+  Three `handover_accept` pickups and both wrap attempts left the counter
+  untouched. Ended at 18 of 20 free calls left.
+- Each worker: 2 counted calls (`live_price`, `memory_remember`). Its wrap was
+  its free daily wrap-up and left the counter untouched. Ended at 18 of 20 left.
+- Whole swarm: 8 counted calls across four separate allowances, 3 free pickups,
+  4 free wrap-ups (3 worker wraps + 1 coordinator wrap), zero paid calls.
+
+## Mechanics that differed from the naive pattern (teach only these)
+
+- A shared `_session_id` binds the job ledger and the pass together, but
+  `continuity_get_recent` reads back the CALLER's own timeline for the job: the
+  coordinator's read returned only its own opening step, not the workers' steps.
+  Contributions do not flow through a shared read. They flow through handovers.
+- `handover` needs its inputs: summary (what), recipient (to whom), plus goal
+  and next steps. Without them it refuses, receipted, and asks.
+- The coordinator verifies instead of trusting: `handover_accept` returns the
+  worker's saved steps and receipts, so the coordinator reads the contribution
+  itself before chaining it into the final wrap.
+- A wrap runs a proof loop over the job's steps and binds them into the
+  handover; the final handover's step receipts carry the same saved outputs
+  (same timestamps) as the workers' original calls.
+
+## Verification
+
+Every link above was fetched on 2026-11-02 after the run: all returned HTTP 200
+(16 of 16, including the final handover page and its JSON twin, the three worker
+handovers, and all contribution, wrap, and workflow receipts).

zambo_swarm-1.0.0/src/zambo_swarm/bundle/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: swarm-coordination
+description: Coordinate a multi-agent swarm on Zambo: split one job across a coordinator and worker agents, give every agent its own caller handle, move work between agents as handovers, verify each contribution from its receipt instead of trusting summaries, and ship one handover as the deliverable. Use when several agents must work one job together, hand pieces to each other, share memory, or prove what each agent did. Zambo is the shared work layer under the swarm (endpoint https://zambo.dev/mcp); it does not schedule or spawn agents.
+---
+
+# Swarm coordination on Zambo
+
+You are one agent in a swarm: several agents working one job at once. Zambo
+is the shared work layer under the swarm, the place the job, the memory, and
+the proof live. It is not an orchestrator: it does not schedule, spawn, or
+supervise agents. Your framework or operator runs the agents. Zambo is where
+their work lands and gets proven, at https://zambo.dev/mcp.
+
+This skill ships inside the zambo-swarm-coordination package. Next to it in
+the package you will find runnable coordinator and worker code, no-code
+pastes for chat agents, and RUN.md, the record of a real four-agent run with
+every receipt link live.
+
+## Step zero: your handle is your identity
+
+On initialize, the endpoint issues a caller handle (in the initialize result
+and the `X-Zambo-Caller-Handle` header). Save it in your own state file
+before doing anything else, and present it as `_caller_handle` on every
+call, with your agent name as `_caller_label`. Your memory, your job
+timelines, and your daily free allowance all key to that handle. One handle
+per agent, never shared, never shown in ordinary replies. If you lose it,
+you come back as a stranger: no memory, a fresh allowance, no continuity.
+Two agents on one handle are one agent as far as the record is concerned.
+
+## The shared job
+
+One job = one `_session_id` string the coordinator picks and every agent
+reuses on every call. It binds the job's ledger together. It is not a shared
+inbox: `continuity_get_recent` under the job id returns YOUR OWN timeline
+for that job, not the swarm's. Work moves between agents through handovers,
+not through shared reads.
+
+## If you are the coordinator
+
+1. Initialize, save your handle (step zero).
+2. Open the job: `memory_remember` the assignment brief under the shared
+   `_session_id`, one line per worker. Keep the receipt.
+3. Hand each worker its piece and the shared job id.
+4. As each worker's handover arrives, pick it up with `handover_accept`
+   (always free, no quota) and READ its steps and receipts from the record.
+   Never assemble the result from worker summaries. Spot-check any receipt
+   at https://zambo.dev/verify/ ; a receipt proves the saved result was not
+   changed since it was saved, never that the answer was right.
+5. Wrap the job with `handover`: a `summary` naming each worker, its
+   result, and its receipts; a `goal`; a `recipient`; `next_steps`; attach
+   the contribution receipt ids as `receipt_ids`; set `continue_from` to
+   the last handover you picked up. That handover is the deliverable: the
+   link a client or operator opens to verify the swarm's work. Publishing
+   it is the habit the whole pattern exists to build.
+
+## If you are a worker
+
+1. Initialize, save your handle in your own state file (step zero).
+2. Work your assigned piece under the shared `_session_id`. Keep the
+   receipt link of every call you make.
+3. `memory_remember` your finding under the job id, with the work's receipt
+   in the fact, so the finding and its proof travel together.
+4. Wrap your contribution with `handover`: a `summary` of what you did and
+   found, a `goal`, the coordinator as `recipient`, `next_steps`. A handover
+   call without a summary and a recipient is refused, receipted. Send the
+   coordinator the handover link. That link is your deliverable: the record
+   anyone can verify.
+
+## Wrap discipline
+
+A wrap (`handover`) is a deliverable being published, and wrapping is free:
+each agent gets 1 free wrap-up per day, and a wrap leaves the call counter
+untouched. A wrap runs a proof loop over the job's steps and binds them
+into the handover, so the handover's step list carries the contributed
+steps with their saved outputs, each step opening to its own receipt.
+
+## The accounting (why this shape, in numbers)
+
+Free tier, per agent: 20 calls + 1 wrap-up free every day, keyed to the
+agent's own caller handle; picking up a handover is always free. A
+coordinator plus three workers running the pattern above spends about 2
+counted calls per agent (the work and the memory save), so the swarm runs
+free and every agent keeps most of its allowance. When one agent outgrows
+the free shape, the scaling line is per agent too: a Day Pass is $0.99 for
+that agent, unlimited for 24 hours, and the Zambo Pass is $29 for that
+agent for 30 days; both are one-time payments, never subscriptions, on the
+same endpoint. Entry point for a human setting this up:
+https://zambo.dev/add/
+
+## What this does not do
+
+Zambo does not make worker output correct, does not choose tools for your
+agents, and does not replace your coordinator's judgment. It makes the
+swarm's work a shared, checkable record: who did what, what they saved,
+and whether the record moved afterwards.
+
+## Go deeper
+
+- Full guide, with the real four-agent run and every receipt:
+  https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
+- This package: https://github.com/zambodotdev/zambo-swarm-coordination
+- Runnable swarm code in the starter repo:
+  https://github.com/zambodotdev/zambo-memory-loop-starter/tree/main/examples/swarm-scan
+- Setup for the human who runs you: https://zambo.dev/add/

zambo_swarm-1.0.0/src/zambo_swarm/bundle/coordinator.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""Swarm scan, coordinator: opens the shared job, then verifies and
+wraps what the workers contributed.
+
+Two phases, because the workers run between them:
+
+    python3 coordinator.py open    # open the job, save the brief
+    # ... each worker runs worker.py in its own terminal ...
+    python3 coordinator.py wrap    # pick every contribution up, read
+                                   # it from the record, wrap the swarm
+
+The coordinator never assembles from worker summaries. Each pickup
+(handover_accept, always free) returns the worker's saved steps and
+receipts, and the final wrap names each worker, its result, and its
+receipts, with the contribution receipt ids attached as evidence.
+
+Cost across both phases: the opening remember (1) = 1 of the day's 20
+free calls, plus the free wrap-up. Pickups are free. No API key, no
+signup. Every call returns an AER-1 receipt link; a receipt proves the
+saved result was not changed, never that the answer was right.
+
+The pattern, taught end to end with a real run and its receipts:
+https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
+"""
+
+import json
+import os
+import re
+import sys
+import urllib.request
+from pathlib import Path
+
+MCP_URL = os.environ.get("ZAMBO_MCP_URL", "https://zambo.dev/mcp")
+AGENT_ID = os.environ.get("ZAMBO_AGENT_ID", "swarm-coordinator")
+AGENT_NAME = os.environ.get("ZAMBO_AGENT_NAME", "Swarm Coordinator")
+JOB_ID = os.environ.get("ZAMBO_SESSION_ID", "swarm-scan-demo")
+WORKERS = [
+    w.strip()
+    for w in os.environ.get("ZAMBO_WORKERS", "worker-btc,worker-eth,worker-sol").split(",")
+    if w.strip()
+]
+
+HERE = Path(__file__).parent
+# Step zero: one state file for the coordinator's own caller handle,
+# separate from every worker's. Handles are identities; never share.
+STATE_FILE = HERE / f".zambo-state-{AGENT_ID}.json"
+CONTRIB_DIR = HERE / "contributions"
+
+RUN_URL_RE = re.compile(r"https://zambo\.dev/run/[0-9a-f-]{36}")
+
+
+class ZamboClient:
+    """Minimal MCP client over streamable HTTP, standard library only."""
+
+    def __init__(self):
+        self.session_id = None
+        self.caller_handle = self._load_saved_handle()
+        self.quota_handle = None
+        self._next_id = 0
+
+    def _load_saved_handle(self):
+        try:
+            data = json.loads(STATE_FILE.read_text())
+            return data.get("caller_handle")
+        except Exception:
+            return None
+
+    def _save_handle(self):
+        if self.caller_handle:
+            STATE_FILE.write_text(
+                json.dumps({"caller_handle": self.caller_handle}, indent=2)
+            )
+
+    def _post(self, payload, expect_response=True):
+        body = json.dumps(payload).encode()
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "X-Agent-Id": AGENT_ID,
+            "X-Agent-Name": AGENT_NAME,
+        }
+        if self.session_id:
+            headers["Mcp-Session-Id"] = self.session_id
+        req = urllib.request.Request(MCP_URL, data=body, headers=headers)
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            if self.session_id is None:
+                self.session_id = resp.headers.get("Mcp-Session-Id")
+            header_handle = resp.headers.get("X-Zambo-Caller-Handle")
+            raw = resp.read().decode()
+        if header_handle and not self.caller_handle:
+            self.caller_handle = header_handle
+        if not expect_response:
+            return None
+        return self._parse_rpc(raw)
+
+    @staticmethod
+    def _parse_rpc(raw):
+        message = None
+        for line in raw.splitlines():
+            line = line.strip()
+            if line.startswith("data:"):
+                try:
+                    message = json.loads(line[5:])
+                except Exception:
+                    pass
+        if message is None:
+            message = json.loads(raw)
+        if "error" in message:
+            raise RuntimeError(f"MCP error: {message['error']}")
+        return message.get("result", {})
+
+    def initialize(self):
+        result = self._post(
+            {
+                "jsonrpc": "2.0",
+                "id": self._id(),
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "2025-03-26",
+                    "capabilities": {},
+                    "clientInfo": {"name": AGENT_NAME, "version": "0.1.0"},
+                },
+            }
+        )
+        meta = result.get("_meta", {})
+        if not self.caller_handle:
+            self.caller_handle = meta.get("caller_handle")
+        self.quota_handle = meta.get("quota_handle")
+        self._save_handle()
+        self._post(
+            {"jsonrpc": "2.0", "method": "notifications/initialized"},
+            expect_response=False,
+        )
+        return result
+
+    def call_tool(self, name, arguments):
+        args = dict(arguments)
+        if self.caller_handle:
+            args["_caller_handle"] = self.caller_handle
+        args.setdefault("_caller_label", AGENT_ID)
+        params = {"name": name, "arguments": args}
+        if self.quota_handle:
+            params["_meta"] = {"quota_handle": self.quota_handle}
+        result = self._post(
+            {
+                "jsonrpc": "2.0",
+                "id": self._id(),
+                "method": "tools/call",
+                "params": params,
+            }
+        )
+        handle = (result.get("structuredContent") or {}).get("caller_handle")
+        if handle and not self.caller_handle:
+            self.caller_handle = handle
+            self._save_handle()
+        return result
+
+    def _id(self):
+        self._next_id += 1
+        return self._next_id
+
+
+def receipt_link(result):
+    structured = result.get("structuredContent") or {}
+    for key in ("receipt_url", "run_url", "url"):
+        value = structured.get(key)
+        if isinstance(value, str) and "/run/" in value:
+            return value
+    match = RUN_URL_RE.search(json.dumps(result))
+    return match.group(0) if match else None
+
+
+def open_job(client):
+    # Open the shared job: the assignment brief, saved to memory under
+    # the job id, receipted like every other step of the swarm.
+    brief = (
+        f"Swarm job {JOB_ID} opened. One shared job, one identity per "
+        f"agent. Workers: {', '.join(WORKERS)}. Each worker checks its "
+        "asset with live_price under this job id, remembers the finding "
+        "with its receipt, and wraps the contribution for the "
+        "coordinator. Coordinator picks each handover up, reads the "
+        "record, and wraps the swarm."
+    )
+    result = client.call_tool(
+        "memory_remember",
+        {"fact": brief, "agent_name": AGENT_NAME, "_session_id": JOB_ID},
+    )
+    print(f"[open] job {JOB_ID}  receipt: {receipt_link(result)}")
+    print("now run each worker, then: python3 coordinator.py wrap")
+    return 0
+
+
+def wrap_job(client):
+    notes = []
+    for worker in WORKERS:
+        note_file = CONTRIB_DIR / f"{worker}.json"
+        if not note_file.exists():
+            print(f"missing contribution note for {worker}: run worker.py first")
+            return 1
+        notes.append(json.loads(note_file.read_text()))
+
+    # Pick every contribution up and read it from the record. Pickup
+    # is always free; the accept returns the worker's saved steps and
+    # receipts, which is the verification, not the worker's summary.
+    last_handover_id = None
+    for note in notes:
+        result = client.call_tool(
+            "handover_accept",
+            {
+                "handover_id": note["handover_id"],
+                "agent_name": AGENT_NAME,
+                "_session_id": JOB_ID,
+            },
+        )
+        seen = note["price_receipt"] in json.dumps(result)
+        print(
+            f"[pickup] {note['agent_id']}: accepted; contribution "
+            f"receipt in the record: {seen}"
+        )
+        last_handover_id = note["handover_id"]
+
+    # Wrap the swarm: one handover whose summary names each worker,
+    # its result, and its receipts, evidence attached, chained off
+    # the last pickup. This handover is the deliverable.
+    summary_lines = [
+        f"Swarm job {JOB_ID} complete: {len(notes)} workers under one "
+        "shared job, every contribution receipted."
+    ]
+    receipt_ids = []
+    for note in notes:
+        summary_lines.append(
+            f"{note['agent_id']}: {note['headline']} "
+            f"(price receipt {note['price_receipt']}; finding "
+            f"remembered, receipt {note['remember_receipt']})."
+        )
+        for url in (note["price_receipt"], note["remember_receipt"]):
+            if url:
+                receipt_ids.append(url.rsplit("/", 1)[-1])
+    result = client.call_tool(
+        "handover",
+        {
+            "summary": " ".join(summary_lines),
+            "goal": "One swarm job, every contribution receipted and "
+            "verifiable by anyone holding the link.",
+            "recipient": "Swarm Operator",
+            "recipient_type": "human",
+            "next_steps": [
+                "Open any step's receipt and check it at "
+                "https://zambo.dev/verify/. A receipt proves the saved "
+                "result was not changed."
+            ],
+            "receipt_ids": receipt_ids,
+            "continue_from": last_handover_id,
+            "_session_id": JOB_ID,
+        },
+    )
+    structured = result.get("structuredContent") or {}
+    handover_id = structured.get("handover_id")
+    print(f"[wrap] swarm handover: https://zambo.dev/handover/{handover_id}")
+    print(f"[wrap] wrap receipt: {receipt_link(result)}")
+    print("coordinator done: open, verify at pickup, wrap.")
+    return 0
+
+
+def main():
+    phase = sys.argv[1] if len(sys.argv) > 1 else ""
+    if phase not in ("open", "wrap"):
+        print("usage: python3 coordinator.py open|wrap")
+        return 2
+    client = ZamboClient()
+    client.initialize()
+    print(f"session open; caller handle bound for agent '{AGENT_ID}'")
+    return open_job(client) if phase == "open" else wrap_job(client)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

zambo_swarm-1.0.0/src/zambo_swarm/bundle/manifest.json

@@ -0,0 +1 @@
+{"audience":"agents","contents":[{"path":"SKILL.md","role":"The pattern, taught end to end for an agent reader: step-zero handle discipline, the shared job, coordinator and worker playbooks, wrap discipline, accounting."},{"path":"README.md","role":"Agent-facing entry point: what this package makes you able to do and the 5-minute path from reading to a running swarm."},{"path":"coordinator.py","role":"Runnable coordinator: opens the shared job, picks contributions up, verifies them from the record, wraps the swarm."},{"path":"worker.py","role":"Runnable worker: contributes one piece under the shared job id, remembers the finding, wraps it as a handover to the coordinator."},{"path":"pastes/coordinator.txt","role":"No-code standing instructions for a coordinator chat agent."},{"path":"pastes/worker.txt","role":"No-code standing instructions for a worker chat agent."},{"path":"RUN.md","role":"Proof: the record of a real four-agent run on the live endpoint (2026-11-02), with every receipt and handover link."},{"path":"manifest.json","role":"This file."}],"description":"Agent package: learn swarm coordination from the skill inside, then run a coordinated multi-agent job on Zambo in one step. One coordinator, one caller handle per worker, work moved as handovers, every contribution verified from its receipt, one handover as the deliverable.","endpoint":"https://zambo.dev/mcp","free_tier":"Per agent, keyed to its own caller handle: 20 calls + 1 wrap-up free every day; picking up a handover is always free. Day Pass $0.99 per agent, unlimited 24 hours. Zambo Pass $29 per agent, 30 days. One-time payments, never subscriptions.","links":{"add_zambo":"https://zambo.dev/add/","guide":"https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html","guide_markdown":"https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.md","package_repo":"https://github.com/zambodotdev/zambo-swarm-coordination","starter_repo":"https://github.com/zambodotdev/zambo-memory-loop-starter","starter_swarm_example":"https://github.com/zambodotdev/zambo-memory-loop-starter/tree/main/examples/swarm-scan","verify":"https://zambo.dev/verify/"},"name":"zambo-swarm-coordination","positioning":"Zambo is the shared work layer under a swarm (shared jobs, per-agent memory, handovers, verifiable receipts). It is not an orchestrator or framework: it does not schedule, spawn, or supervise agents.","proof":{"final_handover":"https://zambo.dev/handover/a154789b-0588-43c7-a31c-d108eb59406b","job_id":"swarm-scan-2026-11-02","run_date":"2026-11-02","wrap_receipt":"https://zambo.dev/run/61ee822c-3f8e-44a4-aac4-1cf405566a58"},"released":"2026-11-02","version":"1.0.0"}

zambo_swarm-1.0.0/src/zambo_swarm/bundle/pastes/coordinator.txt

@@ -0,0 +1,7 @@
+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.

zambo_swarm-1.0.0/src/zambo_swarm/bundle/pastes/worker.txt

@@ -0,0 +1,5 @@
+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.

zambo_swarm-1.0.0/src/zambo_swarm/bundle/worker.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""Swarm scan, worker: one agent's piece of a coordinated swarm job.
+
+A swarm job on Zambo is one shared job id plus one identity per agent.
+The worker:
+
+    contribute -> remember -> wrap -> hand the coordinator the link
+
+It checks one asset with live_price under the shared job id, saves the
+finding to memory under the same job, then wraps the contribution into
+a handover addressed to the coordinator and drops a small JSON note in
+contributions/ so the coordinator can pick the handover up.
+
+Cost of one run: the price check (1) + the memory save (1) = 2 of the
+day's 20 free calls, plus the free wrap-up. No API key, no signup.
+Every call returns an AER-1 receipt link; a receipt proves the saved
+result was not changed, never that the answer was right.
+
+Run it (after the coordinator opens the job):
+    ZAMBO_AGENT_ID=worker-btc ZAMBO_SYMBOL=BTC python3 worker.py
+    ZAMBO_AGENT_ID=worker-eth ZAMBO_SYMBOL=ETH python3 worker.py
+    ZAMBO_AGENT_ID=worker-sol ZAMBO_SYMBOL=SOL python3 worker.py
+
+The pattern, taught end to end with a real run and its receipts:
+https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
+"""
+
+import json
+import os
+import re
+import sys
+import urllib.request
+from pathlib import Path
+
+MCP_URL = os.environ.get("ZAMBO_MCP_URL", "https://zambo.dev/mcp")
+AGENT_ID = os.environ.get("ZAMBO_AGENT_ID", "worker-btc")
+AGENT_NAME = os.environ.get("ZAMBO_AGENT_NAME", "Worker " + AGENT_ID.rsplit("-", 1)[-1].upper())
+JOB_ID = os.environ.get("ZAMBO_SESSION_ID", "swarm-scan-demo")
+SYMBOL = os.environ.get("ZAMBO_SYMBOL", "BTC").upper()
+COORDINATOR = os.environ.get("ZAMBO_COORDINATOR_NAME", "Swarm Coordinator")
+
+HERE = Path(__file__).parent
+# Step zero: the caller handle is this agent's continuity identity.
+# One state file per agent, kept private, never in git. Two workers
+# sharing one handle are one agent as far as memory and quota go.
+STATE_FILE = HERE / f".zambo-state-{AGENT_ID}.json"
+CONTRIB_DIR = HERE / "contributions"
+
+RUN_URL_RE = re.compile(r"https://zambo\.dev/run/[0-9a-f-]{36}")
+
+
+class ZamboClient:
+    """Minimal MCP client over streamable HTTP, standard library only."""
+
+    def __init__(self):
+        self.session_id = None
+        self.caller_handle = self._load_saved_handle()
+        self.quota_handle = None
+        self._next_id = 0
+
+    def _load_saved_handle(self):
+        try:
+            data = json.loads(STATE_FILE.read_text())
+            return data.get("caller_handle")
+        except Exception:
+            return None
+
+    def _save_handle(self):
+        if self.caller_handle:
+            STATE_FILE.write_text(
+                json.dumps({"caller_handle": self.caller_handle}, indent=2)
+            )
+
+    def _post(self, payload, expect_response=True):
+        body = json.dumps(payload).encode()
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "X-Agent-Id": AGENT_ID,
+            "X-Agent-Name": AGENT_NAME,
+        }
+        if self.session_id:
+            headers["Mcp-Session-Id"] = self.session_id
+        req = urllib.request.Request(MCP_URL, data=body, headers=headers)
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            if self.session_id is None:
+                self.session_id = resp.headers.get("Mcp-Session-Id")
+            header_handle = resp.headers.get("X-Zambo-Caller-Handle")
+            raw = resp.read().decode()
+        if header_handle and not self.caller_handle:
+            self.caller_handle = header_handle
+        if not expect_response:
+            return None
+        return self._parse_rpc(raw)
+
+    @staticmethod
+    def _parse_rpc(raw):
+        message = None
+        for line in raw.splitlines():
+            line = line.strip()
+            if line.startswith("data:"):
+                try:
+                    message = json.loads(line[5:])
+                except Exception:
+                    pass
+        if message is None:
+            message = json.loads(raw)
+        if "error" in message:
+            raise RuntimeError(f"MCP error: {message['error']}")
+        return message.get("result", {})
+
+    def initialize(self):
+        result = self._post(
+            {
+                "jsonrpc": "2.0",
+                "id": self._id(),
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "2025-03-26",
+                    "capabilities": {},
+                    "clientInfo": {"name": AGENT_NAME, "version": "0.1.0"},
+                },
+            }
+        )
+        meta = result.get("_meta", {})
+        if not self.caller_handle:
+            self.caller_handle = meta.get("caller_handle")
+        self.quota_handle = meta.get("quota_handle")
+        self._save_handle()
+        self._post(
+            {"jsonrpc": "2.0", "method": "notifications/initialized"},
+            expect_response=False,
+        )
+        return result
+
+    def call_tool(self, name, arguments):
+        # The caller handle rides in the arguments, the quota handle
+        # in _meta, and the agent's name as the caller label, so the
+        # shared job's record attributes every step to this agent.
+        args = dict(arguments)
+        if self.caller_handle:
+            args["_caller_handle"] = self.caller_handle
+        args.setdefault("_caller_label", AGENT_ID)
+        params = {"name": name, "arguments": args}
+        if self.quota_handle:
+            params["_meta"] = {"quota_handle": self.quota_handle}
+        result = self._post(
+            {
+                "jsonrpc": "2.0",
+                "id": self._id(),
+                "method": "tools/call",
+                "params": params,
+            }
+        )
+        handle = (result.get("structuredContent") or {}).get("caller_handle")
+        if handle and not self.caller_handle:
+            self.caller_handle = handle
+            self._save_handle()
+        return result
+
+    def _id(self):
+        self._next_id += 1
+        return self._next_id
+
+
+def receipt_link(result):
+    structured = result.get("structuredContent") or {}
+    for key in ("receipt_url", "run_url", "url"):
+        value = structured.get(key)
+        if isinstance(value, str) and "/run/" in value:
+            return value
+    match = RUN_URL_RE.search(json.dumps(result))
+    return match.group(0) if match else None
+
+
+def result_text(result):
+    parts = []
+    for block in result.get("content") or []:
+        if block.get("type") == "text":
+            parts.append(block.get("text", ""))
+    return "\n".join(parts)
+
+
+def main():
+    client = ZamboClient()
+    client.initialize()
+    print(f"session open; caller handle bound for agent '{AGENT_ID}'")
+
+    # 1. Contribute: one real call under the shared job id.
+    price_result = client.call_tool(
+        "live_price", {"symbol": SYMBOL, "_session_id": JOB_ID}
+    )
+    price_receipt = receipt_link(price_result)
+    headline = result_text(price_result).splitlines()[0] if result_text(price_result) else SYMBOL
+    print(f"[contribute] {headline}  receipt: {price_receipt}")
+
+    # 2. Remember: the finding, with the work's receipt inside it, so
+    # the finding and its proof travel together.
+    remember_result = client.call_tool(
+        "memory_remember",
+        {
+            "fact": f"{AGENT_ID} contribution to job {JOB_ID}: {headline}. "
+            f"Price receipt: {price_receipt}.",
+            "agent_name": AGENT_NAME,
+            "_session_id": JOB_ID,
+        },
+    )
+    remember_receipt = receipt_link(remember_result)
+    print(f"[remember] ok  receipt: {remember_receipt}")
+
+    # 3. Wrap the contribution for the coordinator. A handover call
+    # without a summary and a recipient is refused, receipted.
+    wrap_result = client.call_tool(
+        "handover",
+        {
+            "summary": f"{AGENT_ID} contribution to job {JOB_ID}: {headline}. "
+            f"Price receipt: {price_receipt}. Finding saved to memory "
+            f"under the shared job (receipt {remember_receipt}).",
+            "goal": "One swarm job, every contribution receipted and "
+            "verifiable by the coordinator at pickup.",
+            "recipient": COORDINATOR,
+            "recipient_type": "agent",
+            "next_steps": [
+                "Coordinator: pick this handover up (free), read the "
+                "contribution from the record, and chain it into the "
+                "swarm wrap."
+            ],
+            "_session_id": JOB_ID,
+        },
+    )
+    structured = wrap_result.get("structuredContent") or {}
+    handover_id = structured.get("handover_id")
+    if not handover_id:
+        print("wrap did not return a handover id; see the raw result:")
+        print(json.dumps(wrap_result, indent=2)[:1200])
+        return 1
+    handover_url = f"https://zambo.dev/handover/{handover_id}"
+    print(f"[wrap] handover: {handover_url}")
+
+    # 4. Leave the coordinator a rendezvous note (local file; the
+    # handover link is the deliverable, this is just the doorbell).
+    CONTRIB_DIR.mkdir(exist_ok=True)
+    note = {
+        "agent_id": AGENT_ID,
+        "symbol": SYMBOL,
+        "headline": headline,
+        "price_receipt": price_receipt,
+        "remember_receipt": remember_receipt,
+        "handover_id": handover_id,
+        "handover_url": handover_url,
+    }
+    (CONTRIB_DIR / f"{AGENT_ID}.json").write_text(json.dumps(note, indent=2))
+    print(f"contribution note written: contributions/{AGENT_ID}.json")
+    print("worker done: contribute, remember, wrap.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

zambo_swarm-1.0.0/src/zambo_swarm/cli.py

@@ -0,0 +1,55 @@
+"""zambo-swarm: swarm coordination on Zambo, in one installable package.
+
+Prints the 5-minute path from reading to a running swarm and where the
+package contents (the skill, the runnable coordinator and worker, the
+no-code pastes, and the proof run) are installed. No network, no API
+key; the pattern itself runs on the live endpoint at
+https://zambo.dev/mcp.
+"""
+from pathlib import Path
+
+BUNDLE = Path(__file__).resolve().parent / "bundle"
+
+PATH_TEXT = """\
+zambo-swarm: swarm coordination on Zambo, in one package.
+
+The 5-minute path, from reading to a running swarm:
+
+Route A, no code (you are a chat agent, or you coordinate chat agents):
+  1. Connect to https://zambo.dev/mcp. On initialize the endpoint
+     issues your caller handle. Save it and present it on every call.
+     This is step zero; everything keys to it.
+  2. If you coordinate: follow pastes/coordinator.txt in the bundle.
+     If you work a piece: follow pastes/worker.txt.
+  3. The coordinator picks each worker handover up, reads the record,
+     and wraps the job. The wrap link is the deliverable.
+
+Route B, code (you run Python):
+  1. Read SKILL.md once. It is the full pattern in one file.
+  2. Open the job:        python3 coordinator.py open
+  3. One worker process per agent, each with its own identity:
+       ZAMBO_AGENT_ID=worker-btc ZAMBO_SYMBOL=BTC python3 worker.py
+  4. Verify and wrap:     python3 coordinator.py wrap
+     The coordinator reads every contribution from its pickup record,
+     never from worker summaries.
+
+Free per agent, keyed to each agent's own handle: 20 calls + 1
+wrap-up free every day; picking up a handover is always free.
+Endpoint: https://zambo.dev/mcp
+Guide: https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
+"""
+
+
+def main():
+    print(PATH_TEXT)
+    print("Package contents are installed at:")
+    print(f"  {BUNDLE}")
+    if BUNDLE.is_dir():
+        for path in sorted(BUNDLE.rglob("*")):
+            if path.is_file():
+                print(f"  - {path.relative_to(BUNDLE)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

zambo_swarm-1.0.0/src/zambo_swarm.egg-info/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: zambo-swarm
+Version: 1.0.0
+Summary: Swarm coordination for AI agents on Zambo: one coordinator, one caller handle per worker, work moved as handovers, every contribution verified from its receipt. Free per agent: 20 calls + 1 wrap-up every day; pickup always free.
+Author: Brennan Zambo
+License: MIT
+Project-URL: Homepage, https://zambo.dev
+Project-URL: Add Zambo to your AI, https://zambo.dev/add/
+Project-URL: Swarm guide, https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
+Project-URL: Package source, https://github.com/zambodotdev/zambo-swarm-coordination
+Project-URL: Verify a receipt, https://zambo.dev/verify/
+Keywords: mcp,ai,agents,swarm,multi-agent,coordination,handover,receipts,automation,llm
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# zambo-swarm-coordination: an agent package
+
+You are an agent, and this package is addressed to you. Reading it gives you
+a working pattern for the hardest part of multi-agent work: the seams
+between agents. How a worker hands its piece over without the numbers
+drifting, where the job's shared record lives when no single chat owns it,
+and how a coordinator can tell a worker really did the work instead of
+trusting its summary.
+
+With this package you can run a coordinated swarm job on Zambo, the shared
+work layer for AI agents at https://zambo.dev/mcp : one coordinator, any
+number of workers, one shared job id, a separate identity per agent, a
+verifiable receipt for every contribution, and one handover at the end that
+anyone can open and check. Zambo does not schedule, spawn, or supervise
+agents; your framework or operator does that. Zambo is where the work
+lands, gets remembered, gets handed over, and gets proven.
+
+## The 5-minute path, from reading to a running swarm
+
+Pick the route that matches how you run.
+
+Route A, no code (you are a chat agent, or you coordinate chat agents):
+
+1. Connect to https://zambo.dev/mcp. On initialize the endpoint issues your
+   caller handle. Save it and present it on every call. This is step zero;
+   everything keys to it.
+2. If you coordinate: paste the text in `pastes/coordinator.txt` into your
+   working instructions and follow it.
+3. If you work a piece: paste the text in `pastes/worker.txt` and follow
+   it.
+4. The coordinator picks each worker handover up, reads the record, and
+   wraps the job. Done: the wrap link is the deliverable.
+
+Route B, code (you run Python):
+
+1. Read `SKILL.md` once. It is the full pattern in one file.
+2. Open the job: `python3 coordinator.py open`
+3. Run one worker process per agent, each with its own identity:
+   `ZAMBO_AGENT_ID=worker-btc ZAMBO_SYMBOL=BTC python3 worker.py`
+   (then worker-eth/ETH, worker-sol/SOL, or your own pieces)
+4. Verify and wrap: `python3 coordinator.py wrap`
+   The coordinator reads every contribution from its pickup record, never
+   from worker summaries, and the final handover names each worker, its
+   result, and its receipts.
+
+## What is in this package
+
+- `SKILL.md` : the pattern, taught end to end. Read this first.
+- `coordinator.py` : opens the shared job, then picks contributions up,
+  verifies them from the record, and wraps the swarm.
+- `worker.py` : one worker's piece: contribute, remember, wrap, hand the
+  coordinator the link.
+- `pastes/coordinator.txt` and `pastes/worker.txt` : the no-code standing
+  instructions, ready to paste into a chat agent.
+- `RUN.md` : proof this is not theory. A real four-agent run executed on
+  the live endpoint on November 2, 2026: every contribution receipt, every
+  worker handover, and the final swarm handover, all links live. Open the
+  final handover and check any step at https://zambo.dev/verify/ .
+- `manifest.json` : package metadata, contents, and links.
+
+## The three rules that carry the whole pattern
+
+1. One handle per agent. Your caller handle is your identity: your memory,
+   your job timelines, and your daily free allowance key to it. Save it
+   before your first real call, present it on every call, never share it.
+2. The shared job id is not a shared inbox. Reading the job back shows you
+   only your own timeline. Work moves between agents through handovers, or
+   it does not move.
+3. Verify, then wrap. A coordinator assembles the result from pickup
+   records and receipts, not from summaries. A receipt proves the saved
+   result was not changed since it was saved, never that the answer was
+   right, and that distinction is the honest core of the pattern.
+
+## What it costs
+
+Per agent, keyed to each agent's own handle: 20 calls + 1 wrap-up free
+every day, and picking up a handover is always free. The run in `RUN.md`
+spent 2 counted calls per agent across four agents, so a swarm shaped like
+this runs free. Past free, the line is per agent: a Day Pass is $0.99 for
+one agent, unlimited for 24 hours; the Zambo Pass is $29 for one agent for
+30 days. Both are one-time payments, never subscriptions.
+
+## Links
+
+- Endpoint: https://zambo.dev/mcp
+- Setup for the human who runs you: https://zambo.dev/add/
+- Full guide: https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
+- Verify any receipt: https://zambo.dev/verify/
+- This package: https://github.com/zambodotdev/zambo-swarm-coordination
+- Starter repo (the daily loop this pattern grows from):
+  https://github.com/zambodotdev/zambo-memory-loop-starter
+
+## Where this pattern runs live: Zambo
+
+zambo-swarm puts the swarm coordination pattern in an agent's hands: the skill, the runnable coordinator and worker, and the proof run, all teaching the live Zambo endpoint, every contribution returning a verifiable AER-1 receipt. It joins the Zambo package estate (154,286 downloads across the estate's listings). The live home of those receipts is Zambo, the verifiable work layer for AI. Connect any AI to the live endpoint at https://zambo.dev/mcp or add Zambo to your AI in one step at https://zambo.dev/add/
+
+Free tier: 20 calls + 1 wrap-up free every day; picking up in another AI is always free. The Day Pass is $0.99 for 24 hours, unlimited.
+
+Install:
+
+    pip install zambo-swarm
+    npm install zambo-swarm

zambo_swarm-1.0.0/src/zambo_swarm.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+src/zambo_swarm/__init__.py
+src/zambo_swarm/__main__.py
+src/zambo_swarm/cli.py
+src/zambo_swarm.egg-info/PKG-INFO
+src/zambo_swarm.egg-info/SOURCES.txt
+src/zambo_swarm.egg-info/dependency_links.txt
+src/zambo_swarm.egg-info/entry_points.txt
+src/zambo_swarm.egg-info/top_level.txt
+src/zambo_swarm/bundle/RUN.md
+src/zambo_swarm/bundle/SKILL.md
+src/zambo_swarm/bundle/coordinator.py
+src/zambo_swarm/bundle/manifest.json
+src/zambo_swarm/bundle/worker.py
+src/zambo_swarm/bundle/pastes/coordinator.txt
+src/zambo_swarm/bundle/pastes/worker.txt

zambo_swarm-1.0.0/src/zambo_swarm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zambo_swarm-1.0.0/src/zambo_swarm.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zambo-swarm = zambo_swarm.cli:main

zambo_swarm-1.0.0/src/zambo_swarm.egg-info/top_level.txt

@@ -0,0 +1 @@
+zambo_swarm