If you have built agents that run for more than a few turns, you know where things start to break. The session gets longer. The context gets heavier. Compaction kicks in. Summaries get written. Important details get flattened. The agent may still sound coherent, but execution gets worse.

This is one of the most important problems in agent engineering right now. Consistent execution on long, complex tasks. The community has been trying to solve it with projects like mem0. More recently, even actress Milla Jovovich shared a project called MemPalace.

The hard truth is that most current context management is lossy. Long sessions degrade. The agent forgets small but important details. It loses priorities, constraints, names, decisions, and edge cases that mattered earlier in the run. By the end, you often still have a functioning agent, but the execution becomes untrustworthy.

It feels like everyone is converging on the same idea: memory has to work more like human memory. In the most recent releases, OpenClaw introduced a new feature called Dreaming. Anthropic appears to use similar language for parts of its own memory system, based on what we learned from the Claude Code source leak a few weeks ago. I will write about that in more detail in future posts.

OpenClaw’s Dreaming is very interesting. It is not the agent daydreaming in the background. It is a memory consolidation system. It takes recent notes, transcripts, and memory artifacts, then tries to turn the useful parts into better long-term memory.

OpenClaw Dreaming UI

The Dreaming UI in OpenClaw

Compaction solves one problem and creates another#

Context windows are finite. That means every serious agent system needs some way to compress what happened before. Today that usually means compaction, summarization, retrieval, truncation, or some combination of the four. From my own experience using both Anthropic and OpenAI models, once compaction hits, execution gets impacted. Even with Opus 4.6 and its one million token context window, where compaction may not kick in, execution quality still degrades dramatically once you get past roughly 200,000 tokens.

Those techniques help keep a session alive, but they come with a cost. Compression always throws something away. Sometimes it throws away redundancy and noise. That is good. But in long-running agent workflows, it also throws away important little details.

That nuance is often exactly what matters for execution quality on longer tasks.

A short summary can preserve the headline of a conversation while losing the sharp edges that make the work succeed: why a decision was made, what tradeoff was rejected, which stakeholder is sensitive to what, which workaround is acceptable and which one is not, what are the coding guidelines, what is non-negotiable.

You feel this most in long sessions. The first few hours are strong. The afternoon is still usable. By the third or fourth phase of a complex task, the agent starts making smaller mistakes that add up. It repeats work. It forgets instructions. It misses constraints it already knew. It becomes more generic.

This is the real memory problem in agents. Not storage. Retention quality.

What Dreaming is actually doing#

The documentation on the OpenClaw site is very good, but the simplest way to think about Dreaming is this:

  • short-term memory is the recent working set: chats, daily notes, session context, recent artifacts
  • dreaming is the background consolidation pass
  • durable memory is the smaller, higher-quality set of facts and patterns worth keeping

The job of Dreaming is not to keep everything. The job is to decide what deserves to survive.

That means reducing noise, finding lasting facts, avoiding duplicate junk, and promoting the useful parts of recent context into more durable memory.

So the feature has moved from an experimental prototype toward a real memory maintenance system.

That matters because the core problem is not how to save more text. It is how to preserve what matters from many chats without turning memory into a giant pile of useless stuff.

Dreaming is OpenClaw’s answer:

  • keep raw recent material separate
  • periodically review it
  • promote only the durable parts
  • keep a trail of how and why memory was promoted

This is a much better framing than pretending the context window itself is enough. We all know it is not enough. The context window is a working surface. Durable memory is a separate system.

What it is not#

When I am thinking about systems, it is important to be clear about what a system is not. Dreaming is not:

  • random autonomous reflection for its own sake
  • a hidden planner taking action on its own
  • a second chatbot mode
  • a replacement for explicit memory controls

It is much closer to:

  • background summarization
  • memory curation
  • durable fact extraction
  • memory hygiene

A simple example#

Imagine over a few weeks you tell the system things like this:

  • Antonio prefers to fly United
  • Antonio likes aisle seats
  • Arroz, Feijão e Bife is his go to meal
  • Flowers Saratoga was the anniversary dinner place
  • He prefers reminders to be short and direct

At first, those details may live in recent chat history, daily notes, short-term recall, or session transcripts.

Dreaming reviews that material and asks a more useful set of questions:

  • is this a durable fact or just temporary noise?
  • has it shown up more than once?
  • is this a preference, biography, workflow pattern, or project context?
  • should this be promoted into longer-lived memory?

A good result would promote:

  • Antonio prefers United
  • Antonio prefers aisle seats
  • Arroz, Feijão e Bife is his go to meal
  • he prefers short, direct reminders

A good result would reject things like:

  • one specific link from one night
  • generic greetings
  • random operational clutter

This is the important transition. Raw interactions become cleaner durable memory.

How the pipeline works#

OpenClaw describes Dreaming as three cooperative phases: Light, Deep, and REM.

The names are memorable, but the architecture matters more than the metaphor.

Light#

Light is the quick pass.

This is where the system scans recent notes, transcripts, and recall material looking for candidate facts worth keeping. The goal is not to promote everything. The goal is to surface likely signals while avoiding obvious noise.

This is the phase closest to asking: what from recent interactions looks important?

Deep#

Deep is the consolidation pass.

This is where stronger filtering and reconciliation happen. It merges duplicates, looks for overlap with existing memory, and asks whether a candidate is stable enough to become durable memory.

This is the memory hygiene layer. It is not just extracting facts. It is deciding what survives.

REM#

REM is the more reflective pass.

This is the phase that revisits material more carefully, including older notes through grounded backfill. It is the closest thing to replaying history to find durable truths that should have been captured earlier.

What matters most here is that it is grounded. It is tied back to actual notes and history, which makes it safer and more traceable than speculative memory generation.

My shortest explanation is this:

Light finds candidates. Deep consolidates them. REM revisits and grounds them, including historical backfill. The result is better durable memory.

What OpenClaw added#

OpenClaw introduced Dreaming as an experimental memory pipeline, and it has matured quickly.

The release notes and product surface now include weighted short-term recall promotion, a /dreaming command, a Dreams UI and diary view, multilingual conceptual tagging, doctor and status support, configurable aging and recency controls, replay-safe promotion behavior, transcript ingestion into the dreaming corpus, and grounded REM backfill for older notes.

It also produces more traceable artifacts: promoted durable facts, diary entries, promotion decisions, possible lasting truths, explainable trails, and a more structured Dream Diary experience.

What I like about this direction is that it treats memory as an active maintenance problem, not a passive archive.

Why this matters for real agent systems#

I think many people still underestimate how much agent quality depends on context management and memory quality.

If an agent cannot preserve the right context over time, its performance degrades even if the model is strong. You can see this in coding, research, operations, and communication workflows. The first part of the run looks smart. The later part starts drifting.

In practice, that means long-running execution gets worse exactly when the task becomes more dependent on accumulated context.

This matters a lot for engineering organizations trying to use agents for real work. At Attentive, one of the biggest opportunities in agentic systems is not just generating an answer faster. It is building consistency over time. Accurate management of context and memory is critical.

That is where an architecture like Dreaming starts to matter.

A good memory system should not just retrieve what happened. It should improve the quality of what survives. It should make the next session start from a better state than the last one ended with.

That is very different from simple compaction.

Compaction helps you survive the current session. Dreaming helps the system get smarter across sessions.

The bigger idea#

I think durable memory will end up being one of the core architectural layers in serious agent systems. Frontier models will keep improving context windows, but that alone will not solve the problem.

We spent the last year focused on models, context windows, tool calling, and retrieval. All of that is critical. But if long sessions still decay, then we still have a memory problem.

That is why I see Dreaming as meaningful step forward. It treats memory as something that needs curation, promotion, aging, and traceability. More importantly, it creates a path from messy short-term experience to durable knowledge that improves future execution.

That is the real goal. Not just keeping more tokens alive, but preserving the right truths over time.

This is all so exciting. So much to learn. What a time to be alive!