By ByteBot
Anthropic shipped three new Claude Managed Agents features on May 6 that collectively do something no single release has managed before: move Claude agents from stateless, session-local tools into persistent infrastructure that remembers across runs, verifies its own output, and fans work out to parallel specialists — without developer-written orchestration code. Dreaming (research preview), Outcomes, and Multiagent Orchestration are each useful in isolation; together, they describe a different kind of agent deployment entirely.
Outcomes: The Quality Loop You’ve Been Building by Hand
Start here, because Outcomes is immediately available to all developers and addresses the most common failure mode in production agents: confident, wrong output.
The mechanic is straightforward. You write a rubric describing what success looks like. The harness runs an iterate → grade → revise loop until the agent meets your criteria, hits max_iterations, or gets interrupted. The grader runs in its own independent context window — not inside the agent’s reasoning chain — which is the critical design detail. A grader sharing context with the agent would inherit the same blind spots. A grader with a clean context window can catch things the agent rationalized past.
client.beta.sessions.events.send(
session_id=session.id,
events=[{
"type": "user.define_outcome",
"description": "Build a DCF model for Costco in .xlsx",
"rubric": {"type": "text", "content": RUBRIC},
"max_iterations": 5,
}]
)The grader returns per-criterion gaps, not a binary pass/fail. The agent gets specific feedback on exactly where the output fell short and takes another pass. Set max_iterations to cap costs. Pair with webhooks so you’re notified when an outcome completes rather than polling.
Every team running agents at scale has built some version of this loop manually. Anthropic is folding it into the platform and handling the retry logic. That’s worth something.
Multiagent Orchestration: Parallel Work Without the Graph Code
The second public beta lets one lead agent delegate work to up to 20 specialist agents running in parallel. Each specialist gets its own model, system prompt, tools, and MCP servers. They all run on a shared filesystem, so a security-review agent and a documentation agent can work simultaneously on the same codebase without stomping on each other.
The use case Anthropic cites — a lead agent coordinating an incident investigation while subagents fan out through deploy history, error logs, metrics, and support tickets — is genuinely compelling. The alternative is sequential tool calls from a single agent context, which is both slower and hits context limits faster.
Two constraints worth knowing upfront: the coordinator can only delegate one level deep (subagents can’t spawn their own subagents), and there’s a 25 concurrent thread cap. LangGraph users doing multi-level delegation will hit that ceiling. For most common use cases — research, code review, data extraction — it’s enough.
Dreaming: Better, But You Probably Can’t Use It Yet
Dreaming is the most architecturally interesting of the three features and the one most developers won’t have access to today. It’s a research preview, gated behind a request form.
Here’s what it does: on a schedule you configure, a background process reads your agent’s session transcripts and existing memory store, then produces a reorganized memory layer. New patterns get created. Stale entries get updated or deleted. Frequently-useful information gets promoted so it’s retrieved first. The result is an agent that starts each session slightly smarter than it was at the end of the last one.
Anthropic offers two modes: auto-apply (the dream results update memory directly) or review-first (you inspect and approve changes before they land). For production deployments, review-first is the right default. Silent behavior drift from a bad dreaming session is exactly the kind of failure that’s hard to debug after the fact.
The conceptual shift is real: memory is the storage system, dreaming is the curation engine. The analogy to biological sleep — consolidating experiences into durable knowledge — is apt enough that the name earns its keep.
What the Three Features Mean Together
The clearest way to read this release: Anthropic is repositioning Claude agents as stateful infrastructure, not single-session tools. Outcomes handles correctness. Orchestration handles scale. Dreaming handles continuity. None of them require developers to write orchestration code, manage retry logic, or build custom memory pipelines.
That’s the bet. Whether it pays off depends on execution and — critically — on whether the lock-in is worth the reduced operational burden.
LangChain’s response is instructive. Within weeks of the Claude Managed Agents launch, LangChain shipped Deep Agents Deploy, explicitly calling it “an open alternative to Claude Managed Agents” and describing CMA as “a walled garden that creates an incredible amount of lock-in.” It’s model-agnostic, MIT licensed, and supports the same high-level architecture. The message to developers: you don’t have to choose Anthropic’s managed hosting to get managed agent capabilities.
Access and Costs
The current status of each feature:
| Feature | Status | Access |
|---|---|---|
| Outcomes | Public beta | All developers |
| Multiagent Orchestration | Public beta | All developers |
| Webhooks | Public beta | All developers |
| Dreaming | Research preview | Gated (request form) |
All requests require the managed-agents-2026-04-01 beta header (the SDK adds it automatically). Pricing is $0.08/session-hour for runtime plus standard token rates. One thing to note: Batch API discounts do not apply to Managed Agents sessions. Dreaming, Outcomes, and Webhooks don’t add separate fees — you pay for the tokens the background processes consume.
The full API reference, YAML config for multiagent sessions, and the dreaming access form are at platform.claude.com/docs/en/managed-agents.
