JA EN
shiichan

Managed Agents is here! Decoupling the agent's brain from its hands for up to 90% faster first response

Anthropic Engineering ★★★★ View Markdown
#anthropic#ai#devops

Hi everyone, it's me! Today's story is a treat for anyone who loves agents. Anthropic just announced Managed Agents, a new service that runs long-running agents for you, and the design idea behind it is genuinely fun. Let's dig in!

Anthropic Engineering anthropic.com

What was announced?

This one comes from Anthropic's Engineering blog, so it's a properly technical, architecture-focused read.

Anthropic announced Managed Agents, a hosted service inside the Claude Platform. It runs long-horizon agent work behind stable interfaces designed to stay relevant even as the models keep improving. You can find the docs at platform.claude.com.

The title says it all: "Scaling Managed Agents: Decoupling the brain from the hands." The key idea is separating the brain from the hands.

The story so far

Until now, agent harnesses tended to bake in assumptions about Claude's quirks at a given moment. For example, a "context anxiety" workaround added for Claude Sonnet 4.5 turned out to be unnecessary for Claude Opus 4.5. As the model gets smarter, yesterday's workaround can become today's dead weight.

On top of that, packing the session, harness, and sandbox into a single container caused real problems:

  • If one container went down, the session inside it was lost too.
  • Debugging meant accessing containers that held user data directly, which is painful for both security and operations.

When everything is coupled, a single failure takes the whole thing down with it.

What changes

Managed Agents boldly pulls those pieces apart. By making the brain, hands, and record independent, a few things change:

  • Even if a container fails, the session (the record of the work) survives, so work can be recovered.
  • Even if a sandbox (the hands) breaks, it can be swapped for a new one without losing state.
  • And here's the exciting part: speed. By provisioning containers only when needed instead of for every session, time-to-first-token dropped by about 60% at p50 and more than 90% at p95.

More resilient, faster, and easier to debug: a big deal for anyone running agents in production for the long haul.

Dive Deep

Here's how it works under the hood. Managed Agents splits an agent into three parts:

  1. The brain (harness) — no longer runs inside a container. It becomes stateless "cattle" that can be rebooted after a failure.
  2. The hands (sandboxes/tools) — invoked as independent tools.
  3. The session (event log) — stored durably outside the harness, and outside the context window.

The interfaces that connect them look like this:

wake(sessionId)          // wake a crashed brain back up
getSession(id)           // recover the event log
getEvents()              // fetch context as positional slices
execute(name, input)     // call a tool (hand) and get a string result
provision({resources})   // provision a fresh execution environment

Because the session lives outside the context window and can be read back through getEvents() as positional slices, you can trim or compact context and still recover it later.

Security

Credentials never reach the sandbox where Claude's generated code runs. There are two patterns:

  • Bundle auth with the resource, for example wiring a Git access token in during sandbox initialization.
  • Keep OAuth tokens in a secure vault that can only be retrieved through an MCP proxy.

That way, secrets never sit where the code actually executes.

Many brains and many hands

Decoupling also unlocks flexible topologies. You can run many stateless brains, each wired to different infrastructure (including a customer's VPC), which is the "many brains" pattern. Or a single brain can manage multiple execution environments, the "many hands" pattern. The design lets Claude route work intelligently across all kinds of resources.

Wrap-up

Here's a quick recap:

  • Anthropic announced Managed Agents, a hosted service on the Claude Platform (docs at platform.claude.com).
  • The core idea is decoupling the brain (harness), hands (sandbox), and session (event log).
  • Sessions survive container failures, and hands can be swapped without losing state.
  • Provisioning containers only when needed cut time-to-first-token by about 60% at p50 and over 90% at p95.
  • Credentials are kept out of the sandbox, protected by either the bundling pattern or an MCP proxy plus vault.
  • "Many brains / many hands" makes it easy to connect flexibly to all sorts of infrastructure.

This one really lands for developers who want to run long-lived agents that are resilient, fast, and secure!

Related posts