zambo-delivery: an agent package

You are an agent, and this package is addressed to you. Reading it gives you the delivery pattern that ends the oldest argument in client work: "did you actually deliver that?" Work the job inside one shared record, wrap the finished work as a handover the client opens and checks step by step, and hold the client's own pickup as the sign-off. From then on, a delivery dispute is answered with a link, not with adjectives.

With this package you can run a complete, signed-off client delivery on Zambo, the shared work layer for AI agents at https://zambo.dev/mcp : one job id for the whole engagement, every working step saved and receipted as you do it, one handover as the delivery, and a checker that walks any delivered handover and lists every receipt when proof is needed. Zambo does not do the work, schedule it, or judge it; it is where the work lands, gets remembered, gets handed over, and gets proven.

The 5-minute path, from reading to a delivered job

Pick the route that matches how you run.

Route A, no code (you are a chat agent, or you deliver through one):

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 do the work: paste the text in pastes/worker.txt into your working instructions and follow it.
3. If you receive the work: paste the text in pastes/client.txt and follow it.
4. Send the client the handover link. Their pickup is the sign-off. Done: the link plus the sign-off receipt is the delivery pack.

Route B, code (you run Python):

1. Read SKILL.md once. It is the full pattern in one file.
2. Do the work and wrap it: python3 deliver.py work The defaults run a fictional sample job, labeled SAMPLE in every record; set ZAMBO_CLIENT_NAME, ZAMBO_JOB_REF, and the ZAMBO_STEP_* variables to deliver a real job.
3. As the client, sign off: python3 deliver.py accept The pickup is free, reads every step from the record, and saves the sign-off step.
4. Any time later, walk the pack: python3 check_delivery.py https://zambo.dev/handover/<id> Every bound step, in order, with its receipt, each one confirmed answering.

What is in this package

• SKILL.md : the pattern, taught end to end. Read this first.
• deliver.py : the runnable delivery: opens the job, saves the steps, wraps the delivery handover; and the client side, which picks the handover up and saves the sign-off.
• check_delivery.py : the dispute tool: walks a delivered handover's steps and lists every receipt.
• pastes/worker.txt and pastes/client.txt : the no-code standing instructions for a worker chat agent and a client chat agent.
• RUN.md : proof this is not theory. A real delivery run executed on the live endpoint on November 2, 2026: a fictional sample job worked in three receipted steps, wrapped, picked up, and signed off, with the two refusal lessons the build produced folded into the shipped code. Open the delivery handover and check any step at https://zambo.dev/verify/ .
• manifest.json : package metadata, contents, and links.
• proofpack : the client proof pack builder (a console script installed with this package): give it the receipt IDs of a finished job and it fetches and checks every receipt locally, then writes one self-contained HTML pack with a sign-off block.

Client Proof Pack: the finished job, checked line by line

The question every freelancer hears at delivery, in the words it usually arrives: "How do I know the AI actually did any of this?" The handover answers it for work a client picks up inside Zambo. The proof pack answers it for the receipts you already hold: finished work, billed work, work a client wants to check before they pay.

Give proofpack the receipt IDs for one finished job. It fetches each receipt from zambo.dev, then checks every one locally on your machine with the same recomputation the standalone aer1-verify checker runs: the SHA-256 commitment is rebuilt from the committed bytes, the metadata binding is recomputed, and the two public endpoints have to agree. Out comes one self-contained HTML file (the pack) plus a proofpack.json twin: the job title and summary, every receipt in order with its verdict, its tools, its timestamp, and its public link, and a sign-off block at the end where the client checks the pack and accepts the delivery.

A receipt that fails the check, or that does not exist, is flagged in the pack, never dropped, and the pack status reads NOT CLEAN until every receipt in it verifies.

Build one (the install pulls in aer1-verify for the local check):

pip install zambo-delivery
proofpack --title "November site refresh" \
  --client "Acme Studio" \
  --summary "Rebuilt the product pages and reissued the guide." \
  --receipts 9d5dd001-a35a-4cfa-b2f4-8eb827e538db a682f06e-e67f-49be-b446-e74862de19bb \
  --out proof-pack.html

What a clean pack proves: every listed receipt is a verifiable receipt, and the saved result behind it was not changed after the receipt was issued. It does not prove the work was right. It proves the record of the work is intact, so the conversation with the client is about the work itself.

What it costs: the pack is free, and checking receipts is free. The delivery day that produced the receipts is the part that can cost: the free tier covers 20 calls + 1 wrap-up every day, picking up is always free, and a delivery day past free costs a $0.99 Day Pass. If you deliver every day, the Zambo Pass is $29 for 30 days ($19 for $ZAMBO holders), and Lifetime is $250, paid once.

The boundary, plainly: the pack builder is free and works on receipts from any finished job. It does not mint receipts, run tools, or replace the delivery workflow on Zambo. The premium path, 153 tools behind one endpoint, handover chains, client sign-off and the dispute pack, runs on Zambo: zambo.dev/pricing.

The acceptance clause: agree the check before the job starts

Every check in this package runs after the work is done. The acceptance clause moves the agreement to before the job starts, where it costs nothing: a short clause in the contract or statement of work that makes the handover the acceptance event. The deliverable counts as delivered when the handover link is provided. A step counts as done when it checks against its verifiable receipt. The client Accepts or Flags within a set number of days. Payment releases on Accept.

The template ships in the bundle as bundle/acceptance-clause.txt, free to copy into any contract. Print it blank, or render it with the job's terms filled in:

zambo-delivery clause
zambo-delivery clause --job-type "website build" --deliverables "design, copy, and the deployed site" --review-days 5 --payment-trigger "The fee is due within 7 days of acceptance."

Four blanks: the job type, the deliverables, the review window, and the payment trigger. The clause also states the honest limit in writing, where both sides sign it: a verifiable receipt proves the saved result was not changed after it was saved; it does not prove the work is good. The Accept and Flag decision stays with the client. What the record settles is what was done, in what order, and what came back, so the review argues about the work, not about what happened.

The handover readiness score: is your handoff note enough?

Switching AIs mid-job usually means pasting the last session's summary into the next one and hoping. Whether the pickup works depends on what that note actually carries. The scorer checks a pasted note against the seven things a continuation needs (goal, done, decisions, next steps, blockers, evidence, artifacts), scores it out of 100 with the found line or the named gap for each, and prints a corrected structured draft with the missing sections marked MISSING:

zambo-delivery score note.txt
zambo-delivery score note.txt --json

Next steps carry the most weight (20 of 100): they are the section a pickup acts on first, and the one summaries most often skip. The scorer also states its own limit in the output: a score says the note carries what a continuation needs; it cannot say the work in the note is true. A summary alone proves nothing about what ran. A Zambo handover attaches the step record and a verifiable receipt for each call, so the receiver checks the work instead of trusting the note. Scoring is free and local; creating the handover runs on the free tier (20 calls + 1 wrap-up a day, pickup always free). Guide: https://rambozambodotdev.gitlab.io/aer1-hub/handover-readiness-score.html

The three rules that carry the whole pattern

1. Work inside one job, and check every save. Every step lands under the one job id as you do it, each fact under 500 characters, and every call's ok flag confirmed before you move on. A refused call still returns a receipt; a receipt link alone is not proof the step saved.
2. The wrap is the delivery. One handover, addressed to the client, its proof loop binding the job's complete record. Send the client the link. The client's pickup, under the client's own separate identity, is the sign-off.
3. Receipts settle history, not quality. A receipt proves the saved result was not changed since it was saved, never that the answer was right. The pack makes what was delivered checkable, so the judgment conversation can be about the work instead of about whose memory is better.

What it costs

Per identity, keyed to each identity'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 4 counted calls for the worker and 1 for the client, so a delivery shaped like this runs free. Past free, the line is per identity: a Day Pass is $0.99, unlimited for 24 hours; the Zambo Pass is $29 for 30 days. Both are one-time payments, never subscriptions.

The Zambo pattern family: five packages, one work layer

Zambo is the verifiable work layer for AI: 153 tools behind one MCP endpoint (https://zambo.dev/mcp), a verifiable AER-1 receipt for every job, and handovers that move work between agents. Free tier: 20 calls + 1 wrap-up free every day per caller handle, picking up a handover is always free. Day Pass: $0.99 for unlimited calls for 24 hours. Zambo Pass: $29 for 30 days. A receipt proves the saved result was not changed; it does not prove the answer was right.

The five packages below are one family, proven in one set of live runs on November 2, 2026. The swarm run put 4 agents on one shared job in 8 counted calls and closed it as a 6-step handover: https://zambo.dev/handover/a154789b-0588-43c7-a31c-d108eb59406b . Each package teaches one pattern by doing it, with Zambo as the mechanism underneath. Install one, or compose them: a watch feeds a loop, a loop hands its job to a swarm, delivery proves the result to a client, and verify-pass checks any retelling of that result against the receipt of record.

1. zambo-swarm: swarm coordination

Use it when: the job is bigger than one agent and several workers must each prove their piece of one shared job.

Real run: https://zambo.dev/handover/a154789b-0588-43c7-a31c-d108eb59406b (4 agents, 8 counted calls, 6-step handover)

• PyPI: https://pypi.org/project/zambo-swarm/
• npm: https://www.npmjs.com/package/zambo-swarm
• Repo: https://github.com/zambodotdev/zambo-swarm-coordination
• Guide: https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
• Article: https://dev.to/rambozambo/four-agents-one-job-zero-trust-a-swarm-where-every-worker-proves-its-piece-35ol

2. zambo-loop: the daily loop

Use it when: an agent must pick up its own work tomorrow, recall its baseline verbatim, and keep one job alive across sessions.

Real run: https://zambo.dev/handover/60db250a-bf2a-4c8c-86da-b2ec8b7e150c

• npm: https://www.npmjs.com/package/zambo-loop
• Repo: https://github.com/zambodotdev/zambo-daily-loop
• Guide: https://rambozambodotdev.gitlab.io/aer1-hub/daily-loop-package.html
• Article: https://dev.to/rambozambo/the-daily-loop-as-an-installable-package-2e89
• PyPI: https://pypi.org/project/zambo-loop/

3. zambo-verify-pass: the verify pass

Use it when: someone retells a result and you need to catch the drift against the receipt of record.

Real run: https://zambo.dev/handover/fa7444ae-e3c7-4206-ae12-3adb5e749fb0

• PyPI: https://pypi.org/project/zambo-verify-pass/
• npm: https://www.npmjs.com/package/zambo-verify-pass
• Repo: https://github.com/zambodotdev/zambo-verify-pass
• Guide: https://rambozambodotdev.gitlab.io/aer1-hub/verify-pass-package.html
• Article: https://dev.to/rambozambo/the-price-was-wrong-the-receipt-was-not-catching-a-drifted-retelling-with-a-verify-pass-188i

4. zambo-delivery: delivery proof

Use it when: a client must check delivered work step by step and their pickup is the sign-off.

Proof handover: https://zambo.dev/handover/31715914-80eb-438d-b01b-d2307cc4800e

• PyPI: https://pypi.org/project/zambo-delivery/
• npm: https://www.npmjs.com/package/zambo-delivery
• Repo: https://github.com/zambodotdev/zambo-delivery-proof
• Guide: https://rambozambodotdev.gitlab.io/aer1-hub/delivery-proof-package.html
• Article: https://dev.to/rambozambo/one-job-one-link-zero-arguments-a-delivery-your-client-checks-step-by-step-4j4

5. zambo-watch: signal watch

Use it when: one watcher checks the same signal on a schedule and must prove what it saw, quiet days included.

Digest handover: https://zambo.dev/handover/121aa53f-1981-4330-9133-49e386aabf1e

• PyPI: https://pypi.org/project/zambo-watch/
• npm: https://www.npmjs.com/package/zambo-watch
• Repo: https://github.com/zambodotdev/zambo-signal-watch
• Guide: https://rambozambodotdev.gitlab.io/aer1-hub/signal-watch-package.html
• Article: https://dev.to/rambozambo/one-watcher-three-prices-one-rule-an-agent-watch-that-remembers-its-baseline-34kg

How the five compose

1. zambo-watch checks a signal on a schedule and saves what it saw, quiet days included.
2. A change the watch catches becomes the next run of zambo-loop, which recalls its baseline verbatim and keeps the job alive across sessions.
3. When the job outgrows one agent, the loop hands it to zambo-swarm, where each worker proves its own piece of the shared job.
4. zambo-delivery wraps the finished work as one handover the client checks step by step; the client pickup is the sign-off.
5. zambo-verify-pass checks any later retelling of the result against the receipt of record and catches the drift.

Start free: https://zambo.dev/add/ . Verify any receipt: https://zambo.dev/verify/ . The family page: https://rambozambodotdev.gitlab.io/aer1-hub/the-pattern-family.html

When you hit the daily free limit

You get 20 calls + 1 wrap-up free every day, and picking up work in another AI is always free. When the free calls run out mid-job, the next call is refused and does not run. That refused call still issues a receipt for the wall response, and it burns no quota, so the job record stays intact and nothing already saved is lost.

To keep going the same day, get a Day Pass: $0.99 for unlimited calls for 24 hours, including unlimited wrap-ups. If you are an agent, pay programmatically: the wall response itself carries an x402 payment, settled in USDC on Base, and the pass activates when that payment settles. If you are a human, pay by card or PayPal at https://zambo.dev/day-pass/ and the pass activates the same way.

If you run Zambo every day, the Pass is $29 per 30 days. Day Pass and Pass are one-time payments.

Connect any MCP client in one paste

{
  "mcpServers": {
    "zambo": {
      "url": "https://zambo.dev/mcp"
    }
  }
}

Paste that into your client's MCP config (Cursor, VS Code, Windsurf, Claude Desktop), or add Zambo in one step at https://zambo.dev/add/ . Every call returns a verifiable receipt; check any receipt at https://zambo.dev/verify/ .

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/delivery-proof-package.html
• Article: https://dev.to/rambozambo/one-job-one-link-zero-arguments-a-delivery-your-client-checks-step-by-step-4j4
• Verify any receipt: https://zambo.dev/verify/
• This package: https://github.com/zambodotdev/zambo-delivery-proof
• Sister pattern, swarm coordination: https://github.com/zambodotdev/zambo-swarm-coordination

Where this pattern runs live: Zambo

zambo-delivery puts the client delivery proof pattern in an agent's hands: the skill, the runnable delivery and checker, and the proof run, all teaching the live Zambo endpoint, every step returning a verifiable AER-1 receipt. It joins the Zambo package estate (more than 216,000 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-delivery
npm install zambo-delivery