Anthropic's new Dreaming feature reads session logs offline, finds repeat patterns, and merges duplicate memories into a tighter file
Original session data stays untouched, only the consolidated memory artifact is rewritten
This is not vector search and not fine-tuning, it is a separate offline pass on existing memory entries
Long-running agents and repeated workflows benefit, one-shot agents see almost no gain
Currently in testing alongside Result Loops, Multi-Agent Orchestration, and Webhooks public betas
Anthropic announced Dreaming on May 6 2026 at the SF dev conference. The feature is in testing, not GA. Most of yesterday's coverage labelled it "agent memory consolidation" and moved on. The mechanics are more interesting than the headline gives away, and the practical implications are the part nobody talked about.
What dreaming actually does
Dreaming runs offline. No live request, no user prompt, no tool call. The agent is not awake when it happens. It is a separate pass that reads what the agent wrote down during recent sessions, hunts for patterns, and rewrites the memory file into something tighter.
The job has a few moving parts.
It scans session logs. Every Managed Agent already keeps a transcript of what it did, what it tried, what worked, what failed. Dreaming reads those logs the way you would re-read your own notes on a slow Sunday morning, looking for the bits that keep showing up.
It detects patterns. If the agent asked the same kind of question 14 times across a week, that gets flagged. If five memories describe the same workflow with slightly different wording, they collapse into one canonical entry. If a memory was written once and never referenced again, it gets pruned.
It then rewrites the memory file. Not a summary of the logs. A new version of the file the agent loads on every run, smaller, deduplicated, ranked by what the agent actually used.
The original session data is never altered. That part matters. Logs stay verbatim. Only the derived memory artifact gets touched. If something goes sideways, the source of truth is still there to recover from.
What "duplicates merged" means in practice
This is the part most posts skipped. It sounds obvious until you look at how memory actually accumulates.
A live agent writes memory entries opportunistically. It might save "user prefers TypeScript" on Monday, "user is using TypeScript for this project" on Wednesday, and "switch examples to TypeScript when relevant" on Friday. Same fact, three different outfits. By month two the agent's memory is wearing nine layers.
Dreaming notices the overlap and writes one entry. The new entry usually carries a little extra metadata from the merge, like a confidence weight or a frequency count, so the agent knows this is a stable preference rather than a one-off remark.
It also catches the inverse. If the agent saved "always use 4-space indent" on Monday and "user wants 2-space indent" on Wednesday, the second one wins because it is newer and the user explicitly corrected. The merged entry keeps the corrected version. The stale one gets dropped, not buried under it.
Net effect: the memory file stops growing linearly. Without consolidation a Managed Agent's memory turns into a pile of post-it notes after a few hundred sessions. Dreaming keeps the file in shape so loading it does not eat the context window every time the agent wakes up.
How it differs from vector search, summarization, and fine-tuning
A few approaches already exist for "give the agent memory". Dreaming is none of them.
Vector search keeps everything and retrieves relevant chunks at runtime. The memory grows forever. You pay for it on every query. Recall depends on embedding quality. Dreaming sits before retrieval, rewriting the source set so retrieval has less to do in the first place.
Summarization compresses old conversations into a paragraph the model reads on warm-up. Lossy by design. Specifics get smoothed into bland prose. Dreaming is closer to re-indexing than summarizing. The output is structured memory entries the agent treats as facts, not paragraphs it has to re-parse.
Fine-tuning bakes patterns into model weights. Permanent, expensive, and painful to roll back. If the agent learns the wrong thing, you retrain. Dreaming touches a file, not weights. If the consolidated memory is wrong, you regenerate it from the logs. Reversible, cheap, and per-agent.
The closest human analog I can think of is cleaning your notes app on a quiet Sunday. Same notes, fewer of them, organized so you can find what you actually need on Monday. The agent does this on its own schedule, while you sleep.
For the deeper context on agent memory architectures, see Claude Managed Agents Now Have Filesystem Memory. The memory primitive Dreaming runs on top of was introduced two weeks before this announcement.
When this matters, and when it does not
Dreaming pays off in proportion to how much the agent reuses itself. Run it once, see no benefit. Run it a thousand times, the file stays small.
Long-running agents are the obvious case. A research agent that runs daily for six months piles up thousands of session entries. Without consolidation, every cold start drags more context with it. With Dreaming, the memory file stabilizes after a few cycles and the agent loads in roughly constant time.
Repeated workflows are the next case. If an agent processes the same kind of ticket 200 times, it picks up a workflow shape. Dreaming captures that shape once instead of 200 times. The agent stops re-deriving the obvious on every run, which is the kind of thing you only notice in retrospect when the file size has not doubled in two months.
Multi-agent setups benefit too. The new Multi-Agent Orchestration beta lets a coordinator dispatch up to 20 specialists. Each specialist writes its own memory. Dreaming runs per agent, so the specialists' files stay lean and the coordinator does not get crushed under context spillage from below.
For one-shot agents, it does almost nothing. If the agent runs once and never sees a related task again, there are no patterns to detect and no duplicates to merge. Running Dreaming on that is wasted compute. Anthropic's preview docs note the feature is opt-in for exactly this reason.
It also does not fix bad memory hygiene. If the agent is saving garbage, consolidating that garbage produces tidier garbage. Dreaming is downstream of what the agent decides to remember in the first place. Garbage in, slightly more organized garbage out.
My rough mental threshold: around 50 sessions or 1000 memory entries, whichever comes first. Below that, the file is small enough that a human can eyeball it. Above that, consolidation starts paying for itself.
What to expect in Cowork and Claude Code logs
Once Dreaming ships GA, the surface area in Cowork and Claude Code should be small. That is the point.
In Cowork, expect a new entry in the agent timeline tagged something like "memory consolidation" or "dream cycle". It runs between sessions, never during one. The entry will list how many memories got merged, how many got pruned, and the new total. Click in, you get a diff between the old memory file and the new one. That diff is your audit trail.
Claude Code users running Managed Agents locally will see the same thing in the agent log. Expect a dream: prefixed line, similar to how tool: and compact: already show up. Frequency probably defaults to once per N sessions, configurable from the agent's spec.
Two things to watch for once it lands.
The diff matters more than the metric. A "37 memories merged" line tells you nothing about whether the right ones got merged. The before/after diff tells you whether a useful preference got consolidated away. Read it for the first few cycles, the same way you would read commit diffs from a junior dev until you trust them.
Frequency tuning is where it will get interesting. Too aggressive and the agent forgets useful detail. Too lax and the file bloats. Anthropic will probably ship a sensible default, then expose the knob for power users a release or two later. Plan for that knob to appear, do not engineer around its absence.
If you are running Claude Managed Agents at scale, this is the feature that decides whether your agent is still loading sub-second six months from now. Worth flagging in your eval suite as soon as the API exposes it.
Bottom line
Dreaming is not magic and it is not a memory system. It is a maintenance pass that runs on top of the memory primitive Anthropic shipped two weeks ago. The job is narrow. Read logs, find patterns, merge duplicates, rewrite the memory file, leave the source data alone.
For long-running agents and repeated workflows, that maintenance pass is the difference between a memory file that stays useful and one that turns into a junk drawer after 60 days. For one-shot agents, it is a no-op.
The thing I will be watching when this hits beta is the diff, not the metric. The metric tells you something happened. The diff tells you whether the right thing happened.
It ships alongside Result Loops, the 20-way Multi-Agent Orchestration beta, and Webhooks. The full intro is in Claude Managed Agents Just Got Dreams, 20-Way Parallelism, and Self-Checking Loops. For the rest of the agent tooling I have written about, the RAXXO Lab has the Claude Managed Agents cluster.
