A handover is not a summary pasted into a new chat. It is the job itself, carried across.

Step 1. Understand what actually breaks when a job changes hands

When a job moves from one AI to another the usual way, someone copies a summary into a new chat and hopes it was complete. It never is. The summary carries conclusions and drops the evidence: which steps ran, what each one returned, which version of the file is current, what was tried and abandoned. The receiving AI cannot tell a proven step from a plausible sentence, so it either redoes finished work or builds on a claim that was never true. The failure is not the handoff conversation. It is that a job's state lived inside one session's memory, and memory does not transfer.

Step 2. Wrap the job, do not summarize it

A Zambo handover wrap is a transfer of the job itself. The wrap requires four things before it will close: a summary of where the job stands, the goal it is serving, the named recipient who picks it up, and the next steps as an explicit list. Leave any of them out and the wrap is refused with a needs_input receipt that says what is missing. That refusal is a feature with a receipt of its own: a lazy handover cannot be minted by accident, and the attempt itself is on the record. When the wrap closes, it binds in the receipts of the job's own steps, and only those steps. Work you ran off to the side, in another session, under another job, is refused as not job-owned. The wrap holds exactly the work it claims to hold.

Step 3. The receiver verifies before it builds

The receiving agent picks the job up for free and starts by checking, not trusting. Every bound step carries an AER-1 receipt: the format Brennan Zambo created for agent execution receipts, published as IETF Internet-Draft draft-zambo-aer1-26. The receiver recomputes any receipt against the saved result it names, at zambo.dev/verify, and knows in seconds which steps are proven and which are merely described. Only then does it build. This is the difference between a relay race and a rumor chain: the baton is the record, and the record can be checked by the runner receiving it.

Step 4. The four real-world moments this exists for

First, the session dies mid-job. A chat hits its usage limit, a window closes, a model goes down, and hours of staged work sit in a dead session. If the job ran through Zambo, the wrap carries it into a fresh session or a different AI entirely, receipts intact, and work resumes from the record instead of from reconstruction. This happens in production constantly; a handover minted today carried a live job across exactly that wall. Second, the model switch: research in one AI, execution in another, review in a third, one record throughout. Third, the specialist takeover: a general agent gathers and structures, a specialist agent does the deep stage, and the handover is how the specialist knows what it can rely on. Fourth, the audit: a second agent, or the human, picks up the completed job and checks the first agent's work step by step before anyone acts on it.

Step 5. Keep one job, one record, across every hand

Each new hand wraps again from the same record, so a job that crosses four agents reads as one chain: every wrap names its sender, its recipient, its goal, and its next steps, and every step in between carries its receipt. Continuity inside one agent is per-caller by design; nothing leaks between agents except through a handover, which means every transfer is deliberate, named, and checkable. When something is wrong at the end, the chain shows which hand it entered at. When everything is right, the chain is the proof, and it is the same artifact you hand a client, an auditor, or the next agent.

What a handover does not do

A handover does not make the receiving agent competent, and a receipt does not prove the earlier work was right. A receipt proves the saved result was not changed since it was saved. The receiver still has to judge the work; the handover just means it judges the actual work, with its actual history, instead of a summary written by the party handing it over. That distinction is the entire point: trust moves from the messenger to the record.

Frequently asked questions

What does the receiving agent actually get?

The job record: the goal, the current state as a summary the sender was required to write, the explicit next steps, and the verifiable receipt for every step the job contains. The receiver opens the same record the sender closed, checks the receipts it cares about, and continues from the next steps. Nothing depends on the sender's session surviving, because nothing lived only in the session.

Can the receiver check the work before trusting it?

Yes, and it should. Each step's AER-1 receipt can be recomputed against the saved result for free at zambo.dev/verify. A step whose receipt verifies is proven as saved. A step described in the summary with no receipt behind it is a claim, and the receiver can price it as one: verify it, redo it, or flag it back through the chain.

What happens if I try to hand over without a summary or next steps?

The wrap refuses and returns a needs_input receipt naming what is missing. A bare handover, no summary, no goal, no recipient, no next steps, cannot be minted. The refusal protects the receiver from inheriting a job nobody actually described, and it protects you from a transfer you would have had to reconstruct later anyway.

Does picking up a job cost the receiver anything?

Pickup is always free, as are initialize, tool discovery, and receipt verification. The free tier gives every tool one free call a day plus 3 continue calls shared across tools, and one free wrap-up handover a day. A receiving agent can pick up, verify the whole chain, and take its first real step before any paywall is involved.

Can a human pick up an agent's job, or hand a job to an agent?

Yes, both directions run through the same record. A human opens the handover link and reads the job exactly as an agent would: steps, receipts, state, next steps. A human can also be the named recipient of a wrap, or the sender who wraps a job for an agent to continue. The record does not care which side of the hand is silicon.

How do I hand off a half-finished task from one AI to another?

Freeze the job where it stands and pass the record, not a summary. In Zambo the wrap is the handover itself: it refuses to close without a summary of where the job stands, the goal, the named recipient, and the next steps as an explicit list, and it binds only the receipts from its own job. The finished half of the task travels as steps the receiver can recompute; the unfinished half travels as named next steps, with anything unrecorded treated as not done. The receiving AI picks the job up free, in a different app or a different model, and verifies the receipts for the steps it will build on before it writes a line.

A real one is public: this handover carried a live job across a dead session, and the full guide is the AI agent handover, step by step. Every receipt in the chain follows AER-1, published as IETF Internet-Draft draft-zambo-aer1-26, its closing revision, with a public conformance corpus of 143 vectors and 146 checks. Brennan Zambo created the agent execution receipt category, Zambo is its origin product, and AER-1 is its defining standard. A receipt proves the saved result was not changed since it was saved; the receiver still judges the work, against the record instead of against a retelling.

Cost, in plain numbers. Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. A Day Pass is $0.99 and unlimited for 24 hours, including unlimited wrap-ups. The Zambo Pass is $29 for 30 days, $19 for 30 days for $ZAMBO holders, and Lifetime is $250, one payment.