Amnesiac intelligence: AI is learning to sleep

Last year I went down a rabbit hole on AI memory. It looked like the biggest thing stopping AI from becoming proactive. This led to weeks of reading things like Stanford's generative agents, Letta's work on agents that remember, and a lot of neuroscience about what the brain does with our memories while we sleep. I wrote it all up into a long piece but left it in my drafts.

The idea was pretty simple. We'd given AI the world's knowledge, but no memory of doing anything with it. Models knew a lot about the world and remembered almost nothing about what they themselves had done.

What we know of the brain gave me the framing. So I argued AI would need what we have. A way to sleep, dream and forget.

On 6 November, Anthropic published The components of agent memory. It uses the same brain comparison, and it calls the process of Claude going back over its work between sessions dreaming.

Reading it was a bit like getting my unpublished homework marked a year late. Some of it held up, while some of it didn't.

Sleep: a wrong note and the same ledge, three times

Anthropic uses Pokémon Red to test how its agents cope with long tasks. Claude wrote itself a note putting the Pokémon Center at Mt. Moon’s entrance on the wrong side of the mountain. In the run with that note, it got lost, fell off the same ledge three times and never made it to the next city.

Before the comparison run, Anthropic had Claude check the note against the session transcript. Claude caught the mistake and fixed it. With the corrected note, Claude went back into Mt. Moon and eventually reached Cerulean City.

The thing is, Claude already had memory and remembering was part of the problem. It wrote down something wrong and kept trusting it. One corrected note changed what it did next.

Most of my draft worried about the need for AI to forget. This was AI remembering the wrong thing.

That's where the sleep comparison earns its place. During sleep, the brain can replay parts of the day. Between sessions, Claude can go back through its logs and check what it wrote down.

The problem I started with

Andrej Karpathy has compared LLMs to the main character in Memento, a man who can't form new memories and gets through each day using notes. The model by itself doesn't even have the notes. Karpathy’s original post

Most AI tools got around this in one of two ways, and plenty still do.

The first is the context window: how much text a model can hold in its head during one conversation. Think of a whiteboard that keeps getting bigger. A new session starts with a fresh board unless the app brings something forward.

The second is retrieval, often called RAG, where the model searches your documents, old chats or saved notes when it needs them. That can bring back what happened last week but retrieval on its own doesn't decide which lessons are worth keeping, or notice when an old note is wrong.

That's why we all got used to re-explaining our projects in every new chat... and why agents that run for hours keep making the same mistakes.

What changed in the apps

To be fair, the apps have moved a lot since my draft. OpenAI has been rebuilding ChatGPT's memory around a background process it also calls dreaming, from an early version in April 2025 to a much bigger rebuild this June. Claude's memory reached paid plans in autumn 2025 and free users in March. Since July it updates as you chat, and since August it’s shared between chat and Cowork sessions that run in the cloud.

That's mostly about remembering you… your preferences, your projects, the trip you mentioned last month. Anthropic's new post is about a different job. Agents remembering their work, and fixing what they got wrong.

How Anthropic's version works

Claude learns from experience by keeping notes it can read next time. The model’s weights stay fixed.

There are 4 layers. I find it easiest to think of them like this:

1. The diary: a full record of everything that happened in each session.
2. The notebook: notes Claude chose to write down while working.
3. The wiki: linked pages that pull together what Claude finds in notes and other sources.
4. The cheat sheet: a short list of essentials.

In this setup, the cheat sheet loads automatically at the start of every session, so every line takes up some of the model’s working space. Claude opens or searches the rest when it needs to.

Dreaming runs between sessions. It reads back through the diary, checks the notebook against what actually happened, fixes mistakes, updates the wiki and decides what deserves a place on the cheat sheet. In my old framing, it does all three jobs: sleep, dream and forget.

It is worth noting businesses building agents on Anthropic's platform have had memory since April and dreaming as a research preview since May.

Forget: the hoarder lost

My draft argued that remembering everything is its own problem as human memory lets the boring stuff fade so the important stuff stands out.

Claude Sonnet 3.7 saved almost everything: a file for every battle, every item and every character it met. 413 files across 225 folders. Some of it, like where it was on the map, was already on the screen every turn. Late in the run, it spent 17 steps shuffling files around without playing the game at all. It earned one badge.

Claude Fable 5 kept 10 files, built around a single page of current goals, and earned four badges. Opus 5.5 kept a small folder tracking what it was doing next, and finished the game.

These were single runs of different models, so we can’t tell how much the smaller archive contributed to the better run. What we can see is that the model with the biggest archive spent part of its run maintaining it.

Dream: joining the dots

My draft spent a lot of time on knowledge graphs, so an AI could connect facts spread across lots of documents. Anthropic's answer is simpler. Claude builds itself a wiki: plain pages that link to each other and get updated over time.

They tested it on 25 questions about a company's internal documents, around 350,000 files. Search on its own met 53% of the marking criteria. The wiki on its own met 48%. Both together met 61%, and used fewer tokens per question than search alone. The wiki took 128 dreaming sessions to build, and the per-question saving excludes that work.

The wiki didn't replace looking things up. A well-kept summary worked best when the agent could still check the source. Which is pretty much how good notes work for us too.

The surprise: memory only works if the model knows how to use it

On a database task in Anthropic’s benchmark, Sonnet 5 roughly doubled its score when it had memory. It checked its notes before answering nine times out of ten without being told to. Sonnet 4.6 barely improved, and checked its notes less than half the time.

Having notes is one thing. Knowing what to write down and when to read it back is a skill in itself.

Guidance helps too. When Anthropic told Sonnet 4.6 to read its notes first and test its guesses, its score went from 0.36 with memory alone to 0.64.

The details of that guidance matter. Telling Opus 5 and Opus 4.7 to record only failures cut into the gains they got from memory. What helped these models was telling them what the memory was for and letting them work out the rest. Pretty similar to managing people, to be honest.

Why I underestimated readable notes

My draft already had agents writing notes and reflecting on them. Where I went wrong was how far I thought that could go.

I assumed notes were a stopgap, and that real learning would mean changing the model's weights: the billions of numbers that hold everything it learned in training. My version had a fast memory for the day, then an overnight update that trained the important stuff into the model, much like the brain does while we sleep.

Anthropic's agents keep their memory in text files, and the model never changes. That gets a lot further than I expected.

Three reasons stand out to me.

1. You can see what it got wrong. A note can be opened, checked and fixed, like the Mt. Moon one. A change to model weights gives you no sentence to inspect or correct. Claude Managed Agents logs changes to its memory stores and lets developers roll back to an earlier version. Managed Agents memory
2. The notes carry over. When a new model comes out, you can give it the same files. Whatever you've trained into one model doesn't come with you when you switch. Training a separate version for each user is possible, but it's expensive and fiddly to keep up to date. Letta on continual learning
3. Training facts in can make earlier facts harder to use. In one study, researchers trained a small open model, Qwen3-4B, on 20 invented facts one after another. With varied training examples, the model got 46% of questions about the earlier facts right after learning the final one. Even where the model stopped answering correctly, the researchers could still detect traces of earlier facts in its output probabilities. A narrow test, but it shows how learning new things can bury old ones. Continual learning study

So for memory that has to stay current, checkable and easy to move to the next model, I'd start with readable notes. Probs every time.

It isn't free. Notes take up room in the model's working memory, which costs context, money and can blunt its focus. And they're good for facts and rules, less good at the kind of instinct that comes from practice.

That's why I don't think the weights idea is dead. Letta also expects memories to eventually get trained into models for efficiency, and a position paper out this year argues for that mix: quick notes first, then occasional sleep-like consolidation into the model. Roughly what my draft described, just as a later step.

Readable notes first. Training later, maybe, for the things that really stick.

The catch

None of this is settled.

Most of the agent numbers come from Anthropic's own tests, with small question sets and single Pokémon runs. Dreaming costs compute. And because the cheat sheet loads into every session, a wrong note there keeps causing damage until something catches it.

OpenAI describes improvements in its own evaluations of ChatGPT’s memory. Its announcement gives examples and describes the direction of change.

Anthropic is open about what it hasn't worked out yet: when memories should be written, how to keep them up to date, and how often an agent should dream.

Try it: a memory review you sign off

If you've vibe coded anything, you've probably seen a small version of this. Most coding agents read a rules file at the start of every session, basically their cheat sheet. Change your mind halfway through a project and the code changes, but the rules file often doesn't. Next session, the agent reads the old rule and confidently puts things back the way they were. Nothing's lost. The note it trusts has just gone stale.

Every time I have to remind an agent what's current, I'm still doing part of its job. That's why memory matters more to me than bigger context windows.

You don't need Anthropic's platform to borrow the idea. If your agent keeps logs and notes, you can run your own version of dreaming with one prompt.

Here's the one I'd start with:

You're reviewing an AI agent's memory against its recent work. Use only the evidence I give you. Don't guess.

What I'm giving you
- Recent session logs (what actually happened): [paste them, or give the file path]
- The agent's memory notes: [paste them, or give the file path]
- Its rules file, the one it reads at the start of every session: [e.g. CLAUDE.md or your Cursor rules]
- What this memory is for: [one sentence, e.g. "help the agent work on this app without repeating past mistakes"]

What to do
1. Read the logs first, then every note and rule they relate to.
2. Give each of those notes and rules a status: correct, wrong, out of date, duplicate or unproven.
3. Back every proposed change with evidence: quote the log, give its date and say which old note it replaces. Logs contain the agent's guesses too, so separate what actually happened from what it assumed.
4. If I corrected something myself, propose the update straight away. If the agent worked something out on its own, mark it unproven until the logs back it up.
5. If two things contradict each other and the logs don't settle it, ask me. Don't pick one quietly.
6. Keep the rules file short: current goals, hard rules and known traps. Move everything else into the notes.

What to give me back
- A list of proposed changes, each with the note, its status, the change and the evidence.
- The updated rules file in full, so I can compare it with the current one.
- Any questions you need me to answer.

Don't change anything until I approve. Then make only the changes I approve, and never delete the logs.

How to use it:

1. Fill in the four lines in brackets. In a coding agent like Claude Code or Cursor, give it the file paths and it'll read them itself. In a normal chat, paste everything in.
2. Only include sessions since your last review. Going back over everything every time wastes time and money.
3. Read the change list properly. Approve what's right and push back on what isn't.
4. Once you trust the results, run it regularly. Weekly, or after a big session, is plenty for most projects.
5. A week later, check: is the agent repeating fewer mistakes? If not, sharpen the line about what the memory is for.

Why memory is the big one

Better models make each conversation smarter. Memory is what makes the conversations add up.

But Mt. Moon is the warning. Memory on its own isn't enough. A wrong note just sends you off the same ledge again and again. The difference comes from going back over it: checking what was written down, fixing what's wrong and clearing out what's gone stale.

The test for me: am I spending less time correcting the same things? If the notes keep getting better, every session starts a bit further ahead. And if those notes live in files I control, they come with me to the next model.

Research note. This article covers announcements and research published through 7 November 2026. The agent memory results reported here come from Anthropic’s own evaluations.