Your AI forgets when you switch tools because AI memory is stored per vendor and per account, with no bridge between them: what you teach ChatGPT lives inside your OpenAI account, what you teach Claude lives inside your Anthropic account, and neither can read the other.
That is the whole mechanism. Nothing is broken, no setting is switched off, and no amount of prompting either tool will fix it. It also runs in either direction: going from Claude back to ChatGPT loses just as much, for exactly the same reason. Below is what is actually happening at each of the three layers where context lives, why it feels like you lost everything rather than some of it, why coding agents are worse at this than chat apps, which direction each vendor has actually built a fix for, and an honest run at the question everyone ends up asking: is there a tool for this?
Current as of September 2026.
Key takeaways
- AI memory is per vendor and per account. There is no setting that makes ChatGPT and Claude share memory, because there is no shared store to point them at.
- Three separate things carry context, and switching tools destroys all three at once: the context window, the vendor's memory store, and per-project instruction files.
- The problem is symmetrical, the fixes are not. Claude ships a one-time memory import from ChatGPT. ChatGPT ships no import of Claude's memory, only a Codex-side import of a Claude Code setup. Both are migrations, not syncs.
- Coding agents lose more than chat apps, because their context lives in project files that do not travel between tools.
- The real options are three: per-vendor built-in memory, a memory MCP server, or a local memory layer. Each has a different failure mode, and one of them is free to test in ten minutes.
- Every fix that stores context inside one vendor recreates the problem the first time you switch.
- The durable fix is a portable one: a single memory of you that lives with you rather than inside a vendor, and that whichever tool you are working in can read on demand.
---
Why does ChatGPT forget what we discussed when I switch to Claude?
Because the discussion never left ChatGPT.
When you talk to ChatGPT, two things retain what you said. The conversation itself sits in the model's context window for the length of that chat. And separately, ChatGPT's memory feature writes durable facts about you into your OpenAI account: saved memories it can reuse, plus a broader reference to your past chats. Both of those are account-scoped. They are rows in OpenAI's system, tied to your login, reachable only through OpenAI's products.
Open Claude and you are a different user in a different company's system. Claude has its own memory store in your Anthropic account, and it is empty of anything you told ChatGPT. There is no federation layer, no shared identity, and no export format the two agree on. Anthropic ships an import path now, which we come back to below, but the default state is two sealed boxes.
The reason it feels like a bug is that both products market the same promise. Both say they remember you. Both do, inside their own walls. We compare the two systems feature by feature in ChatGPT memory vs Claude memory, and the short version is that they are built the same way and share the same two limits: siloed to their platform, and stale unless someone maintains them.
Why does my AI assistant forget everything when I switch from ChatGPT to Claude?
The word doing the work in that question is "everything." It really is everything, and that is because three different layers hold your context and switching vendors clears all three in one move.
| Layer | What it holds | How long it lasts | Does it survive a tool switch? |
|---|---|---|---|
| Context window | The current conversation, pasted text, attached files | This chat only | No. It ends with the chat, even inside the same tool |
| Vendor memory store | Saved facts, preferences, references to past chats | Across chats, inside one account | No. It is account-scoped to that vendor |
| Project instruction files | Standing rules, such as custom instructions, CLAUDE.md, AGENTS.md | Until you edit them | Only if you copy the file yourself |
Notice that only the third row is something you hold. The first two are the vendor's. So when people say the AI "forgot everything," what happened is that they lost the one layer that was theirs by never having written it down, and the other two were never portable in the first place.
This also explains a smaller mystery: why continuity sometimes survives a switch and sometimes does not. If your context was mostly standing rules, and you kept those rules in a file or a custom-instructions box, you can rebuild in a minute. If your context was accumulated across two hundred conversations that you never summarized, it is gone, and no import will fully recover it.
My AI agents keep forgetting previous conversations when I switch between Claude and ChatGPT
Agents are worse at this than chat apps, and for a reason worth knowing.
A coding agent keeps its standing context in files on your disk rather than in a cloud memory store. Claude Code reads a CLAUDE.md in your project. Codex, which is the surface most people now reach through the ChatGPT desktop app, reads an AGENTS.md in ~/.codex/. Those are two different files, in two different formats, read by two different tools, and neither file reads the other. Codex will now convert a Claude Code setup for you once, on import, which is a copy rather than a link, and nothing does that job in reverse. Maintain both by hand and they drift within a week. Maintain one and the other agent works from a stale brief.
Then there is the per-run problem. Agent sessions are usually short-lived: a task starts, it works, it exits. Whatever it figured out during that run, the fact that a migration is already applied, the reason a test is skipped, the decision you made about a library, lives in the transcript and nowhere else. Start a new session in the other tool and you are re-explaining the same three things you explained yesterday.
So "my agents keep forgetting" is really two problems stacked, and neither one cares which tool you started in. Cross-tool: your instruction files do not travel, in either direction. Cross-session: nothing durable is written at the end of a run. A shared memory that both agents read solves both at once, which is why the Claude memory MCP route matters more for agents than for chat.
Yes, Claude can import from ChatGPT once. That is not the same as fixing it.
Guides written before spring 2026 still tell you there is no import path between the two. That is now out of date. Anthropic ships a native memory import at claude.com/import-memory: Claude gives you an extraction prompt, you run it in ChatGPT, and you paste the result into Claude's memory settings. It is available on the free plan, it takes about a minute, and it genuinely works.
It is also a one-time copy-paste, not a connection. The two accounts are not linked afterwards, so the moment either side learns something new, the two memories start diverging again. Anthropic itself calls the feature experimental and says Claude may not always successfully incorporate imported memories. Full detail on what it moves and what it silently drops is in Claude memory transfer.
Use it. Just do not expect it to answer the question you actually asked, which is how to stop resetting every time you switch. And if you are heading the other way, or living in both tools at once, read the next section first: the import does not exist in that direction.
Why does Claude forget when I switch back to ChatGPT?
Same reason, opposite direction. Memory is per vendor and per account, so it breaks identically whichever way you walk: what Claude learned about you sits in your Anthropic account, ChatGPT reads your OpenAI account, and neither holds a key to the other. Nothing about the mechanism cares which tool you left.
The fixes do care, and the way they are lopsided is stranger than "one direction is covered and the other is not."
For chat memory, only one direction has a native path. Anthropic ships the import from ChatGPT into Claude. OpenAI ships no counterpart: there is nothing that pulls Claude's memory into ChatGPT, so heading that way you re-brief by hand.
For coding agents, the direction flips. The ChatGPT desktop app and Codex CLI now import from Claude Code, Claude Cowork, and Cursor: instruction files become AGENTS.md, settings.json becomes config.toml, and MCP server config, hooks, slash commands, subagents, skills, project folders, Claude Code project memories, and your chats from the last 30 days come across. You can even leave automatic updates on so the copy keeps refreshing. Notice where those project memories land, though. OpenAI's own documentation says local Codex clients keep a separate memory store from ChatGPT's, so an import that fills Codex teaches ChatGPT itself nothing. And nothing imports a Codex setup into Claude Code.
| ChatGPT to Claude | Claude to ChatGPT | |
|---|---|---|
| Chat memory | One-time import at claude.com/import-memory | No native path. Copy it across yourself |
| Coding agent setup | No native path. Rewrite the files yourself | One-time import from Claude Code, Cowork or Cursor |
Each vendor built the bridge for the layer it wants to win on, and neither built the one its rival already has. That is the state as of September 2026, and either half of it can change without notice.
Which leaves the people this hurts most: the ones running both tools at once, rather than migrating between them. An import assumes a move that ends. If ChatGPT is where you draft and Claude is where you think, you are not switching, you are commuting, and you brief two stores forever. Every correction you make in one is a correction the other never hears, so the two versions of you drift apart until each is confidently wrong about something different. No one-time import fixes that, in either direction, because there is no single moment to run it at.
Is there a tool I can use for this?
Yes, and there are exactly three real categories. Here they are with the honest version of each.
1. Built-in per-vendor memory. ChatGPT memory and Claude memory, plus whichever one-time import matches your direction. Free, zero setup, and the best continuity available inside a single tool. It does not cross vendors either way, and you maintain it by correcting the assistant when it is wrong.
2. A memory MCP server. The Model Context Protocol is an open standard that Claude Desktop, Claude Code, and Codex all speak, and there are memory servers built for it, including a reference implementation in the MCP project and several third-party ones. Any MCP-speaking client can read the same store, which genuinely solves the cross-tool problem. The catch is that most are write-on-command: the AI saves what you explicitly tell it to save, so the store is only as complete as your discipline.
3. A local memory layer. A desktop app that holds one memory of you on your own machine and serves it over MCP to the AI tools you connect. Portability is the whole point: the memory lives with you rather than inside a vendor account, so whichever assistant you open reads the same brain, and switching stops costing you anything. Locul is the one we make. The better tools in this category also build the memory out of work you already produce rather than asking you to curate it, which is the part that decides whether it stays current. The trade is real: it is software you install, and it only knows what it can see on your machine.
Which to pick:
| Crosses ChatGPT and Claude | Stays current on its own | Where your data lives | Setup cost | |
|---|---|---|---|---|
| Built-in vendor memory | No | Partly, from new chats | The vendor's cloud | None |
| Memory MCP server | Yes, for MCP clients | No, you save facts manually | Wherever you host it | Config file editing |
| Local memory layer | Yes, for MCP clients | Yes, if it watches your real work | Your machine | An install |
If you only use one assistant, stop here and turn on its built-in memory. That is the correct answer and it is free.
If you use two or more, the cross-vendor row is the one that decides it, and the honest ranking is: try the built-in import first because it costs a minute, add a memory MCP server if you are comfortable editing a config file and do not mind curating by hand, and go to a local memory layer when the curating is the part you keep failing to do.
How to write a portable context brief, step by step
Before you install anything, do this. It is free, it takes fifteen minutes, and it removes most of the pain immediately. The goal is one short document you own, that you can hand to any assistant in any tool.
- Create a plain markdown file called
context.mdwherever you already keep notes. Not inside ChatGPT, not inside Claude. Somewhere you control. - Write five headed blocks and nothing else: who you are, what you are working on, how you want answers written, your standing rules, and your current facts.
- Keep the whole thing under about 500 words. This is a brief, not a wiki. Custom-instruction boxes are small, and a long document gets skimmed by the model rather than followed.
- Date every fact that can change. Write "price: 49 dollars per month, as of September 2026" rather than "price: 49 dollars per month." A dated fact tells the model when to distrust itself.
- Deploy the same file everywhere: paste it into ChatGPT's custom instructions, into Claude's project instructions, and save it as
CLAUDE.mdfor Claude Code andAGENTS.mdfor Codex. - When a fact changes, change it in
context.mdfirst, then redeploy. One source, several copies. The moment you start editing the copies directly, they drift and you are back where you started.
The reason this works is that it converts your context from something a vendor holds into something you hold. The reason it eventually stops working is that last step: it is a manual sync, and manual syncs decay.
A context brief you can copy
# Who I am
Solo founder. I build and ship small software products. I write my own copy.
# What I am working on
Two active products. One launched, one in beta. Current focus is retention.
# How I want answers
Direct. Lead with the recommendation. No preamble, no restating my question.
Short paragraphs. Give me the trade-off, not a survey of options.
# Standing rules
Never invent statistics. If you do not know, say so.
Use plain English. No corporate filler.
When you suggest code, show the diff, not the whole file.
# Current facts (dated)
Pricing: 49 dollars per month (as of September 2026)
Stack: Python backend, React frontend (as of September 2026)
Not doing: enterprise sales, mobile apps (as of September 2026)Swap in your own lines. The dated block at the bottom is the part that matters most, because it is the part that goes wrong quietly.
The problem none of these fixes solve
Even if you get context across tools, you have a second problem that looks identical from the outside.
Every memory system, native or otherwise, only knows what it was told on the day it was told. You raise your price, you kill a feature, you change your mind about a framework. The memory keeps repeating the old fact with total confidence until someone goes and corrects it, in every tool, one at a time. That is the same experience as forgetting, and it is arguably worse, because a blank slate asks you a question while a stale memory just gives you a wrong answer.
A blank slate asks you a question. A stale memory just gives you a wrong answer.
So the real target is not portability alone. It is portability plus currency: one memory that every tool can read, and that updates itself when the underlying facts change. We work through what that looks like in practice in how to give your AI a memory that lasts.
Frequently asked questions
Can ChatGPT and Claude share memory?
No, not directly. Each stores memory inside its own account with no bridge to the other, and there is no setting that connects them. Claude offers a one-time import that copies a summary of your ChatGPT context across, but after that the two stores are independent again. The only way both tools work from the same memory is to keep that memory outside both of them and let each connect to it.
Why does ChatGPT forget what we discussed when I switch to Claude?
Because the conversation and the memory both live in your OpenAI account. Claude is a different vendor reading a different store, so it has no access to any of it. Neither product is malfunctioning; there simply is no shared layer between two competing companies' accounts. The same is true in reverse, for the same reason.
Can I import my Claude memory into ChatGPT?
Not as chat memory. Anthropic ships an import into Claude, but OpenAI ships nothing that pulls another vendor's chat memory into ChatGPT, so that direction is a manual copy. The one reverse path that does exist is on the coding side: the ChatGPT desktop app and Codex CLI can import a Claude Code, Claude Cowork, or Cursor setup, and OpenAI's docs note that local Codex clients keep their own memory store separate from ChatGPT's. Checked September 2026.
Does Claude have memory like ChatGPT?
Yes, in several forms: cross-chat memory in the consumer apps, project instructions, and CLAUDE.md files in Claude Code. The experience overlaps closely with ChatGPT memory, and it is scoped entirely to Claude. There is a fuller breakdown in does Claude have memory like ChatGPT.
How do I stop re-explaining my context to every AI tool?
Write one short context brief you own, keep it under 500 words, date the facts that change, and deploy it into every tool's instruction slot. That removes most of the repetition today. To remove the manual redeployment as well, you need a shared memory store that each tool reads over MCP rather than a file you copy around.
Why do my coding agents forget more than the chat apps?
Because their standing context lives in per-project files rather than a cloud memory store, and those files are tool-specific: Claude Code reads CLAUDE.md, Codex reads AGENTS.md. Neither travels to the other. On top of that, agent sessions are short-lived, so anything learned during a run is lost when the run ends unless something durable writes it down.
Is there a tool that gives ChatGPT and Claude the same memory?
Yes, in the form of a shared memory store both tools read over the Model Context Protocol. That is either a memory MCP server you point each client at, or a local memory app that does the connecting for you. Both work because MCP is a standard the clients already speak, so neither vendor has to cooperate with the other.
The bottom line
Start with the free moves: turn on both built-in memories, run whichever one-time import matches the direction you are heading, and write the context brief. That covers most of the pain in an afternoon.
If what keeps failing is the upkeep, the fix is a memory that does not need you. Locul is a local-first desktop app that builds a second brain out of what you already produce, your markdown notes, PDFs, dictation, Notion, and your LinkedIn profile, then serves it over MCP to the AI tools you already use: Claude Code, Claude Desktop, ChatGPT / Codex, Cursor, and OpenClaw. The brain belongs to you rather than to whichever vendor you happened to open, which is what makes switching free. When a fact about you changes, the old memory is marked superseded and the new one goes active, so every connected tool works from the current truth instead of last quarter's. Everything stays on your machine by default, and it starts free with 500 memories. Download it and connect your tools.
