Using ChatGPT and Claude Together Without Losing Context

Most people who use AI seriously end up using more than one. Claude for the long reasoning, ChatGPT for the quick lookup, Gemini because it is already in the tab. Each one is better at something, so you keep all of them.

The cost shows up immediately. Every assistant starts from zero on everything the others know. You explain the project to Claude on Monday, explain it again to ChatGPT on Tuesday, and by Wednesday you have three assistants each holding a partial, slightly different picture of the same work. Nothing carries across, and there is no setting that makes it.

This post is about why that gap exists, why it is not going to close, and the workflow that makes running two or three assistants practical rather than exhausting.

Why Nothing Crosses Between Them

The isolation is not an oversight. It follows from how each product is built.

Memory is per-vendor and per-account. Whatever ChatGPT has stored about you lives in OpenAI's systems. Claude's Projects live in Anthropic's. Gemini's Gems live in Google's. There is no interchange format and no export path designed to feed one into another.

Each vendor's memory is a retention feature, not a portability feature. From the vendor's side, memory exists to make their product better over time. A memory layer that moved cleanly to a competitor would work directly against that. This is not a conspiracy — it is just the incentive, and it explains why the situation has not improved and will not.

The mechanisms are not even the same shape. ChatGPT's memory extracts discrete facts. Claude's Projects attach documents to a workspace. Gemini's Gems store a fixed instruction block. These are three different ideas about what "memory" means, so even a hypothetical export would not map cleanly. The differences are broken down in ChatGPT Memory vs Claude Projects vs Gemini Gems.

Context windows always start empty. Underneath the memory features, every new conversation begins with nothing in the window except what the product injects. That is true within a single vendor too. Crossing vendors just makes it obvious.

The practical consequence: any continuity across assistants has to come from you, in the form of something you carry between them. The only question is whether you carry it deliberately or by re-typing.

The Three Bad Workarounds

Before the workflow that holds up, here are the three that people try first, and where each one breaks.

Re-explaining. The default. You type the background again at the start of each chat with each assistant. It works, and the cost is invisible because it is spread across dozens of small moments. The failure mode is not the typing — it is drift. Each retelling is slightly different and slightly shorter, so after two weeks your three assistants are working from three different versions of your project, and the one you told most recently is the only one that is current.

Pasting the transcript. Copy the good conversation from Claude, paste it into ChatGPT. Better than nothing, but transcripts are mostly redundant — false starts, corrections, tangents, superseded code. You spend a large share of the new window on material that is no longer true, and you have handed the model the job of working out which parts still apply. It usually gets some of that wrong.

Picking one assistant and living with it. The clean solution, and the reason people abandon it is real: the models genuinely differ. Giving up the one that is better at your hardest task to avoid re-explaining is paying with the wrong currency.

What Actually Transfers Well

The thing that moves cleanly between assistants is not a transcript and not a memory export. It is a compact, current description of your situation — written once, edited as reality changes, and pasted in as the opening message wherever you are working.

A good one covers:

Who you are, in the way that matters for the work. Role, domain, technical environment, level of detail you want. This barely changes and it is the most repeated thing in every conversation you have ever started.

Current project state. What exists, what works, what is in progress. State, not history.

Decisions and their reasons. Especially the reasons. "We chose X over Y because Z" is what stops each assistant independently re-proposing Y.

Hard constraints. What must not change, what is out of scope, what the environment forbids.

Open questions. What is genuinely undecided, so nothing assumes a resolution.

What does not belong: full transcripts, resolved problems, and the story of how you arrived here. If it is not still true, it is costing window and inviting confusion.

This is deliberately boring. The insight is not the format — it is that the document lives with you rather than inside any one vendor, which is what makes it work in every tab.

The Workflow

The manual version of this is a text file you maintain by hand, and it genuinely works. The reason people stop doing it is maintenance: the file goes stale within a week, because updating it is a separate chore from the work that changed it.

MindLock automates the maintenance half. The loop:

Save the conversations that produced something. In ChatGPT, Claude, Gemini, or Perplexity, press Ctrl+S (Cmd+S on Mac) at the end of a session where you decided something or solved something. The browser writes an HTML file. No extension and no API key needed. There is also a Chrome extension adding a one-click "Save to Memory" button on those four sites — it is developer-load only, installed through chrome://extensions with Load unpacked, not from a store.

Import them into one place you control. MindLock parses saved HTML from all four platforms into a single archive, stored locally in IndexedDB on the free tier — nothing leaves your device. The point is that a Claude conversation and a ChatGPT conversation land in the same store, which is precisely what neither vendor offers. Walkthrough: Importing Conversations.

Distil them into memory documents. Distillation turns transcripts into a profile memory plus topic memories — compact documents holding decisions, constraints, and current state rather than dialogue. This is the step that produces the transferable artefact, and it is the step you would otherwise be doing by hand. It runs locally on your GPU via WebLLM, which needs a WebGPU-compatible GPU and defaults to Llama 3.2 3B, or in the cloud via Gemini on the Pro tier with 100 distillations per month. See Memory Documents and Free vs Pro.

Generate a context block and open with it. Select the memories relevant to what you are about to do, generate a formatted block, and paste it as the first message — in Claude, in ChatGPT, in whichever tab you are in. Details in Generating Context.

Find things across all of it. Semantic search with Ctrl+K covers conversations, memory documents, and contexts together, so "where did I work out the retry logic" does not require remembering which assistant you were using at the time.

The property that makes this work across vendors is unglamorous: the output is plain text. No integration, no API access, no cooperation from OpenAI or Anthropic or Google required. Text goes in any chat box.

What a Week Looks Like

Concretely, running two assistants with this workflow:

Monday. Long architecture session with Claude. It goes well and produces real decisions. Ctrl+S at the end.

Tuesday. You want a quick implementation answer and ChatGPT is faster for that. Import Monday's conversation, distil, generate a context block for the project, paste it as your opening message in ChatGPT. It knows the constraints Claude helped you set — because you carried them, not because the vendors talked.

Wednesday. Debugging in ChatGPT, which produces its own decisions. Ctrl+S.

Thursday. Back to Claude for the next hard problem. Re-distil so Wednesday's decisions are folded in, generate a block, paste. Claude now knows what ChatGPT worked out yesterday.

Friday. Something needs a document you half-remember from two weeks ago. Ctrl+K, semantic search over everything regardless of which assistant produced it.

Nothing here required either vendor to support anything. The context lives in one place, and both assistants read from it.

Honest Limitations

The same scepticism this post applies to vendor memory features applies to ours:

It is not automatic. Conversations are saved by you pressing Ctrl+S or clicking the extension button. Nothing captures chats in the background, and the memory documents update when you re-run distillation, not continuously.

There is a habit to maintain. Save the sessions that mattered, re-distil when the picture has moved, paste context at the start of chats that need it. Realistically fifteen minutes a week. Less than re-explaining, but not zero.

Local distillation has a hardware requirement. WebLLM needs a WebGPU-compatible GPU. Without one, you are on the Pro tier's cloud distillation or you cannot distil.

The extension is sideload-only. Manifest V3, loaded unpacked from chrome://extensions. Not on the Chrome Web Store.

Cloud sync is a paid feature. The free tier is local-first, which also means single-device. Firebase-backed sync across devices is on the Pro tier at five dollars a month — see pricing.

It does not make the assistants agree. Two models given identical context will still answer differently. That is usually why you are running both.

When One Assistant Is Enough

If all your AI use is short and self-contained — one-off questions, quick rewrites, lookups — none of this is worth setting up. The built-in memory of whichever product you prefer is fine, and re-explaining costs nothing when there is nothing to explain.

The workflow earns its keep when you have projects that run for weeks, you switch assistants because they are genuinely better at different things, and you have noticed yourself typing the same background paragraph for the fifth time. That is the point at which the maintenance cost is lower than the re-explanation cost.

Four Failure Modes Worth Watching For

Running the same context through several assistants introduces its own problems. All four are avoidable once you know the shape of them.

Updating one assistant and not the others. You correct something mid-conversation in ChatGPT — a constraint changed, a decision reversed. That correction lives in one chat with one vendor. Claude will happily keep working from the old version tomorrow. The rule that fixes this: if a correction matters beyond the current session, it belongs in the memory document, not only in the chat where you noticed it. Re-distil, or edit the document directly.

Letting the context block sprawl. Blocks grow. Every distillation adds, nothing prunes, and after a month you are pasting three pages where one would do. Long blocks are worse than short ones — they cost window and bury the important lines. Periodically read the block and delete what is no longer true. Deleting resolved items is not losing history; the transcripts are still in the archive if you ever need them.

Pasting everything into every chat. The block is meant to be selected per task, not dumped wholesale. A quick formatting question does not need your architecture decisions. Select the memories relevant to what you are about to do and leave the rest out.

Treating one assistant's answer as the shared record. If Claude works out a plan and you act on it, the plan is now project state. If it never leaves that conversation, the next assistant — and the next you, in three weeks — does not have it. Anything you acted on is worth saving.

The common thread is that the memory document is the record and the chats are working surfaces. Once that hierarchy is clear, the rest is mechanical.

A Note on Where the Combined Picture Lives

There is a privacy consequence to consolidating context that is worth stating plainly, because it cuts both ways.

Running three assistants without a shared layer means each vendor sees a fragment. Consolidating means one archive holds the complete picture of your work — which is more sensitive than any single fragment, precisely because it is complete.

That is the reason MindLock's free tier stores conversations locally in IndexedDB rather than on a server. The complete picture stays on your machine, and the fragments are the only thing any vendor gets. Cloud sync exists on the Pro tier for people who need the archive on more than one device, and it is opt-in rather than the default.

The practical implication for what you paste: a context block is a summary, so it can be deliberately thinner than the archive it came from. If a project has details you would rather not send to a vendor at all, leave them out of the memory documents you generate blocks from, or edit them out of the block before pasting. The document is text you control, which means you also control what leaves your machine.

Bottom Line

ChatGPT, Claude, and Gemini do not share memory, and the incentives point away from them ever doing so. Any continuity across them has to be carried by you.

Carrying a transcript is inefficient and carrying nothing means re-explaining until your assistants quietly disagree about your own project. What transfers well is a compact, current description of your situation — state, decisions with reasons, constraints, open questions — kept somewhere you own and pasted in wherever you are working.

Do that and running several assistants stops being a tax. Each one gets the same picture, updated as often as you distil, and switching costs a paste instead of an afternoon. Related reading: Give ChatGPT, Claude, and Gemini Persistent Memory Across Every Chat.