Your Claude Forgets Everything. Anthropic's Fix? Let It Dream.

You spend ten minutes telling Claude how your project works. You close the chat. The next day you open a new one, and it asks you the same questions again.

I used to think this was just how AI works. Then I watched a talk by Lamis, a member of technical staff on Anthropic's applied AI team, at AI DevCon. She explained why this happens and how Anthropic fixes it for agents running in production.

This post is my plain English version of her talk. All the ideas are hers. I only simplified them and added how I plan to use them every day. Watch the full talk here:

The honest disclaimer: The results she mentions (better accuracy, lower cost) come from Anthropic's own production systems. I have not measured them myself, so treat the numbers as her claims, not mine.

1. Why a smart model still forgets

A new model is smarter, but it does not know your codebase, your team, or how you like things done. That knowledge is called context. Better models do not replace it. Good context multiplies whatever intelligence the model already has.

And without memory, your agent never gets better at a task the second time. It makes the same mistake again, because every new chat starts empty.

2. How memory grew up in one year

Anthropic's rule through all of this is: do the simple thing that works. Here is the path they took:

• CLAUDE.md files. A plain markdown file with your instructions, loaded at the start of every session. Shockingly effective. The problem: if the file grows too long, it clogs the context.
• Memory tools. Let the agent decide by itself when to read, write and update its own notes during a session.
• Skills. Think of a bookshelf. The agent only reads the title (a few lines at the top) and opens the full book when it needs it. You get deep detail without filling the context. Her example: someone speaks French to you, you notice you own a French dictionary, you pull it off the shelf.
• Memory as a file system. This is what Anthropic now calls best practice. Store memory as markdown files in folders, and let the agent search them with normal tools like bash and grep. Let memories grow big, give the agent a way to search them, and let it write to them on its own.

3. What breaks when you scale up

One agent with a notes file works great. A whole fleet of agents does not, unless you add guardrails. Her examples:

• Two agents writing to the same memory file at the same time.
• One agent writes something wrong into the shared, company-wide notes, and every other agent now believes it.
• Humans and agents both editing memory, and nobody knows who changed what.
• Old notes going stale, or someone sneaking a bad instruction in on purpose (prompt injection).

4. The four guardrails

• Versioning. Keep every version, so you can roll back. Also record which session and which agent or human made the change.
• Concurrency. Before an agent edits a memory, it takes a fingerprint (a hash). Before saving, it checks again. If the fingerprint changed, someone else edited it, so the agent re-reads and tries again.
• Permissions. Company-wide knowledge is read only. An agent's own scratchpad is read and write.
• Portability. Your curated memory is valuable, so keep it in a format and behind an API you can use across tools.

5. The big idea: dreaming

Here is the part I found most interesting. While an agent works, it only sees its own chat. It cannot notice a pattern across many chats. It also has to split its energy between doing your task and taking notes for the future.

So Anthropic added a second process called dreaming. It runs in the background, in a batch, with its own budget. It reads many past session transcripts (including the tool calls, not only the messages), compares them with the memory store, and proposes changes.

Her school example makes it easy. A head teacher marks everyone's exams and notices every student got the same geography question wrong. The topic is missing from the lesson plan, so the teacher adds it. Or everyone answered in radians instead of degrees. The calculator setting is wrong, so the teacher fixes the instructions. For agents, that is the same as spotting a tool that keeps failing, or a company-wide habit you do not like.

The output is a list of proposed changes, with example transcripts and how common the problem is. A human then accepts or rejects each one.

6. What you can do today

If you use Claude every day:

• Keep a short markdown file of your preferences and paste it at the start of important chats.
• Turn repeated workflows into Skills.
• Once a week, review what Claude got wrong and update your notes. That is dreaming, done by hand.

If you build with Claude Code or agents:

• Start with CLAUDE.md and skills. Do not over-engineer.
• Store memory as plain markdown in a folder, one topic per file, with an index file.
• Add versioning and permissions before you run many agents together.
• Add a review step that cleans out stale notes and adds what is missing.

If you want a ready made version, she pointed to Anthropic's memory and dreaming API in Claude Managed Agents, which has versioning and hashing built in.

The 60 second version

• Models forget. Memory fixes that.
• Markdown files plus search beat fancy tools.
• Let agents write notes, but guard them with versions, checks and permissions.
• Then add a background review (dreaming) to keep memory clean and correct.

It is still early and she said so herself: this is an open area of research. But the simple parts work today, and you can start this afternoon.

Set it up in 2 minutes (free)

I did not want this to stay as theory, so I turned her ideas into a small open source kit. It has two skills, a starter memory folder, and a safety script that adds the versioning, the conflict check and the permissions she talked about. No servers, no database, no API keys.

Repo: https://github.com/Emmanuellsensai/claude-memory-kit

Step 1. Install it (Claude Code). On Windows PowerShell:

git clone https://github.com/Emmanuellsensai/claude-memory-kit.git
cd claude-memory-kit
.\install.ps1 -AppendClaudeMd

On Mac, Linux or Git Bash:

git clone https://github.com/Emmanuellsensai/claude-memory-kit.git
cd claude-memory-kit
./install.sh --claude-md

That copies the skills into your Claude folder, creates a memory folder, and adds a short note to your CLAUDE.md so Claude follows the memory habit on every task.

Step 2. Check it works. Open a new Claude Code session and ask: "What does your memory-keeper skill do?"

Step 3. Teach it something. Say: "Remember that I like short answers with the result first." Claude should save a note and tell you in one line. You can see the note in the memory folder.

Step 4. Dream once a week. Just say "dream". Claude reads your last week of sessions, finds the mistakes that keep repeating, and writes proposals. You accept or reject each one. Nothing changes without you.

No terminal? The repo has a claude.ai route in docs/SETUP.md that uses Skills and a Project.

The honest part: this kit is a community project built from her talk. It is not an official Anthropic tool, and I have not measured the accuracy or cost gains myself. Use it as a good starting point, then adjust the notes to fit how you work.

All credit goes to Lamis and the Anthropic team for sharing this. If this helped you, drop a comment with how you handle memory in your own Claude setup, and share it with someone who keeps re-explaining things to their AI. Follow me for more practical developer and AI workflow tips.

Cover photo by Growtika on Unsplash.