Anthropic's 'Dreaming' Primitive: Async Memory Consolidation, Explained
Anthropic's Dreaming primitive consolidates agent memory asynchronously between sessions. Here's how that differs mechanically from synchronous, per-query relevance scoring like Feather DB's adaptive decay.
Anthropic added persistent memory to Claude Managed Agents in public beta on April 23, 2026, giving agents a filesystem mounted at /mnt/memory/ inside the container — memories stored as files, exportable and editable via API or the Claude Console (EdTech Innovation Hub, Anthropic). Roughly two weeks later, on May 6, 2026, Anthropic shipped a companion primitive called Dreaming — an asynchronous process that runs between agent sessions, not during them, reviewing and rewriting what's stored in that memory filesystem (OpenTools). Here's what Dreaming actually does mechanically, why consolidation is a distinct problem from storage or retrieval, and how it compares conceptually to synchronous scoring approaches like Feather DB's adaptive decay.
What Dreaming actually does
Dreaming is not a retrieval mechanism. It doesn't run when an agent answers a live request, and it doesn't change how memories are fetched mid-session. Based on Anthropic's description, it's a scheduled, offline pass that runs in the gap between sessions: it reads session transcripts and the current contents of /mnt/memory/, then performs three kinds of work on that store. First, pattern extraction — pulling recurring structure out of raw transcript history into reusable memory entries. Second, deduplication — merging memory files that say the same thing in different words, which accumulate naturally when an agent writes a new memory file every session instead of checking whether one already exists. Third, surfacing new insights — connections across sessions that weren't visible from within any single session's context window.
The important detail is timing. Dreaming runs asynchronously, between sessions. During a live session, the agent reads whatever state the last Dreaming pass left behind — it does not trigger consolidation itself. That makes Dreaming closer to a batch ETL job over an agent's memory files than a real-time feature of the request path.
Consolidation is a different problem than storage or retrieval
It's worth being precise about why this is a separate primitive at all, rather than a config flag on the memory filesystem. Storage answers "where does this fact live." Retrieval answers "which facts are relevant to this query, right now." Consolidation answers a third question: "is what's stored still true, still non-redundant, and still worth keeping?"
A memory store that only ever appends — write new memory, never revisit old memory — degrades in a specific and predictable way. Duplicate entries pile up because nothing checks for prior art before writing. Contradictions accumulate because an early session's conclusion and a later session's revised conclusion both persist as equally-weighted facts. Signal-to-noise drops because low-value observations sit alongside high-value ones with no mechanism to tell them apart after the fact. None of this is a retrieval bug — a perfect retrieval system will happily surface a stale, duplicated, or contradicted memory with full confidence, because retrieval only reasons about relevance to the query, not about the internal consistency of the store. Consolidation is the missing step that keeps the store itself coherent over time, independent of any particular query.
Async rewriting vs. synchronous decay scoring
Dreaming solves consolidation by editing the store directly, between sessions. There's a conceptually related but mechanically different approach: score relevance continuously, on every read, without ever touching the underlying store. Feather DB's adaptive decay works this way. Each memory has a stickiness value computed as 1 + log(1 + recall_count), and at query time that stickiness is combined with a time-based decay term (30-day half-life by default, 0.3 default time-weight) to adjust how strongly a given memory scores against a query. This runs synchronously as part of every search call — not as a separate offline job — so relevance drift is handled per-query, in real time, without a scheduled pass and without rewriting any files.
These are answers to overlapping but not identical questions. Decay scoring asks: given everything that's stored, how relevant is each entry right now? It never merges two records, never rewrites a contradiction, never deletes a duplicate — it just weights old, rarely-recalled entries lower at read time. Dreaming asks a structurally different question: should the store itself look different than it currently does? It can merge two memory files that describe the same customer preference in different phrasing. A pure scoring function, by construction, cannot — it operates over whatever records exist, it doesn't rewrite them.
The tradeoff: deeper restructuring vs. a consolidation-lag window
The capability difference maps directly to a cost difference. Because Dreaming does real editing — pattern extraction, deduplication, merging — it can do things a scoring function structurally cannot: collapse redundant entries into one, rewrite a stale conclusion once a later session supersedes it, or generate a new synthesized memory that didn't exist as a discrete entry in any single transcript. That's deeper restructuring than adjusting a weight.
The cost is a latency window. Between the moment new information enters the memory store and the next scheduled Dreaming pass, that information sits unconsolidated — duplicates and contradictions can exist un-merged for the length of that window, and any session that runs during it inherits whatever inconsistency accumulated since the last pass. A continuous, per-query mechanism doesn't have this window by construction, because there's no separate pass to wait for — every read incorporates the current recall count and elapsed time at the moment of the query. What it gives up in exchange is the restructuring capability: it can down-weight a stale memory, but it can't merge it with its duplicate or rewrite it into something more accurate. In practice these are complementary mechanisms aimed at adjacent problems — one keeps the store itself clean on a schedule, the other keeps per-query relevance current continuously — rather than substitutes for each other.
Early results, with a scoping caveat
Anthropic cites early adopters including Netflix, Rakuten, Wisedocs, and Ando, reporting a 97% reduction in first-pass errors and a 30% speed increase in document verification workflows (source). Those numbers are specific to document-verification use cases at those organizations — they describe a workflow where consolidated memory of prior document formats and correction patterns compounds directly into fewer repeated errors. They shouldn't be read as a general benchmark for what Dreaming, or async consolidation more broadly, delivers across arbitrary agent workloads. Different workflows have different tolerance for the consolidation-lag window described above, and different rates of memory growth that determine how much deduplication work there is to do in the first place.
FAQ
Is Dreaming a vector database or a replacement for one?
No. Dreaming operates on Anthropic's memory filesystem — memory files mounted at /mnt/memory/ inside a Claude Managed Agents container. It's a consolidation process over that store, not a storage or indexing layer itself.
Does Dreaming run during a live agent request?
No. It runs asynchronously between sessions. A live session reads whatever the most recent Dreaming pass left in the memory store; it doesn't trigger or wait for consolidation itself.
How is this different from Feather DB's adaptive decay?
Decay is a synchronous scoring function evaluated on every search — it adjusts relevance weight using recall count and elapsed time but never edits the underlying records. Dreaming is an asynchronous editing pass that can merge, deduplicate, and rewrite memory files, but only at scheduled intervals between sessions rather than continuously.
Can you use both approaches together?
Conceptually, yes — they address adjacent problems. A scheduled consolidation pass keeps a store's contents clean and non-redundant, while a continuous per-query scoring function keeps relevance current without waiting for the next scheduled run. Nothing about either mechanism is architecturally exclusive of the other.
Feather Core is free and MIT-licensed for self-hosting today via pip install feather-db; if you're curious how continuous decay scoring behaves against your own agent memory, it's worth trying against a real workload.