How to Make Claude Remember Previous Chats (and the Decisions You Made in Them)

By Branislav Koist · Updated

To make Claude remember previous chats, turn on memory and chat search, but don't rely on them for decisions. Memory holds what Claude chooses to note, and Anthropic says Cowork sessions that run locally on your computer don't use it. Decisions you need to keep belong in plain files that every new conversation reads first.

Below: what Anthropic's documentation says Claude remembers (checked on 10 October 2026), where that memory stops, and the habits that carry decisions from one conversation to the next.

Does Claude remember previous chats? What the docs say

On its own, a new conversation starts empty. Claude Code's documentation says it directly: each session begins with a fresh context window. Anthropic's Help Center calls chat without memory a "stateless chat interface". Anthropic offers three ways to carry something across:

  • Chat search. On paid plans (Pro, Max, Team and Enterprise), you can ask Claude to search your earlier conversations, for example to continue where you left off. Claude searches all chats outside projects; inside a project, it searches only that project's chats.
  • Memory. Claude can remember context from your chats and carry it into new conversations. According to the Help Center, it saves memory as separate topics while you chat, on its own, and you can also ask it to remember something. Memory is on by default on the Free, Pro and Max plans. On Team and Enterprise plans, the organization's owners decide whether it's available. You can read, edit or delete every topic in Settings > Memory.
  • Projects. Each project in Claude has its own memory space and project summary, kept separate from your other chats. Cowork projects work in a similar way: the Cowork documentation describes a project memory store that persists across sessions.

Menu and setting names were checked on 10 October 2026. The Claude desktop app changes them from time to time, so if you can't find a setting, search for it by name.

Claude Code has two layers of its own: CLAUDE.md files that you write, and auto memory, which is notes Claude writes for itself based on your corrections and preferences. Both load at the start of every session.

Where Claude's memory stops

The same documentation shows why memory can't be the only home for your decisions.

1. Claude decides what to save

Memory is written by Claude, not by you. Claude Code's documentation says Claude doesn't save something every session; it decides what is worth remembering. The Help Center lists what chat memory focuses on: your role, your projects, the people in your work, your preferences and your ongoing work. That is useful context about you. It is not a record of what you and Claude agreed on last Tuesday, in your own words.

2. Local Cowork sessions don't use it

The Help Center says memory is shared between chat and Cowork only when Cowork runs in the cloud. Cowork sessions that run locally on your computer don't use memory. The Cowork help article says the same from the other side: in sessions in the cloud, Claude starts from what it already remembers from your chats. If your Cowork tasks run on your own computer, memory from your chats doesn't reach them.

3. Claude Code's memory has a size limit and stays on one computer

At the start of a session, Claude Code loads the auto memory index only up to its first 200 lines or 25KB, whichever comes first. Whatever is beyond that isn't loaded at the start. Auto memory is also machine-local: the files aren't shared across machines or cloud environments.

4. Long conversations forget too

Even inside one conversation, space is limited. Anthropic's best-practices page says performance degrades as the context window fills, and Claude may start "forgetting" earlier instructions. When Claude Code compacts a long conversation, it re-reads the project's CLAUDE.md from disk, but an instruction you only gave in the chat can disappear. The documentation's advice: add such instructions to CLAUDE.md so they persist.

Why decisions belong in files

That last point holds the key: what survives is what is written in a file on disk and loaded again. So the reliable way to make Claude remember previous chats is this: the decision lives in a plain file you can open, read and correct, and every new conversation reads that file before it starts working.

A file gives you three things memory doesn't. You can see exactly what it says. It holds what was decided, not what Claude thought was worth keeping. And it doesn't depend on a memory setting or on where the session runs.

One caution. A file only helps once Claude reads it. Claude Code loads CLAUDE.md at the start of every session. In Cowork, the pages we checked don't promise that a folder's CLAUDE.md loads by itself, which is why our guide to Cowork instructions vs. CLAUDE.md suggests asking Claude to confirm which rules it loaded.

Four habits that carry decisions from one chat to the next

None of these needs code. They are habits you ask Claude to keep, written into your standing instructions.

  1. Write decisions down when they happen. Not at the end of the conversation. A conversation can end before you planned: a long one gets compacted, or a window gets closed. A decision written down the moment it's made is already safe.
  2. Give each project one place for its current state. One file that says where the work stands, what was decided and what comes next. A new conversation should have to read one file, not search through ten.
  3. End every conversation with a hand-off. Before you close a conversation, have Claude update the state file and prepare a short opening message for the next one. You paste it into the new chat, or the new chat finds it on disk.
  4. Start every conversation by reading, and ask for a receipt. The first thing a new conversation should do is read the state file, and its first reply should say which file it read and how current it is. If that line is missing, stop before any work starts. Noticing a missing line takes seconds, while work built on a forgotten decision may have to be redone.

What happened in our testing

We build a rules system for Claude Cowork and Claude Code that works this way, so we test the hand-off between conversations. Here is one case from 8 October 2026: Cowork in the Claude desktop app on a Windows PC, in a test folder with no client data in it.

  • At the end of the first Cowork task, we gave the wrap-up command. The AI updated the project's state file and wrote a hand-off file whose first line said how current it was.
  • Then we started a new task and typed only a short command naming the topic. No pasted context, no summary. The AI first read the rules file to find out what the command meant. Then it picked up the topic from disk, did the one task that was waiting there, saved the result to a file and marked the task as done.

The hand-off worked because it lived on disk, not in chat memory.

The same test also showed two gaps. Our rules say the hand-off file should be started with the first logged change, not only at the end. In all five chances in that test, the AI skipped this step, and the file appeared only at the wrap-up. And a new task that started with a plain greeting didn't load the rules at all until we asked. Files make memory possible. They don't make it automatic, which is why the first reply has to show what was read.

What this won't do

A file doesn't force Claude to read it or to follow it. Claude Code's documentation says Claude treats CLAUDE.md and auto memory as context, not enforced configuration. So files are half the answer. The other half is a check that shows you whether the files were read and updated. More on that in why Claude ignores your CLAUDE.md and how to check when your AI says "done".

Claims Need Receipts sets this up in Claude Cowork and Claude Code for people who aren't programmers. In every conversation, the AI writes decisions and where the work stands into plain files on your computer as it goes, and prepares an opening message for the next conversation. Guard scripts print a warning where a receipt is missing, such as a change without a log entry or a hand-off without a trace.

FAQ

Does Claude remember previous chats?

Partly. On paid plans you can ask Claude to search your past chats, and its memory can carry context into new conversations: your role, your projects and your preferences. You can review that memory in Settings > Memory. For exact decisions, keep a plain file that every new conversation reads first.

Why does Claude forget everything between chats?

Every new session starts with a fresh context window. Only what is loaded at the start carries over: your instructions, memory, and files Claude reads. Memory keeps what Claude decides to note, and long conversations can lose earlier instructions. Write decisions into a file that loads every time, and ask Claude to confirm it read it.

Does Claude Cowork have memory?

Yes, with limits. According to Anthropic's Help Center, memory is shared between chat and Cowork only when Cowork runs in the cloud; Cowork sessions that run locally on your computer don't use it. Cowork projects also have their own memory. Decisions that must survive belong in files in the project folder.

What is a guard script, and do I need to write one?

No. A guard script is a small program that checks files on your disk (a date, a number, a log entry) and prints a warning when a receipt is missing. In Claims Need Receipts you don't write or edit any of them: your AI reads the guide, asks you seven questions, shows what it will add and installs everything only after you say yes. The one requirement is Python 3.10 or newer on your computer; if it's missing, your AI walks you through installing it.

Sources

All accessed 10 October 2026.

Last updated: 10 October 2026

Claude is a trademark of Anthropic. Claims Need Receipts is an independent product and is not affiliated with, endorsed or sponsored by Anthropic.