How to share context between Claude, ChatGPT, and Gemini without losing your mind
Every import tool, browser extension, and data export moves your chat history. None of them move what the agent figured out while working. Here's what does.
All postsYou know the drill. You spend an hour with Claude digging through a gnarly bug, and it eventually nails the fix and writes a tidy decision log. You close the tab feeling smart. The next day you open Codex to work on the UI for the same feature, and Codex has no idea any of that happened.
Welcome to the most annoying part of using multiple AI models: every switch is a context reset. The articles that rank for this problem treat it like a one-time migration ("how to move from ChatGPT to Claude without losing your data"), but that is not really the issue most of us are living with.
The real issue is that I use three models a day on the same project, and none of them can see what the others just did.
What people try (and where each one breaks)
Here's the honest tour of the workarounds I've actually used, roughly in the order most people reach for them.
Claude and Gemini memory imports
You paste a summary from another chatbot and it carries over your persona and preferences. Useful for "I write in short sentences" style things, but not for "here is the current state of the auth refactor." Chatbot memories are already compressed, and they are about you rather than about the work. Anthropic literally labels their import feature experimental.
Context Pack and similar migration tools
You export your ChatGPT conversations, upload them, and get back a distilled file to drop into Claude. Fine for a one-shot "I'm switching tools" moment. The whole design assumption is compression: you trade fidelity for brevity, which is not the right trade when you are hopping between models four times a day.
Browser extensions (AI Context Flow, Windo, etc.)
They capture your chats into folders and re-inject context on the next prompt. Useful for continuity when the work is conversational, but the capture is still user-side: it only sees what you typed and what the model replied, not the agent's scratchpad where most of the actual reasoning happens.
OpenAI and Google data exports
You request a zip, wait a day, upload it to a Claude project. Handy for the very occasional rescue, but nobody is running this pipeline every week.
A disciplined handoff doc
A markdown file with decisions, current state, blockers, and next steps, maintained by hand. This actually works if you are the kind of person who maintains it, and I tried for about a week before I stopped. Most people will have the same experience.
Memory layers (Mem0, Zep, Letta)
These move the memory out of vendor lock-in and usually expose it over MCP. The good ones are solid. The catch is that they still treat memory as something you write to the agent, so the agent stays a consumer and never becomes a producer.
Each of these fixes a slice of the problem. None of them fix the thing that's actually costing me time.
The thing none of them fix
Every tool above shares the same three assumptions, and every one of them falls apart the moment you're running a real multi-agent workflow:
- Context is treated as a snapshot. Export, import, done. That works if your context is static (writing style, tech stack), but it falls apart when the context is changing every hour.
- You are the curator. You write the summary, you upload the file, you tell the next model what matters. That is a lot of secretarial work and you will not keep up. When I was switching models four times a day, I stopped maintaining my handoff doc within about a week.
- The agent is only ever a consumer. These tools move user-authored context around, but none of them capture what the agent actually reasoned through: what it tried and ditched, which approach it rejected, and why. That is the expensive stuff, the hour of thinking that produced the decision, and it lives in a tab you are about to close.
So what does fix it?
A workspace where humans and agents both write
Imagine a shared notebook for each piece of work, one that every model can read from and (critically) write to. When Claude makes a decision, it logs it. When Codex hits a gotcha, it logs that too. When Gemini flags a concern in a review pass, same thing. Open a fresh session tomorrow and everything is waiting for you, including what the other agents figured out.
This is roughly how humans already work on a team. You do not email each other raw chat logs. You file tickets, write docs, leave comments, and the writing is the substrate of the work. Whoever picks it up next reads what is there.
The shape I landed on has two parts:
- A structured record per piece of work. Problem statement, success criteria, tasks, assets, and the magic part: an accumulating reasoning trail written as the work gets done.
- MCP as the protocol. Any MCP-speaking client (Claude Code, Codex CLI, Gemini CLI, Cursor, Zed, or your own agent) can read and write the record with a single config line.
That is Workunit, basically. The reasoning trail is a series of typed "context atoms" (decisions, insights, questions, attempts, progress), and every model talks to the same stream.
A real week, not a marketing scenario
Here's how this actually plays out on a normal feature.
Open a fresh workunit for the notifications feature. Claude reads the problem statement, thinks about the schema, and before writing any code it saves a decision atom: "Per-workunit preferences table over JSONB blob, because we'll query by workunit often." That decision is now part of the workunit, instead of sitting in my head or in some markdown file I'll forget about.
I hand the same workunit to Codex for the UI. First thing Codex does is pull the workunit and read Monday's decision. It does not revisit the schema; it just builds the settings page against what Claude already set up. Midway through, it hits a templ quirk with HTMX form state, and instead of fixing it silently it saves an insight atom so nobody else has to rediscover the trick.
Gemini gets the review pass. It reads the workunit (both atoms plus the diff) and flags a subtle perf concern it can't fully verify from the CLI. Instead of saying "looks fine" or pretending to know, it logs a question atom, which sits there overnight waiting for me.
Over morning coffee I read Gemini's question, check the data, and realize it's a real concern. Back to Claude, which reads the whole thing (the Monday decision, Tuesday's insight, Gemini's question), tries a fix, hits an index issue, logs an attempt atom, and then saves a refined decision that supersedes Monday's. The old reasoning is preserved; the new direction is clear.
No copy-paste between CLIs, and no re-explaining myself. The reasoning that mattered will still be there in six months, when I have long forgotten why we made those choices in the first place.
Bring your AI agents and your team into one workspace
Workunit gives your agents structured context and your team a shared place to plan, track, and ship the work. Free to start, no credit card.
Dive deeper
Want to go from the idea to the actual workflow? These guides walk through it step by step.
Connect Claude, Codex, Gemini, and other clients to one workspace.
How workunits, tasks, assets, and atoms fit together.
The full guide library covers every part of Workunit, and the community discussions are open if you want to ask.