Video summary

Code with Claude 2026: Memory and dreaming for self learning agents

Main summary

Key takeaways

Technology

Overview

Anthropic product manager Mahesh (Platform team) presents “memory” as the next core primitive for frontier self-learning agents, and introduces “dreaming” as a new mechanism to continually improve and organize that memory. Both are released as part of the Managed Agents API:

  • Memory: public beta
  • Dreaming: research preview

Why Memory Matters for Self-Learning Agents

Models and agents can now run for many hours (up to near days). The remaining challenge is continuous self-learning + context management over long horizons.

Memory is positioned as the primitive that enables agents to learn about:

  • Tasks
    • Success criteria
    • Common mistakes
    • Effective and ineffective strategies
  • Environments
    • Up-to-date codebases
    • Files and assets
    • Operational context
  • Other agents in the same environment
    • Share learnings
    • Detect issues elsewhere
    • Incorporate improvements

Product: Claude-Managed “Memory” (Public Beta)

Key promise: “maximize intelligence by default” and support multi-agent systems, with enterprise-grade control.

How Memory Is Modeled / Updated

Memory is treated as a file system that the model can manage:

  • A hierarchy of files Claude can read and write
  • Uses familiar coding tools such as bash/grep to keep memory organized and updated

Claude Opus 4.7 is cited as being strong at file system-based memory, especially at:

  • Deciding what to store
  • Choosing how to structure it
  • Determining how to organize and split files

Multi-Agent Scaling Requirements

Memory must work when hundreds to thousands of agents run concurrently and share state.

Key requirements include:

  • Permission scopes
    • Different memory stores can have different access levels (e.g., org-wide read-only runbooks vs SRE read-write working memory)
  • Optimistic concurrency
    • Agents use a content hash / precondition check to avoid clobbering each other’s writes

Enterprise Control Features (Production Readiness)

To support operational use, memory includes:

  • Version history / audit log
    • Full audit trail of memory updates
    • Attribution metadata: which agent, which session, when
    • Supports rollback/traceability and safer control of updates
  • Standalone / portable API
    • Customers can integrate memory workflows outside managed agents (e.g., custom curation pipelines, PII scanning, cloning memory externally)

Product: “Dreaming” (Research Preview)

Dreaming is introduced as an out-of-band process to improve memory beyond what individual sessions can learn.

What Dreaming Does

Dreaming runs batch and asynchronously, separate from the active agent task “hot path.”

It analyzes:

  • Recent agent sessions
  • Transcripts

To:

  • Find patterns and shared mistakes
  • Identify inefficient strategies (e.g., repeated behaviors across agents)
  • Produce organized, up-to-date memory content as a memory update (a diff)

Dreaming can be scheduled via:

  • Console/API/cron
  • Triggered after tasks complete

Why Dreaming Exists (Limitations It Addresses)

Multi-agent memory can become:

  • Siloed to each session/task
  • Incomplete, missing learnings found by other agents/sessions
  • Less efficient at keeping large shared memory holistic and current

Design Rationale (Important Properties)

Dreaming has several guiding properties:

  • Out-of-band
    • Enables cross-agent pattern detection that a single agent couldn’t infer from its own perspective
    • Avoids added latency to the agent task
  • Separates objectives
    • Keeps “memory quality improvement” distinct from “task completion”
  • Scales via compute
    • Similar to “test-time compute” / thinking models: spend more effort to produce better-organized memory
    • Similar to search systems: build a high-quality index upfront so later retrieval is efficient

Demonstrated Outputs (Demo)

In an SRE scenario with multiple specialized agents:

  • Agents have memory stores like:
    • Org-wide knowledge (read-only runbooks/SLOs)
    • SRE memory (read-write working memory updated continuously)

Immediate benefit: when a similar alert recurs, a new agent consults prior investigation notes to short-circuit redundant work, improving token efficiency, intelligence, and speed.

Then dreaming runs:

  • Updates specific memory notes using transcript evidence, such as:
    • “agents were triggered 60 seconds after CPU spikes → likely inefficient retry logic”
  • Performs deduplication and curation
    • Consolidates repeated entries
    • Removes stale information
  • Adds a verification/backfill note so future agents can trust the updates

Reported Results

Example customer: Harvey (legal benchmark)

  • Using dreaming increased task completion rate for a legal scenario by 6x

“Frontier Memory System” Framing

Mahesh describes a layered approach:

  • Memory primitive: real-time read/write during work
  • Dreaming: verification, organization, enrichment, and backfill using session transcripts

Together, these steps bridge toward larger-scale knowledge bases that remain current and efficient.

Main Speaker / Source

  • Speaker: Mahesh — Product Manager, Platform Team, Anthropic

Original video