Why Does ChatGPT Forget What I Told It?

TL;DR: ChatGPT forgets because a chat only carries what fits inside its context window, and anything outside it must be stored elsewhere or it is gone. Five separate failures produce the same symptom: a full window, memory off or empty, project instructions overriding Custom Instructions, a genuinely blank new chat, and summarization. Each has a different fix.

Why does ChatGPT forget what I told it?

Because ChatGPT does not have one memory. It has a working memory that is capped by size, a long-term memory that is optional and lossy, and a settings layer that can be silently overridden. Something you said lands in exactly one of those, and each fails differently.

The reason this feels maddening is that all five failures look identical from the chair. The model drops a constraint. It re-asks a question you already answered. It reverts to a default tone you told it to abandon four days ago. Same symptom, five mechanisms, five fixes, and the fixes are not interchangeable. Starting a new chat solves one of them and actively causes another.

Here is the triage. It takes about thirty seconds and it saves you from applying the wrong remedy.

One diagnostic beats all of them, and almost nobody uses it. Under any ChatGPT reply there is a book icon. Tap it and you see which sources shaped that response: custom instructions, past chats, files, memories. OpenAI notes in its Memory FAQ that sources "may not show every factor or source that shaped a response", so treat it as strong evidence rather than a full audit log. It still answers the only question that matters, which is whether your instruction was in the room at all.

Cause 1: the conversation outgrew the context window

The context window is the total budget for a single request. OpenAI's API documentation defines it as "the maximum number of tokens that can be used in a single request", and notes that the number "includes input, output, and reasoning tokens". Everything competes for the same space: your new message, the entire transcript so far, and the reply being generated.

That last part is the piece people miss. Each turn is not an increment. The whole conversation is re-sent every single time. OpenAI's conversation state guide is blunt about it: "each text generation request is independent and stateless". Turn forty ships turns one through thirty-nine along with it. Once that payload no longer fits, the oldest material stops making the trip.

OpenAI publishes per-plan windows on the ChatGPT pricing page. Checked August 26, 2026:

The same page carries a footnote that explains the symptom better than most articles on the subject: the window is shared, and "the portion available for user input is smaller than the total window, as space is also used for system instructions (including tools and personality), memories (if enabled), and internal processing".

Read the parenthetical. Memory itself consumes window. So does personality. So does every tool definition currently loaded. Your usable share is smaller than the headline number and it moves depending on what is switched on.

Tokens are not words, and dense material burns them faster. Paste three PDFs into a thread and you can cross a 54K window inside a handful of turns without writing anything long yourself.

The fix: start a new chat and bring a brief, not a transcript. Two or three sentences of goal, the constraints that actually bind, and the last good output. Copying the old conversation across defeats the entire point, because you are re-importing the ballast that caused the problem.

If your symptom is answers stopping rather than the model forgetting, that is a related but separate diagnosis. We split those causes apart in why ChatGPT cuts off mid-answer.

Cause 2: memory is off, full, or never saved what you assumed

Memory is the layer that carries facts between chats, and it is much less deterministic than people think. It rebuilt substantially in 2026. OpenAI's June 4, 2026 announcement describes "dreaming", a background process that synthesizes your memory state from many conversations instead of waiting for you to say "remember this". OpenAI's own framing of the old system is unflattering: saved memories "relied on strong cues", and using it "could feel like talking to someone who took a few notes, but still forgot everything that wasn't written down".

The new system writes more and asks less. It also introduces a new failure mode: you cannot fully see what it holds. The Memory FAQ says the memory summary "will not include everything that ChatGPT remembers based on your chats", and then gives the workaround directly: "If you want to know if ChatGPT has remembered something, just ask in chat."

Four ways this breaks, in rough order of frequency:

1. Memory is off. Settings, Personalization, Memory. Nothing was ever going to persist.
2. You were in a Temporary Chat. OpenAI's Temporary Chat FAQ states that ChatGPT "won't access or create memories for personalization" there. Nothing written, nothing read.
3. Memory is full. Users on OpenAI's own developer forum report the message "ChatGPT memory is full. You can forget existing memories to make space" on the legacy saved-memories system. OpenAI does not publish a numeric capacity for memory on any plan. What it publishes is a grade: Limited on Free, Expanded on Plus and Pro.
4. It saved something, just not the thing you meant. Synthesis is lossy by design. It kept "user is planning a rebrand" and dropped the specific hex codes.

The fix depends on which of the four it was, but there is one rule that covers all of them. Memory is for context. Custom Instructions are for rules. OpenAI draws the same line in the Memory FAQ: "For explicit information or instructions, you can add it to your Custom Instructions. For information shared via conversations, ChatGPT can remember relevant details for you."

If a fact must apply every single time, do not hope memory catches it. Put it in Custom Instructions, which OpenAI documents as available on all plans and "applied immediately to all chats".

Cause 3: your Custom Instructions do not apply inside that Project

This one has the highest confusion-to-explanation ratio of the five, because the setting looks global and is not.

OpenAI's Projects help article states it plainly: project instructions "only apply inside the respective project and will override your global custom instructions". Checked August 26, 2026. So the rules you spent an afternoon tuning in Personalization can be overridden by three lines you typed into a project six weeks ago and forgot about.

On Enterprise and Edu workspaces it goes further. The same article's context table marks Custom Instructions as "Not available (only project instructions)" for chats inside projects, on both default and project-only memory settings. Not overridden. Not present.

Shared projects tighten it again. OpenAI states that shared projects are automatically set to project-only memory, and that they "do not have access to an individual member's context, custom instructions, or memories outside the project". If a colleague shared a project with you and it suddenly behaves like a stranger, that is the documented behavior, not a bug.

Project-only memory has its own list of consequences, straight from the same article:

• Previously saved memories are not referenced in project chats.
• Chats can reference other conversations within the same project.
• Chats cannot reference conversations outside the project, including general ChatGPT chats or another project.
• Chats outside the project cannot reference conversations from the project.

Two more details worth knowing. Changing a project's memory setting "may take a few hours to take effect", so testing it immediately after flipping the toggle tells you nothing. And when you drag an existing chat into a project, "the chat inherits the project's instructions and file context", which means a working chat can change behavior purely from being filed.

The fix: stop treating Custom Instructions as global. Keep a canonical block of standing rules somewhere outside ChatGPT, and paste it into every project's instructions as well as your Personalization settings. Duplication is the correct answer here, not a smell.

Cause 4: the new chat genuinely started empty

Sometimes nothing broke. A new chat is supposed to be empty, and the only things that reach across the gap are Custom Instructions, memory, and, inside a project, the project's own instructions and files. The transcript of that brilliant conversation from Tuesday is not among them.

This trips people up because the sidebar makes old chats look live. They are readable, not resumable. Opening one and continuing works because the transcript gets re-sent. Starting a fresh chat and referring to "the plan we agreed" does not, unless memory happened to synthesize that plan into something durable, which it may or may not have.

Temporary Chat produces the strangest version of this. Per OpenAI's Temporary Chat FAQ, it "won't access or create memories" but "will still follow your custom instructions if they're enabled". The result is a chat that knows your tone rules perfectly and has no idea who you are. People read that as ChatGPT forgetting them. It is ChatGPT doing precisely what the toggle says.

The fix is a re-entry brief you keep on hand rather than reconstruct each time:

CONTEXT RESET. Do not ask me to re-explain any of this.

Project: [one line]
Audience: [one line]
Non-negotiables:
- [constraint 1]
- [constraint 2]
- [constraint 3]
Decisions already made (do not relitigate):
- [decision + the reason]
Last good output:
"""
[paste only the most recent accepted version]
"""

Task: [what you want now]
If anything above conflicts with what you infer from memory, the text above wins.

That last line matters more than it looks. It resolves the ambiguity between a stale memory and your current brief, and it costs you eleven words.

Cause 5: it summarized the conversation instead of retaining it

This is the subtle one, and the one that makes people think the model is being lazy. The gist survives. The specifics evaporate. You get a reply that is broadly right about your project and wrong about the two numbers that actually mattered.

Two documented mechanisms explain it, plus one well-established research finding.

Compaction. On the API side, OpenAI documents this explicitly. When a conversation crosses a configured threshold, the server "runs server-side compaction", and it "prunes context before continuing inference". The replacement is described as an item that "carries forward key prior state and reasoning into the next run using fewer tokens", and OpenAI adds that it "is opaque and not intended to be human-interpretable". A compressed stand-in for your conversation, in other words, chosen by a process you cannot inspect.

Memory synthesis. Dreaming does the same job on a longer timescale. It converts conversations into a synthesized memory state rather than a verbatim archive. Synthesis means selection, and selection means loss.

Position effects. Even when material is technically inside the window, the model does not weight it evenly. The 2023 TACL paper Lost in the Middle: How Language Models Use Long Contexts found that "performance is often highest when relevant information occurs at the beginning or end of the input context, and significantly degrades when models must access relevant information in the middle of long contexts, even for explicitly long-context models". Your constraint from turn nine is in the middle. That is the worst place for it to be.

The fix: put the constraints that must not drift into the most recent turn, every time it matters. Not turn one. The turn you are on. Ten seconds of restating beats a rewrite.

Before you answer, re-confirm these in one line each:
1. Word count: [n]
2. Audience: [who]
3. Forbidden: [what you must not do]
4. Format: [structure]

Then produce the output. If you cannot confirm all four, say which one you lost.

Asking it to confirm is the trick. A model that has lost a constraint will confabulate around it if you let it, and will name the gap if you ask directly. This is the same discipline behind why your ChatGPT answers are bad: explicit contracts beat implied ones.

Where each fact should actually live

Most "ChatGPT forgets" complaints are really storage-layer mistakes. The fact was put somewhere that was never going to hold it. This table is the whole post compressed.

That last row is the one worth arguing about. Every layer above it is controlled by a vendor and can be overridden, capped, synthesized, or changed in a product update. The 2026 memory rebuild changed how ChatGPT stores things about you without you doing anything. If a prompt or a brief is load-bearing for your work, it belongs somewhere you own.

That is the whole thesis behind keeping a real prompt library rather than scrolling your history: how to write better ChatGPT prompts covers the writing side, and keeping persistent product context in every AI chat covers the storage side for anyone maintaining the same context across dozens of threads.

Prompt Architects exists partly because of this exact failure. Your standing context lives in a Context Library and your reusable instructions live in a Prompt Library, both outside any single chat, and Global Variables let one brief carry the client name, the audience, and the constraints without you retyping them. When the thread dies, the instructions do not.

We are not a memory system for ChatGPT and we do not claim to be. We do not read your chats, and no extension can extend your context window. On ChatGPT that number is set by your plan and by the model you pick, and nothing installed in your browser changes it. What we do is stop the useful half of your context from living only inside a transcript that is about to fall out of range.

How do I stop ChatGPT forgetting my instructions?

Set the standing rules once, in the layer that persists, and stop hoping the transcript will carry them. Here is a Custom Instructions block worth stealing. Paste it into Personalization, and paste the relevant half into each project's instructions too, because the project will override the global one.

HOW TO RESPOND

Format
- Lead with the answer. No preamble, no restating my question.
- Short paragraphs. Tables for anything with three or more comparable items.
- Code and copy-paste text always in fenced blocks.

Constraints
- If a request is ambiguous, ask exactly one clarifying question, then proceed.
- Never invent statistics, sources, prices, or quotes. Say "not verified" instead.
- If you are unsure, say so in one sentence and give your best answer anyway.
- Do not use: [your banned words]

Continuity
- If I say "CONTEXT RESET", treat the message that follows as the only truth
  and ignore anything you think you know from memory.
- If a constraint I set earlier conflicts with something in memory,
  the most recent thing I typed wins.
- If you have lost track of a constraint, say which one before answering.

That last block is the piece almost nobody writes, and it converts a silent failure into a visible one. A model that tells you it lost your word count is a model you can correct in one line. A model that quietly guesses costs you a rewrite.

Two habits complete it. Start a new chat earlier than feels necessary, roughly whenever a thread stops being about one thing. And keep a canonical version of any instruction you have written twice, because writing it a third time from memory is how instructions drift. If you are choosing between putting rules in a system prompt, a project, or the message itself, system prompt versus user prompt covers the trade-off properly.