Scaling Managed Agents: Decoupling the brain from the hands
by Anthropic
Stop packaging an agent as one long-lived container: split it into a brain, a set of hands, and a durable session log.
Overview
Published 8 April 2026 by Lance Martin, Gabe Cemaj and Michael Cohen with Anthropic's Agents API team, this piece argues that the common practice of packaging an agent as one long-lived container — the 'pet' — is the thing that stops agent systems scaling. It proposes virtualising the agent into three decoupled layers, explicitly by analogy to how an operating system virtualises hardware behind abstractions like 'process' and 'file': the brain (the model plus its harness), the hands (sandboxes and tools that actually execute), and the session (a durable, append-only event log). Sections run Don't Adopt a Pet, Decouple the Brain from the Hands, The Session is Not Claude's Context Window, and Many Brains Many Hands. The consequences are concrete: containers become stateless cattle; a harness failure loses no state because a fresh instance recovers through wake(sessionId); inference begins immediately instead of waiting on container provisioning, and sandboxes spin up only when code genuinely needs to run. Credentials are bundled with resources at sandbox initialisation or held in a vault behind a proxy, so generated code never handles auth material. The session log is queried through getEvents(), letting the harness transform history before it reaches the model, and hands are interchangeable behind execute(name, input) so brains can pass them to one another. Reported effect: p50 time-to-first-token down roughly 60 percent and p95 down more than 90 percent.
At a Glance
- Topic
- Agentic
- Level
- Advanced
- Format
- Guide
- Cost
- Free
- Duration
- ~10 min read
- Provider
- Anthropic
- Hands-on
- No
- Certificate
- None
What You’ll Learn
- ✓Split an agent into brain, hands and session as separately deployable layers
- ✓Model conversation state as a durable append-only log outside the context window
- ✓Recover from a harness crash by waking a stateless instance from the session
- ✓Provision sandboxes lazily so inference starts before any container exists
- ✓Keep OAuth tokens in a vault behind a proxy so generated code never sees them
- ✓Design a getEvents() interface so the harness can reshape history before inference
- ✓Route many brains to many hands through a stateless execute(name, input) tool interface
- ✓Spot harness components that exist only to patch a weakness the next model fixes
Highlights
- •First-party writeup from the engineers who built Claude's Agents API, not a vendor explainer
- •Publishes real latency numbers — p50 time-to-first-token down about 60 percent, p95 down over 90 percent
- •Gives named primitives (wake, getEvents, execute) you can implement on any stack, not just Anthropic's
- •Closes with a falsifiable warning: the workarounds built for Sonnet 4.5's 'context anxiety' were dead weight on Opus 4.5, so every harness component encodes an assumption that expires
- •Ten minutes for an architecture most teams otherwise rediscover the hard way in production
Who It’s For
Best For
- ✓Platform engineers running agents in containers at more than prototype scale
- ✓Teams whose agent loses all state when its harness process dies
- ✓Anyone designing credential handling for agents that execute generated code
- ✓Architects comparing self-hosted agent harnesses against a managed agent API
Prerequisites
- •Experience running an agent loop with tool calls and a code sandbox
- •Basic distributed-systems vocabulary — stateless services, event logs, orchestration
FAQ
What is Scaling Managed Agents: Decoupling the brain from the hands?
An architecture writeup from the team that built Claude's Agents API, for platform engineers whose agents currently live inside a single container and lose everything when it dies. It argues for virtualising an agent into three independently scalable layers and gives the primitives to do it, so that a harness crash becomes recoverable, sandboxes are provisioned lazily, and generated code never touches credentials.
Is Scaling Managed Agents: Decoupling the brain from the hands free?
Scaling Managed Agents: Decoupling the brain from the hands is free to access.
What level is Scaling Managed Agents: Decoupling the brain from the hands for?
Scaling Managed Agents: Decoupling the brain from the hands is aimed at a advanced audience. Recommended background: Experience running an agent loop with tool calls and a code sandbox, Basic distributed-systems vocabulary — stateless services, event logs, orchestration.
How long does Scaling Managed Agents: Decoupling the brain from the hands take?
Expect roughly ~10 min read. Most learners work through it at their own pace.
What will I learn from Scaling Managed Agents: Decoupling the brain from the hands?
You'll learn: Split an agent into brain, hands and session as separately deployable layers; Model conversation state as a durable append-only log outside the context window; Recover from a harness crash by waking a stateless instance from the session; Provision sandboxes lazily so inference starts before any container exists; Keep OAuth tokens in a vault behind a proxy so generated code never sees them; Design a getEvents() interface so the harness can reshape history before inference; Route many brains to many hands through a stateless execute(name, input) tool interface; Spot harness components that exist only to patch a weakness the next model fixes.
Topics
Sources
This page was written from 2 sources, 1 on domains other than anthropic.com.