How Claude Remembers (and Forgets) Within a Chat Session
Claude feels like it "remembers" what you talked about ten minutes ago in the same chat, and it does. Open a new chat tomorrow and ask a follow-up without context, though, and Claude has no idea what you're referring to.
Both of these behaviors come from the same underlying mechanism, not from two different memory systems. This page walks through how session memory actually works, why it stops at the edge of a chat, and what your one real option is for sharing context across separate conversations.
Summary
Claude does not store a persistent memory of you or your conversations the way a notes app stores files.
Instead, every reply is generated by re-reading the entire labeled history of the current conversation, from the first message onward, up to the token budget of the context window.
"Remembering" earlier turns within a session is really just that full history still being present and readable when Claude generates the next reply.
"Forgetting" across sessions happens because a new chat starts that history over at zero - there is nothing to re-read yet.
The one built-in exception is Claude.ai Projects, which let certain documents and instructions persist and get pulled into multiple chats within that project.
Recipe
Quick-reference: what carries over, and what doesn't.
- Within the same chat: everything you've said and everything Claude has replied stays part of the conversation, available for Claude to reference on the next turn - up to the model's context window limit.
- In a brand-new, separate chat: none of that history is present by default. Claude starts with an empty context window.
- In a Claude.ai Project: documents and instructions you've attached to the project persist and are available across multiple chats inside that project - but each individual chat is still bounded by its own context window when generating a reply.
When this matters:
- Continuing a multi-step task (drafting, then revising, then refining) - stay in one chat.
- Asking something completely unrelated to your last conversation - a new chat is cleaner and faster.
- Working on the same body of material (a project's docs, a research topic) across several sessions over days or weeks - use a Project.
- A single chat has grown very long and started missing early details - that's a context-window limit, not a separate "forgetting" bug.
Working Example
Here's what session memory looks like across a realistic sequence of messages in one chat, followed by what happens in a new chat afterward.
Turn 1 (you):
"I'm writing a cover letter for a marketing coordinator role. Can you give me an opening paragraph?"
Turn 1 (Claude):
Gives a drafted opening paragraph.
Turn 2 (you):
"Make it a bit warmer in tone."
Turn 2 (Claude):
Revises the same paragraph, because "it" resolves to the paragraph from Turn 1 - which is still part of the conversation Claude is reading.
Turn 3 (you), in a brand-new chat:
"Make it a bit warmer in tone."
Turn 3 (Claude):
Asks what "it" refers to, or answers a generic question about tone - because this new chat's context window has no record of the cover letter from the earlier conversation.
What this demonstrates:
- Turn 2 works because the full conversation, including Claude's own Turn 1 reply, is still present in the context window when Turn 2 is generated.
- Turn 3 fails to resolve "it" because a new chat begins with an empty context window - nothing is shared automatically between separate conversations.
- The difference isn't about Claude "trying harder" to remember - it's a structural fact about what's present in each chat's context window at generation time.
- Copying the relevant earlier text into the new chat would fix Turn 3 immediately, because that text would then be part of the new conversation's context.
Deep Dive
How It Works
- Every time you send a message, Claude does not append to some separate long-term memory store - it re-reads the entire conversation so far (every prior user and assistant turn, plus the system prompt) as part of generating the next reply.
- This full-history re-read is what makes "remembering earlier turns" possible: the information isn't recalled from storage, it's simply still present in the input Claude reads each time.
- The context window is the shared token budget bounding how much of that history can be present at once - it ranges from 200K tokens on Claude Haiku 4.5 up to 1M tokens on Claude Fable 5, with Claude Sonnet 5 and Claude Opus 4.8 supporting large windows in between depending on configuration.
- As a session gets very long, the growing history eventually competes for space inside that fixed budget, and the oldest turns are the first to be crowded out or de-prioritized - which is why very long single-session chats can start to lose track of early details even without ever leaving the chat.
- A brand-new chat has nothing in its context window yet, so there is no history to re-read - this is "forgetting" only in the sense that nothing was ever carried over, not in the sense of something being actively erased.
What Carries Over Across Chats
| Scenario | Carries Over Automatically? | Notes |
|---|---|---|
| Same chat, next message | Yes | Full prior history is part of the context window every turn. |
| New, separate chat | No | Context window starts empty; nothing from the old chat is included. |
| Claude.ai Project, different chat inside it | Partially | Attached documents and instructions persist across chats in the project; the live conversation history of one chat does not automatically appear in another. |
| Copy-pasting old context into a new chat | Yes, manually | Whatever you paste becomes part of the new chat's context window from that point on. |
Session Memory Notes
- Session memory is not selective - Claude does not choose to "remember" some turns and "forget" others within a live session; it's an all-or-nothing function of what's still inside the context window.
- Editing or regenerating an earlier reply in a chat effectively updates that turn in the history, and everything generated afterward is based on the updated version.
- Nothing about session memory is tied to your account or identity across chats by default - a new chat's blank slate applies the same way regardless of who's using it, outside of Project-level shared context.
Gotchas
- Assuming a new chat remembers your last conversation - a new chat starts with an empty context window; nothing from a separate, prior conversation is included automatically. Fix: paste the relevant background into the new chat, or use a Claude.ai Project if this is recurring work.
- Not noticing when a long single chat starts losing early details - this looks like Claude "getting worse" partway through, but it's the context window filling up and crowding out the oldest turns. Fix: briefly restate the essential facts partway through a very long session, or split unrelated sub-topics into separate chats.
- Treating a Claude.ai Project as one unlimited shared memory - a Project persists attached documents and instructions across its chats, but each chat inside it is still bounded by its own context window at generation time. Fix: keep the Project's attached material focused on what's actually needed across sessions, rather than assuming everything will always be in view.
- Expecting Claude to remember you personally across unrelated chats - there's no default cross-chat memory of who you are or what you've discussed before, outside of a shared Project. Fix: don't rely on implicit continuity between separate conversations; restate what's needed.
- Assuming "forgetting" means information was deleted - a new chat's blank context window isn't the result of erasing anything; it simply never had that history to begin with. Fix: think of a new chat as a clean workspace, not a memory that was wiped.
Alternatives
| Alternative | Use When | Don't Use When |
|---|---|---|
| Stay in one long-running chat | The task is genuinely continuous and connected (drafting, iterating, refining one thing) | The chat has grown so long that early details are getting crowded out - split it instead |
| Start a new chat per topic | Each task is distinct and doesn't need shared history | You need Claude to build on something from an earlier, related conversation |
| Use a Claude.ai Project | You return to the same body of material or instructions across multiple sessions over time | The work is a one-off task that won't be revisited |
| Manually paste prior context into a new chat | You need one specific piece of earlier context in an otherwise fresh conversation | The amount of context needed is large enough that it would be more efficient to just continue the original chat |
FAQs
Does Claude remember me from chat to chat?
Not by default. Each new, separate chat starts with an empty context window, so there's no automatic memory of who you are or what you discussed in a previous conversation, outside of a shared Claude.ai Project.
Why can Claude follow up correctly within the same chat but not in a new one?
Within the same chat, the full prior history is re-read as part of generating each new reply. A new chat's context window starts empty, so there's no history for Claude to reference yet.
Is Claude actively storing my conversation somewhere it can recall later?
Within a session, "memory" is really the ongoing conversation history being re-read on every turn, not a separate stored memory Claude consults - that's why it disappears the moment you start a genuinely new chat.
Can a very long chat still lose track of things, even without switching chats?
Yes. As a session grows, its full history competes for space inside a fixed context window, and the oldest turns are the first to be crowded out once that budget fills up.
What's the one way to share context across separate chats?
Claude.ai Projects let you attach documents and instructions that persist and are available across multiple chats within that project.
Do Projects give Claude one combined unlimited memory across all its chats?
No. Attached project material persists across chats, but each individual chat is still bounded by its own context window when Claude generates a reply - it isn't one merged, unlimited history.
If I edit an earlier message in a chat, does that change what Claude remembers?
Yes. Editing or regenerating a turn effectively updates that part of the history, and anything Claude generates afterward is based on the updated version, not the original.
Is there a way to make Claude remember something across every future chat?
Outside of a Claude.ai Project's shared documents and instructions, there is no default mechanism for carrying specific information into unrelated future chats automatically.
Does session memory depend on which Claude model I'm using?
The mechanism is the same across models - full history re-read each turn - but the size of the context window differs by model, which affects how much history a session can hold before older turns are crowded out.
What should I do if I need Claude to recall something from an earlier, separate chat?
Copy or restate the relevant information into the new chat - once it's part of that chat's context window, Claude can work with it the same way it would with anything else in the current conversation.
Is losing early details in a long chat the same thing as "forgetting" between chats?
They have the same root cause - a full context window - but they look different in practice: within a session, it's gradual crowding-out of old turns; between sessions, it's a completely empty window from the start.
Related
- How a Claude Conversation Actually Works - the underlying pipeline that session memory is built on.
- Context Windows: Why Claude Has a Memory Limit - a closer look at the token budget behind this behavior.
- System Prompts vs User and Assistant Turns - how the labeled turns that make up session history work.
- Context, Tokens & Conversations Best Practices - habits for managing long sessions and multi-chat work.
Stack versions: Written against the Claude model lineup current as of ~June 2026 - Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5 (the default), and Claude Haiku 4.5. Model names, pricing, and product features move quickly - verify current specifics at platform.claude.com/docs before relying on them.