Continue Claude Code work in Codex, and back again

There is no such thing as moving a thread between providers.

The intuitive version of this feature is a migration: take the conversation, hand it to the other model, keep going. It cannot work, for reasons that are structural rather than a matter of effort.

Claude Code resumes a JSONL file whose uuid and parentUuid chain, tool_use and tool_result pairing, and thinking signatures it validates on the way in. A Codex thread is an opaque id behind its app-server protocol. These are not two encodings of the same object; they are two different contracts with two different runtimes.

So the only honest operation is a fork across providers:

• Read the source conversation.
• Build an attributed briefing from it.
• Start a new session on the receiving provider with that briefing as its first message.
• Record the lineage somewhere that does not touch either provider's native history.

The alternative — writing the source turns into the receiving provider's transcript as its own prior turns — is worse than it sounds. It puts another model's words in the file under the wrong name, and it can produce invalid tool and signature records that break the very resume you were trying to preserve. Quoting is honest, and it cannot corrupt either side.

The briefing is the first message. It pays for itself in tokens.

Everything you quote is context the receiving agent reads before doing anything, on every fork. That makes "include the whole conversation" the wrong default: it is expensive, it buries the point, and most of a transcript is scaffolding the new agent does not need.

The two things a continuing agent actually needs are the opening goal — what was this ever for — and the most recent state — where did it get to. Between them, tool commands and the first lines of their output carry the concrete evidence.

Crowsnest's default budget for the whole briefing is 8,000 characters — deliberately compact. The receiving agent is standing in the same working directory and can always be asked to read a file for detail; what it cannot reconstruct is intent.

The other model's reasoning does not cross.

Thinking blocks are excluded from the briefing on purpose, and the reasons compound.

1. It is private chain-of-thought for a different agent.It was produced under another runtime's conventions, for its own next step, and it was never written to be read as instruction.
2. It is the bulkiest content in a transcript.Paying the token cost of one model's deliberation to prime a different model is a poor trade against the same budget spent on recent state.
3. It invites impersonation.Quoted reasoning reads like the receiving agent's own earlier thinking, which is exactly the confusion the fork model exists to avoid.

A handoff that carries less, but labels what it carried and what it dropped, produces better second attempts than one that carries everything unlabeled.

A fork you cannot trace is just a new conversation.

The reason to fork rather than start fresh is that you want the connection back. That requires three things to stay true after the handoff.

• The source is unchanged. Not annotated, not truncated, not marked as continued elsewhere in its own history. It remains exactly what it was.
• Attribution is inside the briefing. The receiving agent is told which provider and conversation the quoted material came from, so it can reason about it as someone else's work rather than its own memory.
• Lineage lives outside native history. The link between parent and child is application metadata, never an edit to a provider's transcript.

In Crowsnest, Claude children record that link in their existing sidecar and Codex children in a small app-owned index — never a rollout edit. The new session carries a visible lineage badge back to the original thread.

What Crowsnest ships today.

Open a conversation in either provider and pick Continue with … from the caret beside Continue. The receiving provider starts a new native session in the same working directory, and its first message quotes and explicitly attributes the source.

Before anything is sent, a preview shows you the exact text, how many turns were quoted, and how many were omitted for length — plus a field for an instruction of your own, which is usually where you say what the previous attempt got wrong. The source conversation is never modified, and the new session carries a lineage badge back to it.

Cross-provider handoff is part of Pro, the multi-agent layer; Standard is the complete one-agent workspace. Both providers run as the local runtimes already installed on your machine, behind a server bound to 127.0.0.1, with no transcript upload.

Sources and related field notes

Fork semantics, briefing composition, budget and clipping values, reasoning exclusion, and lineage storage were checked against the released Crowsnest handoff implementation on September 3, 2026. Provider reference: Anthropic's Claude Code documentation.