---
title: "Does ChatGPT remember your conversations? How memory works"
description: "Two different machines get called LLM memory: the context window and saved notes. Watch a chat overflow a 1,000-token window and see what each one keeps."
published: 2026-10-31
updated: 2026-10-31
canonical: https://protrailblazer.com/posts/how-chatgpt-memory-works/
tags: [llm, memory, context-window, chatgpt, retrieval, demo, machine-learning]
---

# Does ChatGPT remember your conversations? How memory works

**Answer:** Not by itself. Inside one chat, a language model only knows what still fits in its context window, and older turns fall out once it fills. Memory features are a second machine bolted on: they save selected facts or search past chats, then paste that text into each new request, where it costs window space and can go stale.

The demo below runs a scripted 18-turn chat through a context window of 1,000 tokens. Press **Next turn** a few times, or let it play, and watch the middle column: that is the entire request the model receives. Then turn **Memory** off and run it again.

*Interactive demo: [open the llm memory demo](https://protrailblazer.com/demos/llm-memory/)*

## What you're seeing

The **Conversation** column on the left is the thread as you see it in the app. It never loses anything. Each turn carries a badge: **in ctx** while the model can still read it, **in summary** once it has been compressed, and **dropped** if summarizing is off.

The **Active context** column in the middle is the request payload. It is built fresh for every reply in a fixed order: a 120-token system prompt, any memory cards, a summary of old turns, any retrieved snippets from prior chats, and then as many recent turns as still fit. The striped meter at the bottom shows how those five parts split the 1,000-token budget. Open **Payload** to read the request as plain text.

The right column holds the two kinds of product memory. **Saved memory** is a shelf of short facts, each with a token cost, a **Pin** button that sends it with every request, and a **Relevant** switch. **Prior chats** is a small archive the sim searches by topic before each reply. When an assistant turn depends on an earlier detail, it gets a verdict: **grounded** with the source it found, **detail lost**, or **biased** when a stale memory card won.

## Does ChatGPT remember previous conversations?

The model doesn't. A language model has no state between requests. It reads one block of text, produces a reply [one token at a time](https://protrailblazer.com/posts/why-chatgpt-types-one-word-at-a-time/), and forgets the block. Everything that looks like memory is the app deciding what text to put in front of the model next time.

Apps do that in two different ways, and the demo shows both. The first is the conversation itself: as long as your earlier turns fit in the context window, they are re-sent with every request, so the model can quote them back. The second is a memory feature: a note-taker that saves selected facts, or searches old chats, and pastes the results into a new request, even in a brand-new conversation.

As of October 2026, all three big assistants ship the second kind. OpenAI's [Memory FAQ](https://help.openai.com/en/articles/8590148-memory-faq) describes saved memories, which live in a store separate from your chat history, plus a setting that lets ChatGPT reference past chats. A Temporary Chat neither uses nor creates memories. Anthropic's help center describes Claude searching and referencing past chats when that setting is on, and the search shows up in the chat as a tool call. Google's Gemini app has a Personal context setting that covers past chats, and its Temporary Chats are left out of it. The details differ and change often, but the mechanism is the same one this demo draws: text goes into the request, or it doesn't count.

## Context window vs memory

These two machines behave nothing alike, which is why "memory" confuses people. The context window is automatic. You don't choose what goes in; every turn goes in until the budget runs out, and then the oldest turns go first. It is exact while it lasts: in the demo at a 4K limit, all 18 turns fit (2,340 tokens with memory on) and every follow-up question is answered from your own words.

Product memory is selective. In the trip planning preset, the sim saves your destination, your budget, and your diet, because those are marked as the kind of fact a note-taker keeps. It does not save your travel dates or the hut you wanted to visit. Those are noted in the chat only, and the event feed says so when it happens.

- **Context window:** short term, automatic, holds everything until it overflows, then loses the oldest turns first.
- **Summary of old turns:** a compressed stand-in for dropped turns. It keeps the gist (trip, dates, budget) and loses specifics (diet, hut name).
- **Saved memory:** long term, selective, survives a new chat, costs tokens every time it is injected, and can be out of date.
- **Retrieval from prior chats:** searches an archive by topic and injects the best matches. It is [retrieval-augmented generation](https://protrailblazer.com/posts/retrieval-augmented-generation/) pointed at your own history.

## Why does ChatGPT forget what I said?

Run the trip preset at the default 1K limit and the first turn leaves the window at turn 8. From there the summary grows by 14 tokens for every turn it absorbs. By turn 18, 13 of the 18 turns live only in a 212-token summary, and just 5 turns are still verbatim.

Turn 13 asks which hut you wanted. That detail was in turn 7, it was never saved to memory, and a summary does not keep it, so the turn 14 reply is marked **detail lost** whether memory is on or off. This is the plain version of forgetting: the words left the window, and nothing wrote them down.

Turn 15 is the interesting one. You ask whether a $400 add-on fits your budget. With memory on, the request carries two budget cards: a stale "$3,500 (saved last year)" and the "$1,800 total" saved at turn 3. Your actual message from turn 3 has already scrolled out. The sim's rule is simple: when a stale card is in the request and the fresh value is not in the recent turns, the reply follows the stale card. So it answers "Easily. Your saved $3,500 budget covers it twice." Turn memory off and the same question is **grounded** from the summary: "$400 fits inside your $1,800 budget."

Real models are less predictable than that rule, and that is the problem. A request that contains two conflicting facts gives the model a choice it should not have to make. Raise the limit to 4K and the conflict disappears, because your own turn 3 is still in the window and the sim lets recent words win. The same kind of failure shows up even without memory when a key fact sits in the middle of a very long window, which is the subject of the [lost in the middle](https://protrailblazer.com/posts/lost-in-the-middle/) post.

## How it actually works

The sim rebuilds the request from scratch before every assistant reply. The order matters, because each part spends budget before the next one gets any:

1. Start with the system prompt (120 tokens).
2. Add memory cards: pinned cards always, other cards only when their tags match the latest user message, and none at all if a card is marked irrelevant or memory is off.
3. Add up to two prior-chat snippets whose tags overlap the latest user message.
4. Fill the rest with recent turns, newest first, until the next one would not fit. The newest turn always rides along.
5. If any turns were left out, add a summary sized at 30 tokens plus 14 per left-out turn, capped at 260. The summary takes budget too, so the sim repeats steps 4 and 5 until the numbers settle.

After the request is built, each fact the reply needs is looked up in that request only: first in the verbatim turns, then in fresh memory cards, then in the summary, then in retrieved snippets. If it isn't in any of them, the reply is marked **detail lost**. Nothing reads the script to cheat. Here is the request behind turn 18 with memory on, exactly as the **Payload** panel prints it:

```
[SYSTEM 120t] You are a concise, helpful assistant. Honor saved preferences when they appear in this request.
[MEMORY 18t] Name: Ryan, prefers metric units (pinned)
[MEMORY 18t] Budget: $1,800 total
[MEMORY 14t] Diet: vegetarian
[SUMMARY 212t] 13 older turns compressed. Kept: Trip: Dolomites, June; Dates: June 12 to 19; Budget: $1,800 total
[T14 ASSISTANT 100t] That detail is gone from my context. Which hut was it?
[T15 USER 140t] Can I afford the $400 guided ferrata add-on?
[T16 ASSISTANT 110t] Easily. Your saved $3,500 budget covers it twice.
[T17 USER 130t] Summarize the plan with my dates and diet.
[T18 ASSISTANT 120t] June 12 to 19, vegetarian meal stops, Dolomites route.
TOTAL 982 / 1,000 tokens
```

Turn 18 is grounded: the dates come from the summary and the diet comes from a memory card. With memory off, the same reply is marked **detail lost**, because the summary dropped the diet and nothing else kept it. That is the real case for memory: it rescues the small facts a summary throws away. The cost shows up on the meter. With memory on, the three cards take 50 tokens that would otherwise hold recent turns, and the bad budget card shows what happens when one of them is wrong.

For the longer story of how the window itself fills and slides, the [context window explainer](https://protrailblazer.com/posts/context-window-explained/) runs a 2K and a 32K window over the same document side by side.

> **info:** Token counts are illustrative and the conversations are scripted. Which facts are worth saving is decided by a flag on each fact, not by a model, and retrieval matches topic tags instead of comparing embeddings. Replies come from fixed text chosen by whether the needed facts are in the request. The mechanics (budget order, summarizing, selective saving, topic-matched injection, stale cards) are the point, not any one product's internals.

## Frequently asked questions

### Does ChatGPT remember previous conversations?

Only through its memory settings. As of October 2026, OpenAI's help center describes two: saved memories, which are facts written to a separate store, and chat history referencing, which lets ChatGPT draw on past chats. Both work by adding text to the new request. With them off, or in a Temporary Chat, a new conversation starts from an empty window.

### What is the difference between the context window and memory?

The context window is the fixed amount of text the model reads on each request, and it fills up automatically as you chat. Memory is a separate feature that decides which facts to save and when to paste them back in. The window is short term and holds everything until it overflows. Memory is long term and holds only what it chose to keep.

### Why does ChatGPT forget what I said earlier in the same chat?

Because the chat outgrew the context window. The oldest turns get dropped or summarized to make room, and a summary keeps the general topic while losing exact details. Restating the detail, or starting a new chat that opens with a short summary of what matters, puts it back in the window.

### Does memory make the model smarter?

No. Memory never changes the model's weights. It changes the text in the request, which can help when the saved fact is right and relevant, and hurt when it is stale or off topic.

### Can I stop ChatGPT from remembering things?

Yes. As of October 2026 you can turn off saved memories and chat history referencing in settings, delete individual memories, or use a Temporary Chat, which OpenAI says does not use or create memories. Check the current settings page, because these controls change often.

## Key takeaways

- A model has no memory between requests. Every reply is computed from one request payload, and anything outside that payload does not exist for that reply.
- The context window is automatic and lossy at the edges: once a chat outgrows it, the oldest turns are dropped or squeezed into a summary that keeps the gist and loses specifics like a hut name or a firmware build.
- Product memory is a note-taker, not a bigger brain. It writes a few facts down and pastes them back into later requests, so every note it injects spends tokens that recent turns could have used.
- A saved note can be wrong in a way the chat is not. In the demo, a year-old $3,500 budget card outranks the $1,800 you just typed once your own words have scrolled out of the window.
- When an assistant forgets something, the fix is usually to restate it, start a fresh chat with a short brief, or correct the saved memory, not to repeat the whole conversation.