How to Build Self-Improving AI Agents

Claude’s Dreaming Feature: How Anthropic Built Self-Improving Agents

Anthropic’s legal AI customer Harvey reported task completion rates rising roughly 6x after enabling “dreaming” on Claude Managed Agents, according to VentureBeat’s coverage of Code with Claude conference. The figure is a vendor-cited early-adopter result, not an independently audited benchmark, but it explains why Anthropic is focusing the next phase of agent platforms on the ability to improve between sessions rather than only within them.

Dreaming, introduced at Anthropic’s second annual Code with Claude event in San Francisco on May 7, 2026, is a scheduled process that reviews an agent’s past sessions and memory stores, identifies patterns, and organizes memories so future work improves. It launched as a research preview, meaning developers must apply for access. Two companion features, outcomes and multiagent orchestration, moved from research preview into public beta the same day.

How Dreaming Works

Anthropic describes dreaming as a complement to the agent memory it released earlier in 2026. Memory lets each agent capture what it learns as it works, in plain text. Dreaming refines that memory between sessions, collecting shared learnings across a team of agents and keeping the store focused as it grows. The distinction matters: memory captures information per session, dreaming consolidates it across sessions.

Alex Albert, who leads research product management at Anthropic, explained the mechanism at the conference. He compared it to how a person builds skill after completing a task: they record the path from A to B so they can reuse it. With dreaming, the model does that recording itself, so a future session inherits the same context without a human writing it down. The process reveals patterns no single agent session could detect alone, including recurring mistakes, workflows that multiple agents independently develop, and preferences shared across a team.

Key Takeaways:

• Dreaming is a scheduled, cross-session review process that extracts patterns from agent memory and writes them back as plain-text notes and structured playbooks.
• It does not modify model weights; all learnings are inspectable and auditable by humans.
• Harvey reported roughly 6x task completion rates with dreaming; Wisedocs cut document review time 50% using outcomes.
• Outcomes used a separate grader agent in a fresh context window, improving task success by up to 10 points in Anthropic’s internal tests.
• Anthropic’s Alex Albert acknowledged a “level of trust” is required when agents consolidate their own knowledge.

The most important design constraint, according to Albert, is that dreaming does not change the underlying model. “We’re not changing the model itself through dreaming; it’s not doing updates to weights or anything like that,” he said. Instead, the agent writes learnings as plain-text notes and structured “playbooks” that future sessions reference. That makes the entire process observable and auditable, which is a property Anthropic relies on when asked about trust implications of agents managing their own knowledge.

During the keynote, Anthropic showed the loop live on a fictional aerospace startup that needed to land drones on the moon. A commander agent, detector agent, and navigator agent ran an initial simulation across six landing sites with imperfect results. The presenters triggered a dreaming session from the Claude Developer Console, and overnight the dreaming agent reviewed all past simulation runs and wrote a descent playbook. When the team ran a new simulation the next morning with that playbook in memory, results improved significantly on sites that had previously underperformed.

The “descent playbook” detail clearly shows what dreaming actually produces. It is not a gradient update or a fine-tune; it is a written artifact, a set of heuristics drawn from patterns across multiple mission runs, that future sessions read as context. The demo’s headline, as head of product Angela Jiang put it on stage, was that improving the system took “all dreaming” and a single button press, not human rewriting prompts or retraining anything.

Dreaming vs. Compaction: The Cross-Session Break

The technical difference that separates dreaming from older memory approaches is that it operates across sessions and across agents. Large language models struggle with limited context windows, so long-running agents historically relied on a process called compaction, where the model periodically analyzes a lengthy conversation and keeps only the most relevant information as context. But compaction is limited to a single conversation with a single agent, as SiliconANGLE’s analysis explains.

Dreaming removes that limitation. Past sessions and memory stores are analyzed across multiple agents, so all of them can retain the most important lessons. This makes it useful for long-running work and multiagent orchestration, where a lesson learned by one specialist should spread to the whole team rather than stay trapped in a single thread.

Anthropic also made a separate architectural choice that is easy to miss: the outcomes feature uses a distinct grader agent that evaluates output in its own fresh context window, so it is not influenced by the working agent’s reasoning or accumulated biases from a long session. Albert argued that giving completed output to a fresh model and asking it to find bugs reliably outperforms asking the same long-running thread to identify its own errors, because attention declines over very long sessions, a limitation he said Anthropic is working to fix in future models.

The separation-of-concerns logic is worth explaining. A single agent that has been working on a task for hours has a context window full of its own reasoning, dead ends, and accumulated assumptions. When it checks its own work, it is grading against that same context. A fresh grader sees only the output and rubric, which is why Anthropic found the two-agent pattern delivers higher success rates on verification than self-review within one thread. This is the same principle behind GitHub’s approach, described below.

Outcomes and Multiagent Orchestration: The Other Two Levers

Dreaming is the headline, but it ships alongside two features that together form what Anthropic calls a continuous improvement loop. Outcomes lets a developer write a rubric describing what success looks like, and a separate grader evaluates the agent’s output against that rubric in its own context. When something is off, the grader pinpoints what needs to change and the agent takes another pass, iterating without a human reviewing each attempt. This is especially useful for subjective quality, like matching brand voice or following visual guidelines.

Multiagent orchestration lets a lead agent break a large job into pieces and delegate each to a specialist with its own model, prompt, and tools. For example, a lead agent runs an investigation while subagents fan out through deploy history, error logs, metrics, and support tickets. Every step is traceable in the Claude Console, showing which agent did what, in what order, and why.

Albert’s guideline for when to use multiagent orchestration versus a single thread: parallel agents are better for investigation, where there is a lot of context that will ultimately be discarded, because you only need the answer, not every search result from areas where nothing was found. He described spinning up disposable sub-agents for specific retrieval tasks and bringing only the result back to the main thread. Increasingly, he said, the model itself will decide when to parallelize, so a developer will not need to care whether it is one agent or many.

GitHub’s chief product officer, Mario Rodriguez, described a similar advisor pattern during the conference, pairing a smaller, cheaper model as executor with a larger model as mentor. When the smaller model hits a problem beyond its capability, it calls the larger one for guidance, then continues executing. Rodriguez said the approach delivers near-Opus-level intelligence at lower cost, and GitHub inserts critique models at three points in the coding workflow: after drafting a plan, after a complex implementation, and after writing tests but before running them.

What Numbers Show So Far

The quantitative evidence for these features is early and mostly vendor-cited, but it is specific. Anthropic’s internal testing found outcomes improved task success by up to 10 points over a standard prompting loop, with the largest gains on the hardest problems, and improved file generation quality by +8.4% on docx and +10.1% on pptx, according to Anthropic’s own announcement. Those are internal benchmarks, not independent audits.

The deployments give the claims some grounding. Legal AI company Harvey uses managed agents for long-form drafting and document creation, and with dreaming its agents remember what they learned between sessions, including filetype workarounds and tool-specific patterns. Medical document review company Wisedocs built a document quality check agent that uses outcomes to grade each review against internal guidelines, cutting review time by half. Netflix’s platform team built an analysis agent that processes logs from hundreds of builds across different sources, using multiagent orchestration to analyze batches in parallel and surface only patterns worth acting on. Spiral by Every runs a lead agent on Haiku that delegates drafting to subagents on Opus, with outcomes enforcing writing quality against a rubric of editorial principles.

CEO Dario Amodei said at the conference that Anthropic saw roughly 80x annualized growth in revenue and usage in the first quarter of 2026, against an internal plan of 10x, and that API volume on the Claude platform was up nearly 70x year over year. The average developer using Claude Code now spends about 20 hours per week with the tool, per Amodei’s remarks cited by VentureBeat. This is a demand environment where a self-improvement feature becomes a competitive advantage rather than a novelty.

A Worked Example: Defining Outcome in Code

The outcomes feature is the most immediately usable of the three, because it maps cleanly onto a rubric a developer already has in mind. Anthropic’s documentation describes writing a rubric for what success looks like, then letting a separate grader evaluate against it. The pattern applies to any agent framework that separates generation from verification. Here is a minimal illustration of the separation-of-concerns principle, written against a generic agent loop rather than a specific SDK, since Managed Agents API details live behind a request-access gate:

# Illustrative pattern for outcomes feature's grader separation.
# This is a generic demonstration of "generate, then grade in fresh
# context," not actual Claude Managed Agents API.

def run_with_outcomes(task, rubric, agent, grader, max_passes=3):
 for attempt in range(max_passes):
 output = agent.run(task) # working agent produces draft
 verdict = grader.evaluate( # fresh grader, own context window
 output=output,
 rubric=rubric, # e.g. "brand voice matches, cites sources"
 )
 if verdict["passes"]:
 return output
 # Grader pinpoints what to change; agent takes another pass
 task = task + "\nRevise to address: " + verdict["feedback"]
 return output # return best effort after max passes

# Note: prod use needs a pass limit, cost tracking per grader call,
# and a human-review escape hatch for high-stakes outputs. The grader's
# fresh context window is the point -- it must not inherit the working
# agent's reasoning, or the check degrades into self-review.

The key point in the code is the comment: the grader’s fresh context window is the entire mechanism. Anthropic’s design claim is that a fresh model reviewing completed output finds more bugs than the same long-running thread reviewing its own work, because attention declines over very long sessions. The loop above caps passes, tracks that each grader call costs tokens, and leaves a human-review path, which is practical discipline for any team adopting this pattern.

Limits and Trade-offs

Dreaming has real constraints that practitioners should consider before treating it as a finished system. It is a research preview, not a generally available product, and Anthropic requires developers to request access. The early-adopter metrics come from Anthropic’s own customers and its internal tests, so they should be read as directional signals, not independently verified benchmarks.

The trust question is one Anthropic itself acknowledges. When asked about agents consolidating their own knowledge, Albert said “there is a level of trust that you need to place” in the process, though he noted all memories are inspectable and that smarter models are getting better at writing notes for their future selves. That is an important caveat: a self-improvement loop is only as good as the quality of the memories it consolidates, and a flawed playbook written into memory will be reused by future sessions just as readily as a correct one.

There is also a cost and control dimension. Dreaming is a scheduled process that consumes compute to review sessions and restructure memory, and developers must decide whether the agent updates memory automatically or whether changes go through human review first. The latter preserves control but sacrifices the hands-off improvement loop the feature is designed to enable. The features also all run inside Anthropic’s managed platform, which means teams trade the flexibility of building their own agent harness for the speed of a pre-built one. Albert compared it to building for macOS: you do not want to reimplement the operating system.

Anthropic’s own outlook is ambitious. Co-founder Jack Clark wrote in his Import AI newsletter that there is a 60% chance frontier AI models will be able to autonomously train their successors by the end of 2028, as Business Insider reported. Dreaming is not that, but it is an early step in the same direction: agents that partially manage themselves, review their own history, and carry curated knowledge forward without a human writing it down. The line between “self-improving within a fixed harness” and “self-improving at the model level” is where the next several generations of this technology will be drawn.

What to Watch Next

The first sign to watch is whether dreaming moves from research preview to general availability and whether Anthropic publishes independent or third-party evaluations of its effect on task success over many sessions. The current evidence is early-adopter testimonials and internal benchmarks, both of which can be noisy.

The second sign is how the trust mechanism holds up in production. If the playbooks that dreaming writes into memory are consistently auditable and reversible, the feature earns its place. If consolidated memories start to encode mistakes and spread them across a fleet of agents, the “level of trust” Albert described will be tested directly. For teams that rely on Claude for reliability, our analysis of 2026 Claude outages and our guide to how Claude’s system prompts shape behavior provide useful context for where this platform sits on the reliability curve.

The third sign is the competitive response. As agent platforms from OpenAI and Google push on developer adoption, Anthropic is betting that production reliability, not just model quality, will determine which platform wins enterprise budgets. Dreaming stakes out territory others have not claimed: the idea of agents systematically reviewing their own histories to extract reusable knowledge goes beyond the memory and tool use that competing platforms offer. Whether that translates into lasting advantage depends on whether the improvement loop works well on long-running, high-stakes workloads without accumulating errors.

There is a testable claim in the trajectory worth tracking. If Jack Clark’s estimate holds and a frontier lab shows a model autonomously training its successor by the end of 2028, dreaming will look like an early productization of that capability. If self-improvement stops at the harness level, the 60% figure will look optimistic. Either outcome is observable.

Related Reading

More in-depth coverage from this blog on closely related topics:

• How to Fix Claude API Problems

Sources and References

Sources cited while researching and writing this article:

• Anthropic introduces “dreaming,” a system that lets AI agents learn from their own mistakes | VentureBeat
• Anthropic is letting Claude agents ‘dream’ so they don’t sleep on the job
• New in Claude Managed Agents: dreaming, outcomes, and multiagent orchestration | Claude by Anthropic
• Anthropic Introduces ‘Dreaming’ Technique for AI Agents – Business Insider
• New in Claude Managed Agents: dreaming, outcomes, and multiagent orchestration – SD Times
• Anthropic updates Claude Managed Agents with three new features – 9to5Mac