AI Agents Learned to Dream This Year. Here Is What That Actually Means.
By M. Mahmood | Strategist & Consultant | mmmahmood.com
TL;DR/Summary
In 2026 the agent memory field split into two layers: agents write memories during a session, then a background process curates the store afterward. Anthropic named its curation feature Dreaming, OpenAI shipped a same-named feature for ChatGPT, and plain files like CLAUDE.md, AGENTS.md, and SKILL.md now carry a surprising share of what agents remember between sessions. The biggest performance numbers still come from vendors themselves, but teams everywhere now treat memory as a system that needs upkeep, not a bigger storage bin.
Writing memory versus cleaning memory
For most of 2025, memory in AI agents meant one job: write things down, find them again later. Every tool in the space, from Mem0 to Zep to the built-in memory in ChatGPT and Claude, chased the same question. What should the agent store, and how do we structure the store for fast retrieval?
In 2026 the field started asking a second question: once an agent piles up thousands of memories, who throws out the duplicates, rewrites the stale entries, and connects the patterns that span sessions?
A Japanese practitioner blog published one of the sharpest comparisons of agent memory systems in August 2026, and it draws this split most clearly. The author separates the problem into two stages. In stage one, the agent captures facts from conversations and tool calls while you work with it. In stage two, a separate process reviews that capture, deletes near-duplicates, swaps outdated entries for current ones, and extracts patterns that no single session could produce. The author bets that within a year no one will discuss "agent memory" as one thing, because teams will design and measure both layers independently.
That is the idea people circulate as "inbound and outbound memory." Precision matters here: those exact terms appear nowhere as a shared standard. The underlying split is what matters, and vendors and research groups keep rebuilding it independently.
Anthropic named the second layer, and the name stuck. At its Code with Claude conference on May 6, 2026, Anthropic announced Dreaming, a Research Preview for managed agents where a scheduled background process reads past sessions and the memory store, then removes duplicates, replaces outdated entries, and surfaces cross-session lessons. Anthropic borrowed the name from REM sleep, the phase researchers credit with deciding which of a day's experiences survive, get compressed, or get discarded. OpenAI picked the same word: its Dreaming memory feature curates ChatGPT memories in the background using full chat history, rather than waiting for you to say "remember this." Two competitors adopting one metaphor within months tells you the workflow is real, whatever you call it.
The consolidation race now extends past coding assistants into consumer products, where the personal agent war between OpenAI's and Meta's always-on assistants turns on exactly this question: whose memory survives a long weekend and comes back cleaner on Monday.
What Anthropic and OpenAI actually shipped
Coverage of these launches tends to skip the fine print, so here it is. As of July 2026, Anthropic kept Dreaming behind an application process, and it ran on exactly two models, claude-opus-4-7 and claude-sonnet-4-6, according to the August Zenn comparison cited above.
The strongest performance claim comes from Harvey, a legal AI company, which reported finishing tasks at roughly six times its prior rate after adopting Dreaming, as described in this overview of Claude Dreaming's mechanics. The sourcing deserves a caveat: secondary outlets quoted the company, and nobody has audited the figure independently. A sixfold jump from tidying memory would be remarkable, so treat it as a signal worth watching rather than a fact you can bank.
The plainer layer does more daily work. Claude Memory consolidates a conversation into an editable profile every 24 hours, and you can open that profile and rewrite anything in it. Dreaming sits above it. Analyst Ken Huang describes Dreaming as a background database compactor for agent memory: memory carries work across sessions, and the dream pass stops the store itself from going stale.
Where steering files and skill files fit in
The launch features get the press, but a less glamorous mechanism drives more of what agents actually do day to day: instruction files on disk that the agent reads as if they were memory. A steering file functions as permanent policy that an agent enforces on itself, which is why its contents deserve the same scrutiny as agent approval thresholds: every line grants authority to a model, and nobody audits that grant line by line.
Steering files came first. Drop a CLAUDE.md in your project root and Claude Code reads it at the start of every session, alongside a global version at ~/.claude/CLAUDE.md for personal preferences, as this complete guide to agent memory files documents. The open AGENTS.md format does the same job for Codex and most other coding tools, and over 60,000 open-source projects now ship one. Claude Code also writes notes to itself during sessions, covering build commands, debugging patterns, and your preferences, and stores them in a per-project memory directory, capped at the first 200 lines or 25KB, whichever limit hits first, per this analysis of memory file sprawl and token cost.
Skill files work differently, and the difference matters for memory hygiene. A skill is a folder with a SKILL.md file at its entry point: YAML frontmatter declares a name and description, markdown below holds the actual instructions, and the folder can also carry scripts and reference documents, following Anthropic's official skills specification. At startup, the agent reads only the name and description of each skill, roughly 100 tokens apiece, per this technical explainer of how Claude Skills load. When a task matches a description, the agent opens the full SKILL.md, and it pulls in bundled reference files only at the moment instructions call for them. LangChain's documentation states the practical rule directly: memory holds general preferences and learned conventions, while skills package procedural know-how that the agent discovers and reads only when relevant.
This split solves a real cost problem. That XTrace analysis cited above calculates that sixty memory files averaging 800 words each consume roughly 64,000 tokens, or about a third of a 200,000-token context window, before anyone asks the agent a single question. Their fix mirrors the dreaming insight: stop treating memory as text the agent reads, and start treating it as an index the agent queries. Background curation and progressive disclosure argue the same point at two different scales: keep the hot path lean and push everything else behind a lookup.
What the research is already adding
Academic work jumped straight past "review your notes at night." The MemDream paper from University of Technology Sydney, posted to arXiv in September 2026, faults Anthropic's approach for reacting only after work finishes. Instead, three specialized agents (a Dreamer, an Analyst, and a Consolidator, each LoRA-tuned on a Llama-3.1-8B backbone) generate self-test questions that probe the store for knowledge that exists on disk but resists reliable retrieval, then repair the store before a real task can fail. The authors train the repair policy with GRPO reinforcement learning, and they make forgetting reversible: decaying a memory's weight by 0.2 rather than deleting it. The reported gains land at +3.98 average F1 on LoCoMo and +9.1 points on MemoryAgentBench, and the ablation tells the honest story: swap soft decay for hard deletion and average F1 collapses from 55.14 to 41.04. The forgetting mechanism, not the dream cycles, does the heavy lifting. A related push, the MASkills paper on continual skill optimization, applies the same self-improvement logic to skill libraries rather than memory stores, which brings the two halves of this article together.
On the forgetting side, SCM (Sleep-Consolidated Memory), a single-author prototype from April 2026, implements five neuroscience-inspired parts: a seven-item working memory cap, importance tags across four dimensions, slow-sleep consolidation, dream-like random walks between distant concepts, and deliberate value-based forgetting. It posted perfect recall and cut noise concepts by 90.9 percent, but the author states the limits plainly: the benchmark holds only 22 stated facts, the code is not public, and real conversations never arrive that clean. The scheduling idea behind all of this, running consolidation on idle compute between user requests, gives its operators a name: sleep-time compute. Letta builds this in as a background sleep-time agent, and LangChain frames the whole field as continual learning across three layers: model weights, harness, and memory.
Both papers point the same direction as the steering-file work. Memory quality now outweighs memory quantity. Whether you maintain your CLAUDE.md by hand, let an agent curate its own MEMORY.md, or run a dream pass over a vector store, the 2026 consensus reads identically. Write during the session, curate during the quiet hours, and never let the raw store dictate what the agent believes.
0 Comments