November 22, 2026•12 min

Why AI Remembers Wrong Things About You (and the Fix)

There is a particular kind of irritation that comes from an assistant that remembers you, just not correctly. It greets a new chat by assuming you still work at a job you left, still use a framework you abandoned, or still want answers in a format you asked it to stop using months ago. It is not forgetting you. It is remembering a version of you that is out of date, half-right, or never existed at all.

People search for this in a few different ways: AI keeps remembering wrong things, AI stuck on outdated info, why your AI remembers you wrong. The complaint is the same underneath. Some piece of context that the assistant treats as true is not true any more, and the assistant gives no sign of which piece it is.

This post explains where wrong memories come from across ChatGPT, Claude, and Gemini, why correcting them in chat so often fails, and how to audit and fix the stores that actually hold them. The short version: there is almost never one memory to fix. There are several places context can live, and the wrong fact is sitting in one of them.

Wrong Memory Is Usually Old Memory

The first thing to accept is that most wrong memories were right when they were written. You did use that framework. You did ask for bullet points. You were working on that project. The memory was accurate, then your situation moved, and the stored version did not move with it.

That distinction matters because it changes what you look for. If you assume the assistant invented something, you look for a bug. If you assume it saved something that used to be true, you look for the oldest entries in whatever it keeps about you, and you usually find the culprit quickly.

A smaller share of wrong memories are genuinely wrong from the start. These come from a few predictable places:

  • A hypothetical treated as a fact. You asked for help writing a cover letter "as if I were a nurse", and somewhere a note now says you are a nurse.
  • Someone else's details. You pasted a colleague's bio, a client's requirements, or a friend's situation, and the assistant attached them to you.
  • A misread compression. A long exchange got condensed into one line, and the line lost the qualifier that made it accurate. "Prefers Python for scripts" becomes "prefers Python".
  • A guess written down. The assistant inferred something you never said, and the inference got stored with the same weight as things you did say.

Stale and false need slightly different fixes, but the starting point is the same: find out where the memory lives.

The Places a Wrong Fact Can Live

When an assistant says something wrong about you, the fact came from one of a handful of places. Different products name them differently, and the exact controls move between releases, so treat this as a map of categories rather than a list of menu items.

1. A saved memory list. ChatGPT keeps a list of short facts about you that it can supply to new chats. Other assistants have offered similar features at different times and on different plans. This is the most common home for a stale fact because entries persist until you remove them.

2. Standing instructions. Custom instructions in ChatGPT, Project instructions in Claude, and the instructions inside a Gemini Gem are all text you wrote once and that gets re-supplied every time. If you described yourself in them a year ago, that description is still being sent.

3. Attached reference files. Documents in a Claude Project, files attached to a custom GPT or Gem, anything you uploaded as background. These are re-supplied too, and they never update themselves.

4. Conversation history the product can draw on. Some assistants can reference earlier chats, depending on your plan and settings. When that is switched on, a fact you stated in an old conversation can resurface even if it is not in any memory list.

5. The current conversation. Sometimes the wrong fact is simply earlier in the chat you are in, either something you said, something you pasted, or a mistake the assistant made and then kept building on.

6. Context you paste yourself. If you keep a personal brief or a summary you open chats with, that is a store too. It goes stale exactly as fast as any of the others.

The reason wrong memories feel so slippery is that these stores do not know about each other. Deleting an entry from the memory list does nothing to your custom instructions. Editing the Project instructions does nothing to the stale spec attached to the same Project. You can fix the wrong fact in one place and watch it come straight back from another.

Why Correcting It in Chat Rarely Sticks

The natural response is to tell the assistant it is wrong. "I do not work there any more." "I stopped using that framework." "Please stop doing bullet points."

Inside the current conversation, this usually works. The correction is now part of the context window, so the next reply takes it into account. The problem is what happens in the next conversation.

A correction made in chat lives in the chat. Whether it reaches any of the persistent stores depends on the product deciding to save it, and on it being saved in a way that replaces the old entry rather than sitting next to it. That is not something you control directly, and it frequently goes wrong in one of three ways:

  • Nothing is saved. The correction stays in that one conversation and disappears with it. Tomorrow, the old fact is back.
  • A second entry is saved. You now have "works at Company A" and "no longer works at Company A" in the same list. Which one wins in a given reply is not predictable.
  • The wrong store is updated. The memory list changes, but the stale fact was actually coming from your custom instructions or an attached file, so nothing visible improves.

For ChatGPT specifically, the duplicate problem and how to clean it up is covered in detail in ChatGPT Remembers Wrong Information. The general lesson applies everywhere: corrections only persist when you make them in the store that holds the fact.

A Ten-Minute Audit, Store by Store

The fix is unglamorous. Go through each store you use, read what is actually there, and correct it at the source. Doing it in a fixed order stops you from fixing the same fact twice and missing the one that matters.

Step 1: Catch the wrong fact in the act

Before opening any settings, find out what the assistant currently believes. Start a brand-new chat and ask it to list everything it knows or assumes about you, your work, and your preferences, and where each item came from if it can tell. You will not always get a reliable source, but you will get a list to check against.

A structured version of this test is in Test What Your AI Assistant Remembers. The point is to have the wrong facts written down before you start deleting things, so you can confirm afterwards that they are gone.

Step 2: Read the saved memory list from the oldest end

If your assistant has a memory list, open it and start with the oldest entries. Stale facts collect there. For each entry, ask one question: is this still true, and would I want it supplied to a chat I start today?

Delete the ones that fail. Edit the ones that are partly right, if the product lets you, rather than deleting and hoping the corrected version gets re-saved. If the list is long, the triage approach in ChatGPT Memory Is Full: What to Prune works as well for wrong entries as for full ones.

One caution: deleting an entry from the list is not always the end of it. If the same fact is sitting in an old conversation that the product can reference, it may come back. That situation is explained in Deleted ChatGPT Memory Still There.

Step 3: Re-read your standing instructions as a stranger would

Open your custom instructions, your Claude Project instructions, and any Gem or custom assistant you use regularly. Read them as if someone else wrote them. Instructions are the store people forget exists, precisely because they work silently.

Look for three things: descriptions of yourself that have changed, rules you no longer want followed, and references to projects that are finished. Rewrite rather than append. Instructions that grow by addition end up contradicting themselves, and a contradiction is just a wrong memory with extra steps.

Step 4: Check the attached files

This is where the most confident wrong answers come from, especially in Claude Projects and Gems. A specification you attached in week one is presented to every chat as current. If three decisions in it have since been reversed, the assistant will reason from the reversed versions without any hesitation, because nothing told it they changed.

For each attached file, check the date you last edited it against the last time anything important changed. If you cannot remember, assume it is stale. Either update it or remove it; a stale file is worse than no file. How Gems handle this specifically is in Do Gemini Gems Have Memory?, and a lightweight way to keep a Claude Project current is in Claude Project Decision Log.

Step 5: Decide what you want from chat history

If your assistant can reference past chats, the old conversations themselves are a source of stale facts. You have three reasonable options: leave it on and accept that old context may surface, switch it off and rely on the stores you curate, or delete the specific old chats that carry the wrong information.

There is no universally right answer. If you value convenience and your situation rarely changes, leaving it on is fine. If you have changed jobs, projects, or tools recently, switching it off for a while gives you a cleaner baseline. Check the current wording of the setting in your own account, because names and defaults change.

Step 6: Re-run the test

Start another brand-new chat and ask the same question as in step 1. Compare the answers. Anything still wrong tells you which store you have not reached yet. Usually it is instructions or an attached file, because those are the two people skip.

When the Conversation Itself Is the Problem

Not every wrong memory is persistent. Sometimes it lives only in the current chat, and the right move is to leave that chat rather than repair it.

The typical case: early in a long conversation, the assistant got something wrong, or you said something that was later superseded. You corrected it, but the original is still in the context window, and the assistant keeps sliding back toward it. Long conversations make this worse, because the more text there is, the more chances there are for the wrong version to win.

If you have corrected the same thing twice in one chat, stop correcting. Write a short handover with the current, correct facts, open a new chat, and paste it in as the first message. The new conversation starts without the wrong version anywhere in it. A template for that handover is in The Context Brief Template.

Why This Keeps Happening

Every assistant that remembers you faces the same basic problem: your life changes continuously, and memory is written at a few discrete moments. Between those moments, the stored version drifts.

Automatic memory makes the drift harder to see. When the assistant decides what to save, you do not see the moment a fact was written, so you do not know how old it is or what it was based on. When it decides what to retrieve, you do not see which stored facts influenced a given reply. The wrong answer shows up, but the path to it is hidden.

Explicit stores, like instructions and attached files, make the drift easier to see but easier to forget. You know exactly what is in them because you wrote it. You just wrote it a long time ago and have not looked since.

Neither approach removes the need to review. The difference is only whether you can.

A Store You Can Actually Read

The pattern that avoids most of this is to keep the context you care about in one place you can read, date, and edit, and to supply it deliberately instead of hoping the right fact gets retrieved.

That can be as simple as a document you maintain by hand. It is also what MindLock is built around. You save conversations worth keeping by pressing Ctrl+S (Cmd+S on Mac) in ChatGPT, Claude, Gemini, or Perplexity and importing the saved HTML, as described in Importing Conversations. MindLock distils those transcripts into a profile memory and topic memories, which are ordinary readable documents rather than a hidden list. See Memory Documents.

The part that matters for wrong memories is that those documents only change when you re-run distillation. That cuts both ways, and it is worth being clear about it. They do not update themselves, so they can go stale like any other store. But you can see exactly what is in them, you control when they change, and the same document can be pasted into ChatGPT, Claude, or Gemini, so you fix a wrong fact once instead of in three products.

On the free tier, distillation runs locally on your GPU through WebLLM and requires a WebGPU-compatible GPU; storage stays in your browser. Pro adds cloud distillation through Gemini and cloud sync for €5 a month. Details are on the pricing page.

A Maintenance Habit That Holds Up

Audits fix wrong memories once. A habit stops them coming back. The lightest version that works:

  1. After a real change, update the store immediately. New job, new project, new tool, abandoned approach. Edit the instructions, file, or memory document the same day, not later.
  2. Rewrite, do not append. Replace the old fact rather than adding a correction next to it. Two contradictory lines are worse than one stale one.
  3. Date your context. A line at the top of any brief or attached file saying when it was last reviewed tells you, and the assistant, how much to trust it.
  4. Re-run the test monthly. Ask a fresh chat what it believes about you. It takes two minutes and surfaces drift before it causes a bad answer.
  5. Leave chats that keep sliding back. If a correction will not hold inside one conversation, start a new one with a clean handover.

None of this is specific to one product, which is the point. Products will keep changing how memory works. The stores will keep drifting. The habit of reading what is stored and fixing it at the source is the only part that stays useful.

The Short Version

When an AI remembers you wrong, it is usually remembering an old version of you, and the fact lives in one specific store: a saved memory list, standing instructions, an attached file, referenced chat history, the current conversation, or a brief you paste yourself. Correcting it in chat rarely persists because the correction lands in the chat rather than the store.

Find the wrong fact with a fresh-chat test, then fix it at the source, store by store, starting with the ones people forget: instructions and attached files. Leave conversations that keep sliding back to the wrong version. And keep the context that matters in something you can read and edit, so the next correction takes one edit instead of a hunt. For the opposite problem, assistants that forget too much rather than remembering wrong, start with Why Your AI Keeps Forgetting You.