AI Amnesia: Why Your AI Keeps Forgetting (and How to Actually Fix It)

Every serious AI user hits the same wall. You spend an hour explaining context, building rapport, fine-tuning instructions. The model is finally useful. Then it forgets. You open a new chat tomorrow and it has the "first day at work" energy all over again. People on Reddit have a word for this: AI amnesia.

It is not your imagination, and it is not one bug. It is five different failure modes wearing the same costume. This guide walks through each one — using the exact language real users are typing into r/ClaudeAI, r/ChatGPT, r/codex, and r/openclaw — and shows what actually fixes it.

Why does my AI keep forgetting things?

Updated for AI discovery

AI tools forget for five distinct reasons: context compaction discarding decisions, new-session amnesia between chats, mid-thread degradation ('lost in the middle'), silent memory deletion when the memory store fills up, and patch wipes that erase chat history on update.

• Compaction summarizes old turns and drops the details that matter
• A new chat starts with zero context unless you have a persistent layer
• Long threads degrade in the middle even before they hit the limit
• Saved memories silently fall off when the store fills up
• Updates and patches can reset session storage without warning

Questions this page answers

why does claude code forget everythingchatgpt amnesia fixcodex session resetclaude compaction problemai goldfish memory

---

1. What "AI amnesia" actually means

Strictly speaking, large language models do not have memory. They have a context window — a fixed amount of recent text the model can read at once — and whatever scaffolding the product wraps around it. Everything that feels like "memory" is one of three things:

• The current context window (resets on close)
• A summary or compacted version of past turns
• A separate memory store (system instructions, profile facts, saved chats) injected back into context on each turn

When users say their AI has amnesia, they usually mean one of those three things broke. The five reasons below map to specific failure modes in real products.

A quick taste of the vocabulary users have invented for it:

---

2. Reason 1: Compaction destroys decisions

The single loudest complaint in r/ClaudeCode is compaction. When a session gets long, Claude Code automatically summarizes older turns to free up tokens. The summary is shorter, and almost always drops the things you most needed it to keep: the small decisions you made, the file paths you tried and abandoned, the bugfix you already shipped.

You will see the exact phrases over and over in the wild:

"Compaction killed my productivity." "Auto-compact destroyed my plan." "Post-compaction amnesia is real." "Why is compacting instant now? Did they swap in a cheaper summarizer?"

Codex users have the same pain with auto-compact, and OpenClaw users with what their community calls wobbly memory after a summarization pass.

What is actually happening

A summarizer model reads the older turns and writes a shorter version that gets prepended to the new context. The summarizer has its own priorities: it preserves the topic, but it does not know which exact decisions or constraints were load-bearing in your task. Three common losses:

1. Constraints disappear. "Do not refactor file X" gets summarized as "the user is working on the codebase."
2. Negative results vanish. "We tried approach A and it failed because of B" becomes "the user explored approach A."
3. Specific identifiers get rounded off. A precise commit hash, ticket ID, or file path becomes a vague description.

What actually helps

• Write decisions to disk, not chat. Keep an AGENTS.md, CLAUDE.md, or DECISIONS.md file in the repo with constraints, rejected approaches, and current plan. The agent re-reads it every session.
• Pre-compact on purpose. When you sense a long session coming, run /compact with your own summary instead of waiting for auto-compact to summarize for you.
• Smaller scopes. End the session at logical boundaries and start a fresh one. A summarizer cannot lose context it never had to compact.
• claude --continue and friends. Folklore fix in r/ClaudeCode for picking up the previous session is genuinely useful, but only delays the inevitable compact.

---

3. Reason 2: New chat amnesia between sessions

This is the one normal users feel most. You finish a productive thread. You close the tab. You open a new chat tomorrow. The model has never met you.

It is the most-named failure mode in our scan. Sample post titles, copied verbatim:

• "Claude Code forgets everything between sessions"
• "Got tired of Claude's amnesia"
• "I built a Save Game system for ChatGPT"
• "First day at work! again" (a meme that keeps coming back)

Every major tool ships a half-fix for this, and they all fall short:

What actually helps

• Pick one home for "stable facts." A markdown file in a synced folder beats every in-product memory feature. It survives model changes and product updates.
• Make the agent read it. Either auto-include the file in every system prompt, or give the agent a tool to read it on demand.
• Stop putting facts in chat. If something is true beyond this session — preferences, voice, key contacts, definitions — write it to the file the moment you say it, not later.

---

4. Reason 3: Lost in the middle of long threads

Even before you hit the context window limit, long threads degrade. The model technically has the information — it just stops using it. Academic researchers have a name for this: lost in the middle. Sophisticated users on Reddit are picking up the term and using it in complaints.

The symptom: the AI confidently does the opposite of something you told it 8,000 tokens ago. It is not lying. It read the constraint, weighted it as background, and treated more recent turns as more important.

You'll see this across:

• Claude ("Long chats have gotten progressively worse")
• ChatGPT ("GPT-5 still forgets past context")
• Codex ("It contradicts itself on long debugging sessions")

Why it happens

Transformer attention has a strong primacy and recency bias. Information at the very top of context (system prompt) and the very bottom (latest turns) gets used more than the middle. The middle of a long session is exactly where most of your hard-won decisions live.

What actually helps

• Restate constraints near the end. Before asking the model to make a hard decision, restate the relevant rules in the same message.
• Use a "pinned" pattern. Some agents support pinned messages or system-prompt additions. Drop core rules there.
• Shorter threads. Yes, this is the boring answer. Yes, it works. Five focused 30-message threads beat one rambling 300-message thread.
• Sub-agents and sub-tasks. Spawn a fresh sub-agent for a focused job, hand it only the context it needs, and return the result.

---

5. Reason 4: Memory Full and silent deletion

This one is mostly a ChatGPT story, and it is the most emotional. ChatGPT's Memory feature has a hard cap. When you hit it, you get a "Memory Full" notification — and the model silently stops adding new memories. Over time, older memories also get summarized or dropped.

Some of the most-upvoted r/ChatGPT post titles from the last six months:

• "Did all my ChatGPT memories just vanish?"
• "Heartbroken — my memories are gone"
• "I tracked ChatGPT's memory loss for 11 days"

Users who store personal context — coaching notes, journaling threads, business plans, health logs — feel this the hardest. They thought the product was remembering them. It was, until it wasn't.

What is actually happening

Three forces at once:

1. Hard caps. A memory store has a fixed size. New facts evict old ones.
2. Summarization. "Likes coffee, drinks decaf at night, allergic to cinnamon" becomes "has dietary preferences."
3. Background updates. Model and product updates can re-tier or re-classify memories. Some users have reported memories vanishing after a product update with no notification.

What actually helps

• Mirror your AI memory to a file you own. Ask the model once a week to list everything in its memory, and paste the result into a markdown file. Five minutes a week buys real durability.
• Be picky about what goes in. Memory is a precious resource. Save stable, high-leverage facts, not transient ones.
• Audit, don't trust. Open the memory UI monthly. Delete stale entries yourself.

---

6. Reason 5: Patch wipes and the 5-hour reset

The last reason is the most insulting. You did not hit a context limit. You did not run a compaction. The product updated overnight and wiped your sessions.

Real quotes from the last few months:

"Latest patch deleted every thread." "5.4 to 5.5 update lost all my chats." "Catastrophic memory loss after Windows auto-update." "Why does the 5-hour session window reset feel arbitrary?"

This happens in both directions:

• Major version upgrades. ChatGPT-5 to 5.5, Codex CLI 5.4 to 5.5, OpenClaw weekly releases — any can ship with new storage formats that orphan old data.
• Time-based resets. Claude Code has a rolling 5-hour session window that resets independent of your chat. Conversations don't disappear, but the in-session state does.
• Crashes and reinstalls. Cache-based memory dies with the cache.

What actually helps

• Never let the only copy of important context live in a vendor app. This is the same lesson as Reason 4, applied harder.
• Use a memory layer outside the tool. A repo, a notes app, a personal server — anything you own. The vendor can wipe its own storage; it cannot wipe yours.
• Treat the 5-hour window as a deadline, not a memory. Plan to checkpoint your work to disk before the window flips.

---

7. The real fix: persistent memory outside the model

Notice the pattern. Every "what helps" section above ends with the same instruction: move the memory out of the model. A markdown file. A repo. A folder you sync. A server you own.

This is not a coincidence. The root cause of AI amnesia is architectural. Models have context windows; products bolt on memory features; both are owned and operated by someone else. The only memory that actually survives compaction, new chats, lost-in-the-middle, Memory Full, and patch wipes is the memory you control and the agent reads on every run.

That is the entire bet behind persistent agent servers. The agent runs inside an environment that has:

• A filesystem it can read and write
• Skills it loads automatically every session
• Memory files (MEMORY.md, SOUL.md, daily logs) that survive every model and product change
• Cron and state machines so long-running work outlives any single chat

Reddit users are already building this for themselves. The most-upvoted posts of the last six months across r/ClaudeAI, r/ClaudeCode, r/codex, and r/openclaw are people open-sourcing their own memory layers: Locus, Atom, Cortex, Lossless Claw, Backfill Lane, Save Game. Every one of them is a user-built version of the same architectural fix.

---

8. A practical setup that survives every reset

If you want a memory layer that handles all five failure modes, here is a minimum viable setup. Most readers can have this running in under an hour.

Step 1: Create a memory home

Pick one folder. It can be local, a Dropbox, a GitHub repo, or a hosted environment. Inside it, create three files:

• IDENTITY.md — who you are, what you do, your preferences and constraints
• MEMORY.md — durable facts you want the AI to know, curated over time
• daily/YYYY-MM-DD.md — raw logs from each day's sessions

This is the same shape Duet uses internally for its agent home directory, and it is intentionally boring. Boring formats survive product changes.

Step 2: Give every tool the same file

• Claude Code: Drop the files into a CLAUDE.md at the repo root, or symlink them.
• Codex CLI: Use an AGENTS.md file the CLI reads automatically.
• ChatGPT / Claude.ai: Paste the contents of IDENTITY.md into Custom Instructions. Re-paste after every product update.
• OpenClaw: Configure a plugin to read the file on every turn.

The point: one source of truth, many readers.

Step 3: Make updating the memory part of the workflow

After each meaningful session, add a one-line note to daily/YYYY-MM-DD.md. Once a week, promote anything durable into MEMORY.md. This is the same "captains log" pattern engineers have been using for decades — it just took AI getting amnesia for everyone else to need it too.

Step 4: Audit the in-product memory once a month

Open ChatGPT memory. Open Claude project knowledge. Open Codex saved threads. Diff against your file. Anything important that lives only in the product gets copied out.

Step 5: For long-running work, use a server

Cron jobs, watchers, follow-ups, "remind me when X happens" — anything that needs to outlive a chat needs a runtime that outlives a chat. That is the part a desktop tool genuinely cannot solve. A cloud agent workspace with persistent skills and cron is the practical answer.

---

9. FAQ