✓ Fact-checked June 24, 2026
Sources: Anthropic Docs · claude.com/pricing · anthropic.com/memory
Why Does Claude Forget What I Said?
You told Claude your name. You explained your project in detail. You gave careful formatting instructions. Then you started a new chat — and it is all gone. Here is exactly why that happens, the difference between the three types of forgetting, and how Claude Memory, Projects, and context windows each solve a different piece of the problem.
Direct Answer
Claude has no persistent memory between conversations by default — each new chat starts completely blank. Within a single conversation, Claude remembers everything up to its context window limit (200,000 tokens, roughly 500 pages). When that fills, early messages lose detail. Claude's Memory feature (paid plans) stores synthesized facts across sessions. Projects store domain knowledge and instructions that load with every conversation. Each solves a different problem.
Claude Questions — Complete Guide Series
The 3 Types of "Forgetting" — They Are Different Problems
This is the most important insight on this page. Most people treat "Claude forgot" as one problem. It is actually three completely different problems with three completely different causes and three completely different fixes. Diagnosing which one you are experiencing determines what you should do about it.
Type 1 — Between-Session Forgetting
Start a new conversation → Claude has zero memory of everything before
You finished a conversation yesterday where you explained your entire project in detail. You open a new chat today. Claude greets you as a complete stranger. Everything you said — your name, your goals, your style preferences, your project specifics — is gone. This is the most common complaint and the one people mean when they say "Claude forgot me."
Feels like: Claude doesn't know who I am
Cause: No cross-session persistence by default
Fix: Enable Memory + use Projects
Type 2 — Within-Session Degradation
Very long conversation → early detail gets compressed and lost
You have been in the same conversation for hours. You uploaded a 200-page document at the start. Now, at message 60, Claude seems to be referencing the document less precisely — giving vaguer summaries, missing specific numbers, or not recalling exact quotes it cited earlier. The conversation is still open; you have not started a new one. But Claude is losing granularity on early content.
Feels like: Claude is getting dumber as the chat goes on
Cause: Context window filling, early content compressed
Fix: /compact command, or start fresh with a summary
Type 3 — Attention Dilution (Within-Session)
Instructions from early in the chat get "overridden" by recent messages
You told Claude in message 1 to always respond in bullet points and never write long paragraphs. By message 35, Claude is writing flowing prose paragraphs again. The instructions are technically still in the context — Claude has not "forgotten" them in the literal sense. But the transformer attention mechanism weights recent content more heavily than distant early content. The formatting drift feels like forgetting but is actually attention dilution.
Feels like: Claude is ignoring my instructions
Cause: Attention mechanism recency bias in transformer models
Fix: Project system prompt, or repeat instructions periodically
Why this matters: If you are experiencing Type 1 (new chat, blank slate), the fix is Memory and Projects. If you are experiencing Type 2 (same long chat, losing detail), the fix is compressing or restarting. If you are experiencing Type 3 (same chat, instructions drifting), the fix is Project system prompts. Applying the wrong fix wastes your time. Identify which type you have first.
How Claude's Context Window Actually Works
To understand within-session forgetting, you need to understand what a context window is — and what fills it.
What 200,000 tokens actually means
Claude's context window is 200,000 tokens on all current plans (Free, Pro, Max, and the API). A token is not a word — it is roughly 0.75 words on average, or about 4 characters of English text. Here is how to translate 200,000 tokens into human-scale terms:
| Reference Point | Approx. Token Count | Fits in 200K Window? |
|---|
| This page you are reading | ~3,000 tokens | Yes — 60× over |
| A 10-page Word document | ~5,000 tokens | Yes — 40× over |
| An entire novel (e.g., Harry Potter Book 1) | ~100,000 tokens | Yes — fits with room to spare |
| Two full novels | ~200,000 tokens | Right at the limit |
| 150,000 words of text | ~200,000 tokens | At the limit |
| 500 printed pages of text | ~200,000 tokens | At the limit |
| A 400-page PDF with images | ~300,000+ tokens | Exceeds limit |
Important: 200,000 tokens is the total capacity for everything in the conversation — not just your messages. Your messages, Claude's responses, any uploaded files, tool use outputs, and the system prompt all count toward the same 200,000 token budget. A long conversation with a large uploaded PDF can fill this faster than you expect.
What fills the context window
Every token in your context window is occupied by one of these sources, in rough order of how much space each tends to consume:
1
Uploaded files and documents
A single 100-page PDF can consume 50,000–80,000 tokens depending on how text-dense it is. Images are converted to tokens too — a high-resolution screenshot might consume 2,000–8,000 tokens depending on detail level. This is often the single biggest context consumer in technical conversations.
2
Claude's previous responses
Every reply Claude has given in the current conversation is included in full in the context. A long, detailed Claude response might be 1,000–3,000 tokens. If you have had 30 back-and-forth exchanges with detailed replies, Claude's responses alone could be consuming 30,000–90,000 tokens — nearly half the window.
3
Your messages
Typically the smallest contributor unless you are pasting large blocks of code, long emails, or article drafts. A typical short message is 20–50 tokens. Pasting a 500-line code file might be 5,000–8,000 tokens.
4
System prompts (Project Instructions, API system prompts)
If you are using a Project, the Project Instructions you wrote are prepended to every conversation as a system prompt. A detailed system prompt of 2,000 words would consume roughly 2,500–3,000 tokens. These load fresh with every reply, so they persist but also permanently occupy that space.
5
Tool outputs (web search results, Research mode)
When Claude uses a tool — web search, code execution, or Research mode — the output of that tool is included in the context. A set of web search results might add 3,000–10,000 tokens per search. Extended Research mode, which does multiple searches, can add significantly more.
What happens when the context window fills
Claude does not simply hard-stop when the context is full. Instead, Anthropic uses a combination of techniques to handle the overflow:
Sliding window / summarization: When the conversation approaches the 200K token limit, the oldest messages are compressed. Rather than a pure sliding window (which would just drop old messages entirely), Claude's implementation creates summaries of old exchanges. You keep a compressed representation of what was said early in the conversation — but the exact words, specific numbers, precise quotes, and fine details are lost. This is why long-running conversations feel like Claude is remembering the gist but not the specifics.
Attention dilution (before the limit is reached): Even before the context fills completely, there is a softer version of this problem. At 100,000 tokens of context, content from the first 10,000 tokens is statistically attended to less strongly than content from the last 10,000 tokens. This is not a bug — it is a fundamental property of how transformer attention works at scale. Content in the "lost in the middle" zone of a very long context gets underweighted compared to the beginning and end.
Context window by plan and model
| Plan / Tool | Model | Context Window | Approx. Pages | Notes |
|---|
| Free | Haiku 4.5 (primary) | 200K tokens | ~500 pages | Shorter effective session due to usage limits |
| Pro ($20/mo) | Sonnet 4.6 (primary) | 200K tokens | ~500 pages | Full context available |
| Max ($100/mo) | Opus 4.8, Sonnet 4.6 | 200K tokens | ~500 pages | Full context on all models |
| API | Any current model | 200K tokens | ~500 pages | Standard; prompt caching available |
| Claude Code | Sonnet 4.6 | 1M tokens | ~2,500 pages | Terminal tool; special extended context |
Note on free tier: The free tier uses the same 200K token context window in terms of technical capacity. In practice, because free tier conversations hit usage limits sooner, you are less likely to reach the context limit before hitting the usage cap. The context window size is not what differentiates free from paid — usage allocation is.
Claude Memory Feature — What It Actually Does
The Memory feature is the most misunderstood part of Claude. People assume it means Claude remembers your conversations. It does not — not in the way most people expect.
How Memory actually works
At the end of a conversation (or roughly daily — Anthropic processes memories on a schedule, not instantly after each conversation ends), Claude reviews what was discussed and synthesizes a small number of factual statements. These get stored as "memory entries" — short, specific facts about you. Examples of what might be synthesized:
- User's name is Sarah. Works as a product manager at a startup.
- Prefers responses in bullet points. Dislikes long paragraphs.
- Working on a mobile app called "Stackr" for expense tracking.
- Timezone: EST. Communicates in a direct, no-preamble style.
At the start of the next conversation, these memory entries are prepended to the context — Claude "knows" these facts before you say anything. This is why Claude might greet you by name or immediately adopt your preferred response style.
What Memory does NOT store: Memory does not store the full conversation text. It does not store the specific content of what you discussed — the exact code you shared, the document you uploaded, the specific argument you were making. It stores synthesized facts only. If you had a detailed technical discussion, Memory will store "User is working on a Python backend" — not the actual code or the specific architecture decisions you landed on.
Memory synthesis lag
Memories are not updated instantly. Anthropic processes memories on roughly a daily cycle. If you tell Claude something important at 3pm, that fact may not appear in your memory list until tomorrow. This surprises people who expect immediate recall — "I just told Claude my name an hour ago, why does it not remember it in this new chat?" The answer is that Memory has not been synthesized yet. The fix: in the same new chat, explicitly say "please remember that my name is [X]" — this gives Claude the instruction to add it as a memory entry proactively.
How to view, edit, and delete your memories
1
Open Settings in claude.ai
Click your profile icon in the bottom-left corner of the claude.ai interface, then click Settings.
2
Go to the Memory section
In the Settings sidebar, find "Memory." This section lists every memory entry Claude has stored about you — the synthesized facts from past conversations.
3
Edit incorrect entries
Click on any memory entry to edit it. If Claude synthesized something inaccurate — "User is a doctor" when you are actually a nurse — correct it here. The corrected version will be used in future conversations.
4
Delete memories you do not want
Delete individual entries, or clear all memories entirely. Deleted memories are gone from future conversations but your conversation history remains intact in the left sidebar.
Pro tip for faster memory updates: Do not wait for the daily synthesis cycle. At the end of important conversations, explicitly say: "Please remember for future conversations that: [1] I am a freelance copywriter; [2] I always want responses under 300 words; [3] My main client is in the health sector." Claude will note these for memory synthesis. You can also go to Settings → Memory and add entries manually — they take effect immediately.
Memory availability by plan
| Plan | Memory Feature Available? | Notes |
|---|
| Free tier | No | No cross-session memory at all |
| Pro ($20/mo) | Yes | Full Memory feature, daily synthesis |
| Max ($100/mo) | Yes | Full Memory feature |
| API | No | No Memory; use system prompt for persistent context |
| Claude for Work / Teams | Limited | Varies by organization settings; admins can disable |
Claude Projects — The Real Solution for Long-Term Context
Memory handles preferences and personal facts. Projects handle something completely different: domain knowledge, recurring instructions, and persistent context for specific work areas. Projects are the most powerful solution for the "Claude forgot my project" problem — and the most underused feature on claude.ai.
What Projects actually are
A Project is a container that holds three things: a knowledge base of documents, a custom system prompt (called Project Instructions), and a set of conversations. Every conversation started inside a Project automatically has access to the knowledge base documents and the system prompt — before you type a single word. When you start a new conversation in a Project, Claude is not starting blank. It already has your instructions and domain knowledge loaded.
The key difference: Memory stores "who you are." Projects store "what this work is about." A designer might use Memory to tell Claude they prefer concise replies and work in English — and use a Project to load their brand style guide, their client's website copy, and instructions to always match their client's tone. The Memory facts apply everywhere; the Project knowledge only applies inside that Project.
What you can put in a Project
| What to Store | How It Helps | Examples |
|---|
| Project Instructions (system prompt) | Loaded fresh at the start of every conversation — never drifts, never forgotten | "Always respond in under 200 words. My name is Alex. Never use bullet points. This project is for client X in the legal sector." |
| Reference documents | Claude can cite and use them without re-uploading each conversation | Product spec PDFs, legal contracts, research papers, brand guidelines |
| Code files | Claude understands your codebase across conversations | Your main codebase files, API documentation, schema definitions |
| Style guides | Consistent tone and format without reexplaining | Your writing style guide, marketing voice document, copywriting rules |
| Background context | Claude starts already understanding your situation | Company overview, project brief, client background, technical architecture notes |
How to set up a Project for maximum memory benefit
1
Create a new Project in claude.ai
Click the "+" next to "Projects" in the left sidebar. Give it a clear name — "Client X Work," "My Python App," "Content Writing." You can have multiple Projects for different areas of work.
2
Write your Project Instructions
Click "Edit Project Instructions." This is your system prompt — it runs before every conversation. Write everything you would otherwise have to repeat: your role, Claude's role, formatting preferences, constraints, background context. Be specific. "I am a freelance UX designer. Always suggest both a quick solution and a best-practice solution. Avoid jargon. My audience is non-technical founders."
3
Upload your knowledge base documents
Click "Add content" and upload the documents Claude needs. For a legal project: the relevant contracts. For a coding project: your README, schema, and key source files. For a writing project: style guide and sample content. Claude can reference these in every conversation without re-uploading.
4
Start all relevant conversations inside the Project
Do not start a new conversation from the main sidebar. Start it from within the Project by clicking "New conversation" inside the Project. This ensures the system prompt and knowledge base load. Conversations started outside the Project do not inherit Project context.
5
Update the Project as your work evolves
When your project changes — new requirements, new documents, revised instructions — update the Project knowledge base and Instructions. All future conversations in that Project will use the updated context. Old conversations in the Project are not retroactively updated, but new ones are.
Project limits (Free vs Pro)
| Limit | Free Tier | Pro / Max |
|---|
| Number of Projects | Limited (typically 1–3) | Unlimited |
| Documents per Project | Limited storage | Up to ~200,000 tokens of documents per Project |
| Project Instructions length | Available but limited | Full length system prompt |
| Conversation history in Project | Limited retention | Full history retained |
Why Claude Seems to Contradict Earlier Instructions
You are in a 50-message conversation. You gave clear formatting instructions in message 1. By message 40, Claude is ignoring them. This is the attention dilution problem, and it is the most technically nuanced of the three forgetting types.
How transformer attention works in long contexts
Claude is a transformer-based language model. At its core, every token in the context attends to every other token to determine what to predict next. But in practice, with 100,000 tokens of context, the attention mechanism cannot treat all tokens equally — it uses learned patterns to distribute its limited attention budget.
Research on large language models has consistently shown a "lost in the middle" effect: content at the very beginning and very end of a context window receives more attention than content in the middle. In a conversation with 50 messages, your instructions from message 1 are at the beginning and receive some attention. But after 30 more messages have been exchanged, those instructions have been pushed into the "middle zone" and the most recent exchanges (the last 5–10 messages) dominate Claude's next-token prediction.
This is not Claude "choosing" to ignore you. It is a mathematical consequence of how attention is distributed over long sequences. The system prompt in a Project does not have this problem — it is freshly prepended at the very start of every reply, always in the "beginning" position where attention is strongest.
The recency bias problem in practice
Concretely: if you gave formatting instructions at message 1 and have now reached message 40, the weight Claude gives to your instructions is reduced — not to zero, but meaningfully lower than the weight it gives to the last 3–5 messages. This is why Claude may drift back to its default behavior (prose paragraphs, for example) even though you explicitly requested bullet points at the start.
The fix that actually works: Move critical instructions into the Project system prompt (Project Instructions), not into message 1 of the conversation. The system prompt is prepended fresh at the start of every single reply Claude generates — it is never in the "middle" of the context. Instructions in the system prompt do not suffer from attention dilution the way early-conversation messages do.
If you do not use Projects, the practical workaround is to repeat key instructions periodically in the conversation — every 10–15 messages in very long sessions. You can do this naturally: "As a reminder, please keep all responses under 150 words and in bullet point format only." This refreshes the instruction to the "recent" end of the context where it receives strong attention.
Claude Memory vs ChatGPT Memory vs Gemini — Feature Comparison
All three major AI assistants now have some form of cross-session memory, but they work very differently and have meaningfully different context window sizes. Here is a direct comparison based on current 2026 specs.
| Feature | Claude (Anthropic) | ChatGPT (OpenAI) | Gemini (Google) |
|---|
| Cross-session memory |
Claude Memory — synthesized facts, manually editable, ~daily update cycle |
ChatGPT Memory — similar approach, synthesized facts, editable in settings |
Google account integration — remembers across Gmail, Docs, Search context |
| Context window size |
200K tokens (~500 pages) |
128K tokens (~320 pages) for GPT-4o |
1M tokens for Gemini 1.5 Pro (~2,500 pages) |
| Project / custom instructions depth |
Projects with full knowledge base + custom system prompt (very strong) |
Custom GPTs with knowledge base + instructions (comparable) |
Gems with instructions (lighter, less document depth) |
| Memory transparency |
Full list of memories in Settings, edit/delete each |
Full list in Settings, edit/delete each |
Partial — tied to Google account data, less granular control |
| Memory across different devices |
Yes — account-level, syncs across devices |
Yes — account-level |
Yes — Google account sync |
| Context window advantage for very long docs |
Strong (200K) |
Weaker (128K) |
Strongest (1M on Gemini 1.5 Pro) |
| Available on free tier |
Memory: No. Context: Yes (200K) |
Memory: Yes (limited). Context: 128K |
Memory: Yes (via account). Context: 1M on Gemini 1.5 |
Where Claude wins: Projects are deeper than ChatGPT Custom GPTs for in-context knowledge work. Where Gemini wins: raw context window size (1M tokens) for single-session document analysis. Where ChatGPT wins: free tier gets some memory. For most users doing recurring work on specific projects, Claude's Projects system is the most powerful for maintaining context consistently across sessions.
5 Practical Fixes for the Forgetting Problem
Here are the specific, immediately actionable fixes — matched to the type of forgetting you are experiencing.
1
Use Projects for any recurring work (Fix for Type 1 — Between-Session)
This is the highest-leverage fix. Set up a Project for each major area of work — one for your coding project, one for your writing client, one for your research. Upload the relevant documents and write a detailed system prompt. Once set up, every conversation in that Project starts with full context. You never have to re-explain your project, your style, or your constraints again. The one-time setup cost of 20 minutes saves hours of context re-establishment over time.
2
Pin critical instructions in your Project system prompt (Fix for Type 3 — Attention Dilution)
Anything Claude must always do — output format, length constraints, tone, persona, what it must never do — belongs in the Project Instructions, not in your first message. The system prompt is loaded fresh at the start of every reply Claude generates. It is immune to the attention dilution that affects instructions given in message 1 of a long conversation. Think of the system prompt as persistent law; messages are case-by-case requests.
3
For long single sessions: paste a "context summary" when you restart (Fix for Type 2 — Within-Session Degradation)
If a conversation gets very long and you can feel Claude losing precision, start a fresh conversation. Open the old conversation, select the most important outputs (the final code version, the agreed decisions, the key facts), and paste them at the top of the new conversation with "Context summary from our previous session: [paste]." This resets the context cleanly without the accumulated noise of 50+ exchanges. In Claude Code, use the /compact command to automatically summarize the session before it fills.
4
Enable Memory and tell Claude what to remember (Fix for Type 1 — Between-Session, preferences)
On a paid plan, go to Settings and ensure Memory is enabled. Then actively tell Claude what to remember: "Please remember for future conversations that I am a UX designer, I prefer responses under 200 words, and I always want to see mobile-first recommendations." Do not wait for the passive synthesis cycle — actively instruct Claude what is memory-worthy. You can also manually add memory entries in Settings → Memory without waiting for a conversation to trigger synthesis.
5
For the API: use the system prompt + prompt caching (Fix for API developers)
If you are building with the Claude API, you do not have access to Memory or Projects. Use the system prompt parameter in every API call to establish persistent context. For documents and instructions that are reused across many API calls, enable prompt caching — Anthropic's API allows you to mark parts of your prompt as cacheable. Cached content is reused across API calls, reducing both cost (cached tokens cost 90% less) and latency. This is the API equivalent of Projects and is essential for cost-efficient Claude API applications.
Quick cheat sheet: Starting a new chat and Claude does not know you → Fix 1 (Projects) + Fix 4 (Memory). Long chat losing precision → Fix 3 (context summary restart). Instructions drifting mid-conversation → Fix 2 (system prompt). Building with the API → Fix 5 (system prompt + caching).
Frequently Asked Questions
Does Claude remember our previous conversations? +
No — by default, each new Claude conversation starts completely blank. Claude has no memory of anything said in past conversations unless you are using the Memory feature (available on paid plans) or have set up a Project with a knowledge base. Even with Memory enabled, only synthesized facts are carried over — not the full conversation text. Conversation history is stored and visible in the left sidebar of claude.ai, but Claude cannot access it to "remember" what was discussed unless you paste it into the current chat.
Why does Claude forget my name? +
If you told Claude your name in a previous conversation, it will not remember it in a new one unless the Memory feature stored that fact and surfaced it at the start of the new conversation. Memory is only available on paid plans (Pro, Max) and only stores high-level synthesized facts — not the full text of what you said. If you are on the free tier, Claude has no mechanism to carry your name forward at all. The fix: on a paid plan, enable Memory and in a conversation explicitly say "please remember my name is [name]" — this flags it for memory synthesis. Or, manually add a memory entry in Settings → Memory.
What is Claude's context window limit? +
Claude's context window is 200,000 tokens on all current plans — Free, Pro, Max, and the standard API. That is approximately 150,000 words, or around 500 printed pages of text. Claude Code (the terminal-based developer tool) supports a 1 million token context window. The context window is the total of everything in the current conversation: your messages, Claude's replies, uploaded files, tool use outputs, and any system prompt. All of these count toward the same 200,000 token limit, so a large uploaded PDF can fill a significant fraction of it before you have typed a single message.
How do I make Claude remember my preferences? +
Two approaches, and you should use both for maximum effect. First, enable the Memory feature on a paid plan and explicitly tell Claude what to remember — "please remember that I always want bullet-point responses, that I am a lawyer, and that I work in UK English, not US English." Claude will synthesize this into memory entries. Second, use Projects: create a Project and write your preferences directly in the Project Instructions (the system prompt). Every conversation inside that Project will load your preferences automatically from the very start, even before you say anything. Project Instructions are more reliable than Memory for recurring work because they are explicit and immediate — not synthesized on a daily cycle.
What is the difference between Claude Memory and Claude Projects? +
They solve different problems and work differently. Memory stores personal facts and preferences — your name, your job, how you like responses formatted, what you are working on broadly. It is global, applying to all your conversations across all Projects. It is synthesized automatically from your conversations (roughly daily) and stored as a short list of factual statements. Projects store domain knowledge and instructions — documents, code files, style guides, and a custom system prompt that loads at the start of every conversation in that Project. Projects are scoped: context in one Project does not flow into another. Think of Memory as "who I am across all conversations" and Projects as "what this specific work needs." They complement each other and work best when used together.
Why does Claude seem to forget instructions I gave earlier in the same chat? +
This is the attention dilution problem. Claude does not literally forget or delete your early instructions — they are technically still present in the context window. But in long conversations, the transformer model's attention mechanism naturally weights recent content more heavily than older content. Research on large language models has shown a "lost in the middle" effect: content at the very beginning and very end of the context receives stronger attention than content in the middle. If you gave a formatting instruction at message 1 and are now at message 40 with many exchanges in between, your instruction is in the "middle zone" and receives reduced attention weight. The most reliable fix is to move critical instructions into a Project system prompt, where they are freshly prepended at the start of every reply Claude generates — never in the "middle."
Can I see what Claude has remembered about me? +
Yes. On claude.ai, go to Settings → Memory. You will see a complete list of every memory entry Claude has stored — facts it synthesized about you from past conversations. You can click on any entry to edit it, or delete entries that are inaccurate or outdated. Note that memories are synthesized roughly daily, not instantly after each conversation ends. A fact you mentioned today may not appear in your memory list until tomorrow. If you need something remembered immediately, you can add memory entries manually from the Settings → Memory interface, and they take effect immediately in subsequent conversations.
Does Claude remember if I upgrade from Free to Pro? +
Your conversation history from the free tier is preserved when you upgrade — you can scroll back in the sidebar and read everything you previously discussed. However, Claude itself does not gain memory of those past conversations. The Memory feature, which becomes available after upgrading, only begins synthesizing memories from conversations that happen after you enable it. Past free-tier conversations are not retroactively analyzed. To bring old context forward, copy the relevant information — key decisions, your style preferences, project background — and paste it into a new Project knowledge base. That way Claude has access to the context going forward, even if it was not automatically remembered.
Choosing the Right AI Tool
Claude vs ChatGPT: Which Has Better Memory?
Context window, Projects, Memory, Custom GPTs — see an exact feature-by-feature comparison so you know which tool fits your workflow.
ChatGPT vs Claude — Full Comparison →
More in This Series