How do I hand a job from Claude to ChatGPT without losing the record?

Claude did the first half: the analysis, the plan, maybe a Claude Code session that already touched the codebase. Now the job moves to ChatGPT, because the next stage fits it better, because your team works there, or because Claude's window for the day is spent. The usual transfer asks Claude to summarise itself into a prompt, and ChatGPT starts from that story: the steps flattened, the tool results paraphrased, the proof gone. Move the record instead. The steps Claude actually ran, their saved results, and a receipt on each one, packaged into a single handover link that ChatGPT opens, verifies, and continues from.

See the receiving end first: this finished handover is what ChatGPT would open, and every step in it checks at zambo.dev/verify.

Published October 25, 2026. Written against AER-1, IETF Internet-Draft draft-zambo-aer1-26. AER-1 is an IETF Internet-Draft, not a finalized standard.

The short answer

Package the Claude session; do not ask it to describe itself. With Zambo added to Claude, in the app or in Claude Code, the session's calls run through https://zambo.dev/mcp and each step is saved with a verifiable receipt: an agent receipt is a record of one ai agent tool call that anyone can check: it keeps the exact saved bytes and their sha-256 digest, and it proves the result was not changed since it was saved, not that it was right. The handover tool closes the session into one link. In ChatGPT, with the same endpoint added, the receiving session reads the package and its machine-readable twin, checks the receipts behind the steps it will build on, accepts, and continues. The reverse trip has its own page: handing work from ChatGPT to Claude.

The manual transfer, honestly

Claude is a good summariser, which is exactly the trap. Its handover summary reads well, and it is still a retelling: the session compressing its own work, choosing what mattered, paraphrasing tool results that were precise the moment they returned. ChatGPT then builds on the paraphrase. The failure rarely announces itself; it shows up later, as a step redone because the summary was vague, a number trusted because the summary sounded sure, a decision relitigated because its reasoning never made the crossing. The other default, pasting the Claude transcript, keeps everything and organises nothing: ChatGPT inherits a scroll, not a state. Both defaults ask the receiver to reconstruct the job. A record does not need reconstructing. It needs reading.

The transfer, step by step, Claude side first

  1. In Claude: package at the seam. The session's recorded steps already sit outside the chat, in the app or in Claude Code alike. Run the handover tool with the goal, the recipient, and the next steps written for ChatGPT: what stage comes next, what to build on, what to leave alone. You get one link and a summary receipt over the whole package.
  2. Read the package the way ChatGPT will. The link opens in a browser and as data: each step with its tool, saved result, and receipt linked back to its source. Check the boundary: steps recorded are in; anything the session did off the record is not, and the package says so where it matters.
  3. In ChatGPT: add the endpoint, open the link. The receiving session reads the handover's machine-readable twin: goal, summary, next steps, and the step list with receipts, as data it can act on rather than prose it must interpret.
  4. ChatGPT verifies, accepts, continues. It recomputes the receipts on the steps it will build on at the public verify endpoint, accepts the handover on the record, and its own steps chain onto the trail. If Claude's limit resets tomorrow and the job swings back, the same record carries it home; that round trip is continuing after a Claude usage limit.

Setup pages for both ends: adding Zambo to Claude, adding Zambo to Claude Code, and adding Zambo to ChatGPT. The general pattern is switching AIs mid-task.

The Claude Code case, specifically

Coding sessions are where summaries lose the most, because the work product is not prose: it is a sequence of operations, searches run, files read, data returned, decisions taken on the strength of a specific output. A summary of a coding session tells ChatGPT that "the auth module was reviewed". The record shows which calls ran against it and what they returned, each with a receipt ChatGPT can recompute before it edits a line on the strength of that review. The boundary is honest in both directions: operations the session performed entirely outside the endpoint never entered the record, and no handover can carry what was never recorded. Run the session's tool work through the endpoint and the coding trail crosses intact, which is most of what a pickup session actually needs.

Scope, stated once: a verifiable receipt proves the saved result was not changed since it was saved. It does not prove the result was right, and it does not prove a step happened anywhere but in the record. ChatGPT inherits checkable evidence about the Claude half, and its review starts from that evidence.

Questions, answered

How do I transfer a project from Claude to ChatGPT?

If the project ran through the Zambo endpoint in Claude, package the session with the handover tool: the goal, the steps taken, the saved result and receipt for each step, and the next steps, at one link. In ChatGPT, with Zambo added, open the link. ChatGPT reads the steps as recorded, verifies the receipts behind the steps it will build on, accepts the handover, and continues from the recorded state. The Claude half of the job stays checkable afterwards, and the finished job reads as one trail with a visible seam.

I use Claude Code. Can ChatGPT pick up my coding session?

The recorded part of it, yes. A Claude Code session whose tool calls run through the endpoint leaves the same kind of record as any other session: steps, saved results, receipts. Package that session into a handover and ChatGPT receives the record of what was run and what it returned, which it can verify step by step before building on it. Work the session did entirely outside the endpoint, local edits never recorded as calls, is not in the package, and the handover shows that honestly as the boundary of the record.

What does ChatGPT receive when it opens the handover?

The job in recorded form: the goal, the sender's summary, the listed next steps, and every step so far with the tool that ran, the saved result, and a verifiable receipt whose published copy points back to its source receipt. It also receives the machine-readable twin of the handover, so it reads the package as data. Anything marked as not checked by the sender arrives marked as not checked, so ChatGPT knows exactly where its own verification work is before it writes a line.

Can ChatGPT verify what Claude did before continuing?

Yes. Each step's receipt commits to the exact saved bytes of that step's result, and the check is recomputed at the public verify endpoint by anyone, including the receiving session. A step that verifies is inherited as recorded; a step that fails is re-run, not trusted. A receipt proves the saved result was not changed since it was saved, not that the result was right, so ChatGPT still reviews the work, but it reviews the work Claude actually did, not Claude's account of it.

What does a Claude to ChatGPT handover cost?

The handover tool is free, and both sides run on one set of terms because it is one endpoint: 20 free calls per day, then a $0.99 Day Pass for 24 hours of higher limits, or the Zambo Pass at $29 for 30 days, one payment, $290 for 365 days, and $19 for 30 days for $ZAMBO holders. Nothing extra is charged for crossing between the two apps. People pay by card through PayPal; agents pay in USDC on Base through x402.

A job that starts in Claude can arrive in ChatGPT as a record instead of a story. Add Zambo to both and the crossing costs one link.