How to continue Claude Code work in Codex, and back

Continue the work in five explicit steps.

1. Open the source conversation

   Confirm the task, provider, working directory, and latest state before handing anything off.

2. Choose the receiving provider

   Use Continue with … and select Claude Code or Codex. The receiving runtime starts a new native session; it does not claim the source thread as its own history.

3. Preview the briefing

   Read the exact text, included-turn count, and omitted-turn count. The opening task and latest useful state should survive; private reasoning should not.

4. Add the next instruction

   State what the new agent should do now, especially what failed or what must change from the first attempt.

5. Start the fork and keep the link

   The receiving provider gets the attributed briefing as its first message. The source remains unchanged, and lineage identifies where the continuation came from.

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.

Compact before handoff has two explicit choices. Standard compact builds the briefing entirely on this Mac. Optional TypeSafe Jev sends at most 24 bounded, pattern-redacted excerpts to its fixed HTTPS endpoint so Jev can rank the evidence; Crowsnest still preserves the opening and latest state, restores chronological order, writes the attributed briefing, and falls back to the local method if Jev fails. Connecting a key alone enables neither search nor handoff compaction.

Cross-provider handoff is part of Pro, the operating 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. Native provider conversations otherwise stay in their own runtimes; the optional TypeSafe path is limited to the bounded excerpts described above.

Sources and related field notes

Fork semantics, briefing composition, budget and clipping values, reasoning exclusion, optional TypeSafe selection, and lineage storage were rechecked against the released Crowsnest 0.3.15 implementation on October 29, 2026. Provider reference: Anthropic's Claude Code documentation.