Ask Claude, “Do you remember what we discussed before?” and the answer can feel inconsistent.
Sometimes it knows. Sometimes it does not.
Claude Code may carry a build command into tomorrow's session, then appear to forget it when you open another repository. Clone the same repository on another machine, and some of that context disappears again.
The problem is not simply that Claude has “good” or “bad” memory.
Claude does not have one unified memory system. Chat, projects, Claude Code, and applications built with the Claude API use different mechanisms. They store different things, in different places, and stop at different boundaries.
This article maps those mechanisms by asking four questions:
This article reflects the product documentation available on August 4, 2026. Claude's memory experience is currently being migrated, so your plan and settings screen may differ. Check the linked official documentation and the settings shown in your own account.
I also made a 15-slide Japanese overview on Speaker Deck.
“Six containers” is my way of organizing the product. It is not Anthropic's official taxonomy.
| Surface | Mechanism | Who manages it? | Effective boundary |
|---|---|---|---|
| Claude Chat | Memory generated from non-project chats | Claude | Chats outside projects |
| Claude Chat | Project memory | Claude | One specific project |
| Claude Chat | Past chat search | Claude searches when needed | Non-project chats, or one specific project |
| Claude Code | |||
CLAUDE.md , CLAUDE.local.md , and .claude/rules/*.md |
|||
| You | Depends on file location and launch directory | ||
| Claude Code | Auto memory | Claude Code | One repository on one machine by default |
| An app using the Claude API | Memory tool | Claude requests operations; your app executes them | Whatever your application defines |
At a high level, the map looks like this:
Claude Chat Claude Code Your application
chat memory CLAUDE.md Claude API
project memory .claude/rules/ ↓
past chat search auto memory memory tool request
↓
storage you control
There are no arrows between the three columns because memory is not automatically shared across them.
What Claude learned in a normal chat does not automatically become Claude Code's auto memory. A CLAUDE.md
file does not automatically appear in Claude Chat. The API memory tool is not an endpoint for reading the memory attached to your Claude Chat account.
The first distinction is easy to miss: memory and past chat search are separate features.
Memory keeps extracted information that may remain useful across conversations: your role, active work, communication preferences, tools, and technical preferences.
Past chat search does not pre-store a summary of everything. Claude searches the original conversation history when it needs a detail. When this happens, the search appears as a tool call in the conversation.
The practical difference is:
Anthropic documents both behaviors in Use Claude's chat search and memory to build on previous context.
As of this writing, Claude is moving users to an improved memory experience.
Past chat search has a different plan boundary: Anthropic currently lists it for Pro, Max, Team, and Enterprise plans.
This means “memory” and “search” should not be treated as two names for the same feature.
Claude can search:
It does not perform one account-wide search across both sides of that boundary.
These searches therefore fail by design:
Each project also has its own memory space and project summary. Project A does not inherit the memory accumulated outside projects, and Project B does not inherit Project A's memory.
That separation can feel like forgetting. It is also what prevents one client's context from leaking into another client's project.
In the improved memory experience, deleting or expiring the original conversation does not remove memory entries generated from it. You delete those entries from Settings > Memory, or reset memory entirely.
In the legacy experience, deleting a conversation removes it from the synthesized memory. Anthropic says the synthesis is updated within 24 hours.
If you only want to prevent search, you can turn off Search and reference chats in the relevant settings screen without deleting every conversation.
An Incognito Chat:
However, profile information such as custom styles and personal preferences can still be available inside the chat.
The conversation data is also not erased the moment you close the window. Anthropic says incognito chats are retained for 30 days by default. Enterprise organizations can configure a longer retention period, and Team and Enterprise exports include incognito chats.
So the right use case is a conversation you do not want carried into future chats, not “a place where sensitive information can never be retained.”
See Use incognito chats for the current retention and availability details.
Every Claude Code session begins with a fresh context window. Two mechanisms carry knowledge across sessions:
CLAUDE.md
files containing instructions you wroteAnthropic describes both in How Claude remembers your project.
CLAUDE.md
: instructions you control
Use CLAUDE.md
for things you do not want to explain again:
The common locations have different scopes:
| Scope | Location | Typical use |
|---|---|---|
| User | ~/.claude/CLAUDE.md |
|
| Your preferences across all projects | ||
| Project | ||
./CLAUDE.md or ./.claude/CLAUDE.md |
||
| Team-shared project instructions, usually committed to Git | ||
| Local | ./CLAUDE.local.md |
|
| Personal instructions for this project |
CLAUDE.local.md
is intended for personal project-specific instructions, but Git does not magically keep it private. Add it to .gitignore
if you do not want it committed.
These files are context, not hard enforcement. Claude Code concatenates the instructions it discovers. It does not treat a nearer file as a guaranteed override of every earlier instruction. Contradictory rules can therefore produce inconsistent behavior.
.claude/rules/
: split instructions and scope them by path
For a larger project, you can split instructions into arbitrary Markdown files under .claude/rules/
:
.claude/
├── CLAUDE.md
└── rules/
├── testing.md
├── api-design.md
└── frontend/
└── accessibility.md
A rule without paths
front matter applies to the whole project. Add paths
to load it only when Claude works with matching files:
---
paths:
- "src/api/**/*.ts"
---
- Validate input at every endpoint.
- Use the shared error response format.
My rule of thumb is:
CLAUDE.md
;.claude/rules/
for separate topics or path-specific instructions.Auto memory stores things Claude judges useful for future sessions: build commands, debugging findings, architecture notes, code style preferences, and workflow habits.
By default, each repository gets a local directory like this:
~/.claude/projects/<project>/memory/
├── MEMORY.md
├── debugging.md
├── api-conventions.md
└── ...
<project>
is derived from the Git repository. It is not a name you are expected to choose manually.
MEMORY.md
is the entry point. Claude Code loads its first 200 lines or 25 KB, whichever comes first, at the beginning of a conversation. More detailed files such as debugging.md
are read on demand.
The important boundary is the machine:
.gitignore
does not make it team-shared.Run /memory
to inspect or edit the files and toggle auto memory. Everything is plain Markdown.
I use this promotion rule:
CLAUDE.md
or .claude/rules/
;Auto memory is useful as a notebook. It should not become the only copy of knowledge your team depends on.
The Claude API memory tool is another mechanism with a similar name and a very different storage model.
Claude can request file operations such as create, read, update, and delete under a logical /memories
path. Your application executes those operations and returns the result.
The tool operates client-side. Your application decides:
Anthropic does not provide an account-level memory store for your application through this tool. The documentation is explicit: Claude requests the operation, while your infrastructure performs it against storage you control.
See the Memory tool documentation.
The product names will change. These boundaries are more durable.
Chat memory and Claude Code's instruction files and auto memory are separate systems. Context does not cross automatically in either direction.
Project memory and past chat search remain inside one project. Creating a project is also creating a memory boundary.
Claude Code auto memory is machine-local by default. Cloning the repository elsewhere does not bring it along.
What Claude remembers about you in Chat does not currently carry into Cowork. Cowork can maintain separate memory inside Cowork projects, scoped to each project. See Get started with Claude Cowork and Organize your tasks with projects in Claude Cowork.
Memory does not automatically move to another AI service or custom application. Claude's memory import is experimental and requires an explicit import flow. API-based applications must implement their own storage and identity boundaries.
| What should persist? | Put it here |
|---|---|
| Your role, communication style, and general working preferences | Memory generated from non-project Claude Chat |
| Assumptions and decisions for one client or project | A separate Claude project |
| Coding rules the whole team must follow | Repository CLAUDE.md |
| Rules for one directory or file type | |
.claude/rules/*.md with paths |
|
| A local finding Claude Code may reuse | Auto memory |
| A finding needed on another machine or by the team | Promote it from auto memory into a committed file |
| A temporary conversation that should not affect future memory or search | Incognito Chat, while respecting its retention policy |
| Persistent information for users of your own application | The API memory tool plus storage and deletion behavior you implement |
Duplicating the same fact everywhere does not necessarily make the system safer. It creates multiple copies that can become stale or contradictory.
Before repeating the information, ask:
“Does Claude remember?” is usually too broad a question.
The more useful question is:
Which memory system am I using, and where does its boundary stop?
Originally published in Japanese on Zenn: Claudeの「記憶」はどこにある？ チャット・Claude Code・APIの境界を整理する
This English edition was translated and edited with AI assistance from a Japanese article that I carefully reviewed and revised. I remain responsible for the published content.