What a summary handoff drops
The standard handoff is a prompt: the outgoing agent compresses the job into a brief, and the receiving agent starts from the brief. Compression is the point, and it is also the failure. A summary is written by the system whose work is being handed over, from that system's account of its own run:
- Completed steps blur. The brief says the research is done and the draft exists. It does not say which calls produced them, with what inputs, or what actually came back.
- Failures evaporate. A call that errored, a retry that changed the parameters, a step that was skipped entirely: summaries describe the plan as executed, whether or not it was.
- The context window squeezes twice. A long job already forced the first agent to compress its own history to fit the window. The handoff compresses that compression, and the receiving agent inherits the loss twice over.
- Nothing can be checked. The brief carries no commitments. The receiving agent's only options are to believe it or to redo the work.
The fix is not a longer brief. It is a second artifact next to the brief: the record of what the first agent actually did, captured while it did it.
The two halves of a handoff that holds up
The working context
The goal and its constraints. The current state of the work, in the artifacts themselves, not descriptions of them. The decisions already made and why. The open questions and known blockers. This half tells the receiving agent what the job is.
The proven history
One verifiable receipt per tool call that already ran: the tool, the arguments, the exact result that came back, a timestamp, saved by the executing layer at call time under a hash. This half tells the receiving agent what state the job is actually in, in a form it can recompute instead of believe.
Either half alone fails. Context without the record is a story the receiver cannot verify. The record without context is evidence without a job attached. Together they are a handoff the receiving agent can start from with its eyes open: it knows the goal, and it knows which claimed steps are backed by receipts and which are not.
How a receipt-based handoff works
- Run the work so it leaves a record. When calls run through Zambo's executing layer, each one is saved as a verifiable receipt at the moment it executes: tool name, arguments, observed result bytes and their hash, timestamp, and the call's place in the run.
- Close the run before you hand it over. A multi-step job closes under a single workflow commitment computed from its step receipt identifiers, so the recorded set itself is checkable: the receiver can count steps claimed against steps recorded.
- Pass both halves. The receiving agent gets the working context plus the receipts (or the run's record link). This works identically from Claude to ChatGPT, from Grok to ChatGPT, or between two sessions of the same AI, because the record lives outside all of them.
- Verify before building. The receiver, or you, recomputes each receipt's hash over its saved result and compares it to the record, the same check the receipt verifier walkthrough steps through. Steps with no receipt are treated as not done, and the new work starts from the verified state.
Hand off your first run
- See one receipt: the live demo runs a real call and hands you its verifiable receipt, no signup. That receipt is the unit every handoff above is built from.
- Receipt a whole run: connect an agent over MCP at zambo.dev/mcp and every call in the run leaves a receipt as it executes, ready to hand to the next AI. A Day Pass ($0.99) keeps a full day of runs receipted and seals a closed run so its record stays put.
- Keep the record in an open format: the receipts follow AER-1, an IETF Internet-Draft (draft-zambo-aer1-23), so any AI, tool, or person can check the handoff later, with public test vectors and independent implementations.
AI agent context handoff: FAQ
What is an AI agent context handoff?
An AI agent context handoff is the transfer of a job from one AI agent to another, or from one model to another, so the work continues instead of restarting. A complete handoff carries two things: the working context (the goal, the current state, the files and decisions so far) and the record of what has already been done. Most handoffs carry only the first, usually as a summary the outgoing agent writes about itself. That summary is a claim. The record underneath it, one verifiable receipt per executed call, is what lets the receiving agent check which parts of the summary are true before it builds on them.
What should an AI agent context handoff include?
Five things: the goal and its constraints; the current state of the work, in the artifacts themselves rather than a description of them; the decisions already made and why; the open questions and known blockers; and the execution record, one receipt per tool call that already ran, so the receiving agent can verify what was actually done instead of trusting the summary. Anything the handoff asserts about completed work should be checkable against the record. If a step has no receipt, the receiving agent should treat it as not yet done.
How do I hand off context from Claude to ChatGPT?
The mechanics are the same in both directions, and for Grok, Gemini, and Cursor as well: pass the working context (the goal, the current draft or files, the decisions, the open questions), and attach the execution record from the first AI's run. When the work ran through a layer that issues verifiable receipts, each step's receipt can be checked by the receiving side, by recomputing the hash over the receipt's saved result and comparing it to the record. The receiving AI then continues from a state it has verified, not from a summary it has to take on faith. A summary alone can be pasted into any chat window; a record can be checked in any of them.
Can I transfer an AI conversation to another AI?
You can transfer the transcript, and most chat tools let you copy or export it, but a transcript is the first AI's narration of the work, not the work itself. It can omit failed calls, smooth over retries, and present plans as results. Transferring the conversation gives the second AI the story; transferring the execution record alongside it gives the second AI something to check the story against. For a short chat the transcript is enough. For work that matters, transfer both, and let the record settle disagreements.
What is the best AI agent context handoff tool?
Judge any handoff tool by what the receiving side can check, not by how polished the summary looks. The criteria: does the handoff include a per-call execution record, or only generated prose? Can the receiving AI verify that record itself, by recomputing hashes, without calling the first tool's API? Does the record survive outside both AIs, in an open format, so a third tool can check it next month? A handoff built on verifiable receipts passes all three, because the receipts carry the exact saved results of the calls that ran, bound under hashes the outgoing agent cannot adjust, and the context explains the job they belong to.
How is a context handoff different from cross-AI memory?
A handoff is an event: one agent passes a specific job to another at a specific moment. Cross-AI memory is the standing layer underneath: the context, preferences, and records that persist between sessions and between AIs, so any AI you open can pick up where the last one stopped. Handoffs draw on that layer, and the part of it that matters most in a dispute is the execution record, because it is the part the receiving agent can verify instead of believe.