Does AI Remember Your Conversations?

Three different questions hide inside that one, and they have three different answers. The model itself does not remember you, because its parameters are fixed when training ends and nothing you type changes them. The product does remember inside a single conversation, up to a limit called the context window, after which the beginning starts falling away. Across separate conversations it remembers only if it has a memory feature and that feature is switched on.

The model does not remember you

The thing you talk to is a product. The thing doing the work is a model, and keeping those apart resolves most of the confusion here. You are talking to a chatbot; the model is the part underneath it doing the work.

A large language model is a very large set of numbers, fixed at the end of training. Typing to a chatbot does not adjust them. MIT News, reporting in November 2025 on research presented at the NeurIPS conference, put it directly: "Once a fully trained LLM has been deployed, its 'brain' is static and can't permanently adapt itself to new knowledge." The same report describes what happens to what you tell it in the moment. The model uses the information well, but "the knowledge disappears before the next conversation." It is the same property that gives a model a knowledge cutoff: what it absorbed during training is what it has.

Retraining a model for every user would be slow and expensive, but the harder obstacle is technical. The MIT News report names it: as a model repeatedly adapts to new information, it runs into "catastrophic forgetting," where "performance on earlier tasks slowly declines." A system that absorbed every conversation as it happened would get worse at things it was already good at. There is also the plain problem that one person's chats would then alter a model everyone else uses, mistakes included. A separate, editable memory store avoids all of it.

So when an assistant appears to know something about you, one of two things is happening. Either that information is in front of it right now, in the text of the current conversation, or the product pulled it out of a store and inserted it before the model saw your message. Neither is learning. Both are the product supplying context.

Inside one conversation, until the room runs out

Anthropic's developer documentation defines the context window as "all the text a language model can reference when generating a response, including the response itself," and calls it "a 'working memory' for the model," explicitly separate from the data the model was trained on. Every time you send a message, the whole conversation so far is handed over again. The model is not recalling the earlier turns. It is rereading them.

That is why continuity feels solid and then stops feeling solid. The conversation grows with each exchange, measured in tokens rather than words, and eventually it stops fitting. Products handle the overflow differently: some refuse to continue, some summarize the earlier part, some drop the oldest turns without saying so. The symptom is the same either way. An instruction you gave at the top quietly stops being followed. How the limit is counted, and why it exists at all, belongs to tokens and model limits.

Fitting is not the only issue. Nelson Liu of Stanford and colleagues tested how well models actually use long inputs and published the result in Transactions of the Association for Computational Linguistics in 2024. Performance, they found, "can degrade significantly when changing the position of relevant information": models did best when what they needed sat near the start or the end of the input, and noticeably worse when it sat in the middle. That held even for models built for long contexts. A long conversation can therefore still contain your instruction and behave as though it does not, an effect sometimes called context rot. Writing for that limit, rather than against it, is most of how to work with a limited context window.

Across conversations, only if memory is on

Memory features sit around the model rather than inside it. The product decides something is worth keeping, writes it to a store attached to your account, and inserts the relevant parts into later conversations. It is note-taking, done by software, on your behalf.

That is not the same thing as your chat history, which is the stored record of the conversations themselves. History is the full record, kept so you can scroll back. Memory is a short set of notes the product wrote about you and reuses. Clearing one does not clear the other, which is why an assistant can still know something after you deleted the conversation it came from.

One consequence surprises people: the feature makes editorial choices. OpenAI's help documentation states that "Memory does not retain every detail from every conversation," and that information derived from chat history "can change as ChatGPT updates what is most useful to remember." What gets kept is a judgment the product makes, not a transcript.

Whether memory is on depends on the product, the plan and sometimes the region. Checked in September 2026:

These features get renamed and redesigned often, which is why the date matters more than the detail.

Memory and training are different settings

Memory controls what the product tells the model about you; training controls whether your conversations are used to build future models, and switching one off does not switch off the other. What actually happens to your text once you send it, including training defaults, retention and who can read it, is the subject of is it safe to put your information into AI tools.

Deleting a chat is not deleting the memory

Two actions that feel like one are not. OpenAI's documentation says that "Deleting a chat alone does not necessarily delete a separate saved memory created from that chat." Turning saved memory off is a different control again, and switching it off does not clear entries the product has already stored. Removing a fact means two deletions: the memory entry, and the chat that produced it.

What happens to the deleted conversation itself is a different question, and retention, deletion and legal holds answers it. Memory is the part you can see and edit. Retention is the part you cannot.

What to do about it

Open the memory settings on the tool you use most and read what it has stored. People tend to be surprised in both directions, by how much is there or by how little of it is right.

Use temporary or incognito mode for anything you would rather not have persisted, including work you are only testing. It is the one control that behaves much the same across products.

In a long session, repeat the constraint that matters instead of pointing back at it. Saying "as I said earlier" retrieves nothing; restating the instruction puts it back in front of the model.

Start a new conversation when the answers begin drifting. A fresh context usually fixes what more instructions will not.

Do not treat an assistant as a record. If something matters, keep it somewhere you control.

Memory makes a wrong detail permanent

This is the part worth carrying away, because it inverts the usual complaint about AI. A hallucination inside one conversation is local. You catch it, you correct it, and it is gone when the chat ends. A wrong detail written into memory behaves differently: the product inserts it into later conversations as settled background, the assistant repeats it with the same confidence it gives everything else, and nothing in the interface marks it as something inferred rather than something you said.

Stale entries do the same work more quietly. A job you have left, a project that ended, a preference you have since changed your mind about. Memory carries all of it forward at full strength, because it has no way of knowing which facts expire.

That makes the maintenance small and worth doing. Open the stored entries occasionally and read them as what they are, a list of claims about you, then delete the ones that are wrong and the ones that have gone out of date.