Claude Can Dream: Anthropic Adds a Background Reasoning Mode to Agents

On May 5, Anthropic introduced a new, slightly literary feature for Claude Managed Agents — Dreaming. The name sounds mystical, but what it actually does is quite practical: when an Agent has no user input and is idle, it autonomously generates a series of hypothetical scenarios, runs through them internally, and stores the reasoning results as reusable memory.

In the same round of updates, there’s also a piece of direct good news for heavy users — the rate limits for Claude Code under the Pro and Max plans have been doubled. The first item is product storytelling; the second is real, tangible benefit.

Clarifying What “Dreaming” Actually Is

Anthropic’s official blog phrasing is quite restrained, calling it a “latent rehearsal” mechanism. In plain language: when a Managed Agent isn’t handling requests, instead of truly idling, it creates tasks for itself based on its recently processed jobs, used tools, and accumulated context.

The rough process goes like this:

• The Agent samples several “potential upcoming scenarios” based on historical task patterns — e.g., a customer support Agent might simulate customer complaints about shipping, refund disputes, or product malfunctions.
• For each scenario, it runs through a full internal reasoning chain: which tools to call, how to decompose the task, and where it might get stuck.
• After completing a run, it stores any valuable intermediate conclusions — such as an API call pattern or how to handle an edge case — in its long-term memory.
• When a real request later arrives, it’s already “rehearsed” similar situations, responding faster and reasoning more accurately.

It’s branded “Dreaming” because it resembles a hypothesis from cognitive science — memory consolidation during sleep. Human brains replay daytime experiences while sleeping, turning short-term memories into long-term ones. Claude’s method is entirely different mechanistically — it feeds itself with generated reasoning traces — but the end effect somewhat echoes that concept.

Anthropic stresses that this isn’t mere background reasoning that burns compute for no reason. Dreaming has budget control — each Agent has an independent “dream quota” that can be capped in the management panel. Also, the memory entries generated during dreams go through a self-critique filtering step, so the model won’t accidentally store hallucinated facts as real knowledge — at least that’s what they claim officially.

Is This Actually Useful?

I tend to be wary of “biomorphic” product narratives, but Dreaming makes sense for the Agent product line.

Today’s AI Agents share a common pain point: cold starts are expensive. A freshly deployed Agent spends its first few dozen conversations “learning” — which tools it can invoke, terminology within a business domain, users’ preferences, etc. Traditionally, it accumulates understanding at runtime, improving naturally over time. But this is unfriendly for B2B clients, who expect an Agent product to be productive on day one, not after a month of “training.”

Dreaming’s purpose, in essence, is to move that “training” phase to the background. Agents can refine their strategy libraries without waiting for actual traffic. This aligns with the recent wave of agentic memory concepts — Anthropic simply applied a more dramatic presentation.

But for novelty’s sake, let’s be honest: academia has explored self-play and synthetic trajectory generation for years — DeepMind, Meta AI, etc. Anthropic’s move is an engineering deployment, not a theoretical breakthrough. Its true value lies in how it exposes a usable commercial interface — developers can control via API when an Agent dreams, what it dreams about, and how much. That’s a first among closed-source large models.

API-Level Changes

For developers interfacing via OpenAI Hub, Dreaming is exposed as a parameter under Claude Managed Agents. Its call style is compatible with the OpenAI format — just use /v1/messages or related Agent endpoints. A minimal config example:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_OPENAI_HUB_KEY",
    base_url="https://api.openai-hub.com/v1"
)

response = client.chat.completions.create(
    model="claude-sonnet-4.5",
    messages=[
        {"role": "system", "content": "You are a customer support Agent"},
        {"role": "user", "content": "Please check order #A1029 for me"}
    ],
    extra_body={
        "managed_agent": {
            "agent_id": "agt_customer_support_01",
            "dreaming": {
                "enabled": True,
                "budget_tokens_per_day": 200000,
                "scenarios": ["complaint", "refund", "shipping_query"],
                "memory_retention_days": 30
            }
        }
    }
)

print(response.choices[0].message.content)

A few parameters worth noting:

• budget_tokens_per_day: daily dream quota, in tokens. Too low means insufficient dreaming; too high burns money. Anthropic’s recommended range is 50k–500k depending on task complexity.
• scenarios: you can explicitly specify which scene types the Agent should rehearse. If omitted, it samples automatically from historical traffic.
• memory_retention_days: how long dream-generated memories are kept. For short-term tasks, set this shorter — otherwise the model may drift due to its own hallucinations.

For direct domestic use, OpenAI Hub already supports passing these Managed Agent parameters transparently — no extra adaptation required.

Rate Limit Doubled: The More Tangible Change

Compared to Dreaming’s conceptual narrative, the doubled rate limits for Pro and Max users of Claude Code are an immediately noticeable improvement.

For months, Claude Code’s throttling was a major community complaint. The $200/month Max plan often hit message throttling mid-session, forcing users to wait hours to resume — severely disrupting productivity. Reddit’s r/ClaudeAI frequently saw posts complaining about it, and Anthropic officially admitted in tickets that “demand exceeded expectations.”

This doubling means:

• Pro users ($20/month) get roughly 90 messages per 5-hour window, up from 45.
• Max users come in two tiers — 5× and 20× Pro limits — and both now double again, effectively multiplying their usable allowances.
• Claude Code’s agentic calls (triggering multiple tool uses, more compute-intensive than basic chats) now count against these new limits, improving coding “flow” continuity significantly.

As for how the doubling was achieved: in the past six months, Anthropic has done heavy inference-level optimization — running Sonnet models on its own TPU clusters, improving KV cache reuse, and caching repeated system prompts under prefix caching for Agent contexts. The compute saved now partially benefits existing users.

Context Within Anthropic’s Recent Update Cadence

This update isn’t isolated. Reddit users have counted 74 product updates in 52 days, averaging more than one per day — even denser than OpenAI’s output in the same period.

A few noteworthy mainlines:

1. Claude Cowork broadly available: previously Enterprise-only collaborative Agent capabilities now extend to all paid plans, featuring enterprise management, RBAC, spending caps, OpenTelemetry observability, and Zoom connectors. Clearly aimed at competing with Copilot Studio and ChatGPT Enterprise.
2. Managed Agents framework taking shape: from the initial Claude Agents SDK to today’s Managed Agents + Dreaming + Cowork combo, Anthropic is establishing Agents as first-class product entities, not merely “wrappers over an API.”
3. Claude Code ecosystem expansion: leaked source shows it’s built with TypeScript + React (Ink) — effectively a terminal Agent OS, not just an LLM shell. This architecture lets it integrate MCP servers quickly, accelerating ecosystem growth and widening the gap from competitors.

Taken together, Anthropic’s strategy is clear — not competing with OpenAI in general chat, but in developer tooling and enterprise Agents. Dreaming, as a standalone feature, adds polish; within the broader product portfolio, it strengthens the argument that Agents matter more than models.

Unresolved Issues

Finally, a few concerns raised after reviewing the documentation — things to monitor moving forward:

• Hallucination contamination risk: how much can self-critique truly filter false knowledge? If an Agent dreams up a nonexistent API signature and stores it, could it insist on the wrong answer later during real requests? Anthropic hasn’t published its gating mechanism.
• Cost attribution: how is dream token usage billed? Officially, it’s on the user’s bill, but the display granularity and per-Agent level tracking remain unclear.
• Cross-Agent memory leakage: if a tenant runs multiple Managed Agents, can dream memories intermingle? This is a hard requirement in enterprise scenarios.

Until those questions have clear answers, my personal recommendation is: enable Dreaming only on non-critical Agents first, set a small budget, observe for two weeks, and then decide whether to deploy in production. Promising feature — but don’t dive in headfirst.

References

• Reddit r/ClaudeAI: Discussion thread on Anthropic releasing 74 product updates in 52 days — community breakdown of Anthropic’s recent product release cadence, including details on Cowork’s broader availability