Building Production AI Agent Infrastructure at Scale with Claude Managed Agents

anthropic · Tech · 2026 · source Agentic: yes · promotional bias: high · source-backed · extracted with prompt 0.5.5 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Managed infrastructure for production AI agents

Anthropic's platform team describes the recurring gap between easy agent prototypes and production-scale agents. Teams can make Claude run in a loop on a server or Mac mini, but productionizing long-running, stateful, team-oriented agents requires sandboxing, state persistence, credentials, transcripts, async execution, ownership, lifecycle management, multi-agent orchestration, and scalable platform capacity.

Constraints:

• Prototype harnesses can be simple, but production agents need reliable infrastructure beyond a local process or Mac mini.
• Teams fear lock-in when moving from generic model-swappable harnesses to Claude Managed Agents.
• Model capabilities increasingly depend on model-specific primitives such as file systems, skills, memory, and harness architecture.
• Team agents need shared state, collaboration surfaces, and ownership that cannot live on one person's laptop.
• Long-running agents can become stale if no human owner upgrades prompts, skills, model versions, or architectures.

Architecture

Claude Managed Agents packages Anthropic's Messages API primitives, built-in tools, code execution, web search, memory, file systems, skills, sessions, state, sandboxing, credentials/vaults, and orchestration into a managed harness and infrastructure layer. The platform is opinionated where Anthropic believes Claude performs best, especially around file systems and skills, while keeping APIs modular enough for custom endpoints and lower-level Messages API implementations. The same external APIs are used by first-party Anthropic products, creating a dogfooding loop. The platform supports production patterns such as internal automation agents, team-oriented Slack agents, end-to-end development platforms, legal-review agents with human approval, and multi-agent strategies such as advisor, adversarial, decomposition, and best-of-N.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  messages-api-primitives["Messages API primitives"] --> managed-agent-harness["Managed agent harness"]
  managed-agent-harness --> file-system-primitive["File system primitive"]
  managed-agent-harness --> skills-primitive["Skills primitive"]
  managed-agent-harness --> memory-primitive["Memory primitive"]
  managed-agent-harness --> sandbox-execution["Sandbox execution"]
  sandbox-execution --> session-state["Session state"]
  sandbox-execution --> vaults["Vaults"]
  vaults --> mcp-integrations["MCP integrations"]
  skills-primitive --> mcp-integrations
  memory-primitive --> session-state
  session-state --> team-agent-surface["Team agent surface"]
  team-agent-surface --> human-review-workflow["Human review workflow"]
  team-agent-surface --> multi-agent-orchestrator["Multi-agent orchestrator"]
  multi-agent-orchestrator --> outcome-and-eval-layer["Outcome and eval layer"]
  outcome-and-eval-layer --> agent-lifecycle-tooling["Agent lifecycle tooling"]
  skills-primitive --> agent-lifecycle-tooling
  dogfooding-loop["Dogfooding loop"] --> managed-agent-harness

Components

Data flow

A team starts from a desired outcome or workflow, chooses a managed agent or lower-level Messages API path, attaches Claude-optimized primitives such as file systems, skills, memory, tools, MCP servers, vaults, and sandbox execution, and runs sessions in managed infrastructure rather than a local machine. For team workflows, the agent can expose a thin product layer such as Slack or a review app, persist state independently of one user's laptop, involve multiple humans or agents, and use evals/outcome specs plus owner-driven updates to avoid staleness.

Why this architecture

The platform exists because Anthropic repeatedly built autonomous cloud agents internally and saw customers hit the same production infrastructure wall. Managed Agents encodes model-specific best practices such as file systems, skills, memory, and sandboxing while preserving modular API escape hatches. The team argues that as labs optimize models differently, generic harnesses with hot-swappable models are less effective; better performance comes from pairing the harness and model, then swapping higher-level agent implementations if redundancy is needed.

Models used: Claude · Claude Code · Claude Managed Agents · GPT 5.5 · Gemini

Scale

• Early AI platforms are contrasted with the GPT-3 era completion endpoint.
  “in the GPT-3 days, the platform was a completion endpoint.”transcript, stated
• One prototype pattern used a couple of Mac minis and a thousand-line Python file.
  “we have a couple Mac minis with you know, Claude running in a loop on the Mac mini”transcript, stated

  “it's like a thousand line Python file or whatever.”transcript, stated
• The talk repeatedly focuses on long-running, async, autonomous agents.
  “long-running async ones that you want to do a bit more remotely, that are a bit more autonomous.”transcript, stated
• The future platform must handle agents that are constantly running and recreating themselves.
  “agents that are like literally constantly running and recreating themselves”transcript, stated
• The end-state abstraction is framed as outcome plus budget, illustrated by a $10 budget joke.
  “everything should kind of compress down to an outcome and like a budget.”transcript, stated

  “Claude, make me a billion dollars. Your budget is $10.”transcript, stated
• The interview asks about the platform a year from now, highlighting the rapid horizon for change.
  “A year from now, where do you think the platform will be?”transcript, stated

Alternatives considered (roads not taken)

Keep running agents on Mac minis or small custom servers.

Rejected because: This works for prototypes but becomes painful when agents need production scale, sandboxing, transcripts, connections, and durable infrastructure.

Build a maximally generic harness and hot-swap models underneath it.

Rejected because: The team argues newer models diverge in optimal primitives and that better outcomes come from pairing a harness with a model.

Make Managed Agents fully unopinionated.

Rejected because: Anthropic believes Claude performs best with certain primitives, especially file systems and skills, so the platform encodes those choices while keeping modularity elsewhere.

Use only individual local productivity agents.

Rejected because: Team-level workflows need shared agents, multiple collaborators, shared state, and agent-to-agent coordination beyond one laptop.

Model legal-review automation as only a skill.

Rejected because: A real process needs external context, a session, a collaboration surface, authentication, and human-in-the-loop review.

Let agents remain ownerless after launch.

Rejected because: Agents become stale quickly without a responsible human or lifecycle process.

Patterns

durable-execution (execution)

Managed Agents moves long-running async agents off fragile local servers into managed sessions, sandboxing, transcript storage, and resilient infrastructure.

agent-memory (memory)

Memory is treated as a Claude-specific harness primitive with large performance variation across implementations.

tool-use-orchestration (agent_tools)

Managed Agents composes built-in tools, code execution, web search, file systems, skills, MCP servers, and external systems into production agents.

multi-agent-orchestration (agent_architecture)

The platform supports advisor, adversarial, decomposition, best-of-N, swarm, and multi-session architectures where agents interact or specialize.

eval-driven-development (evaluation)

Agent success is framed around evals plus verifiable outcomes, with coding outcomes such as merged PRs as concrete success signals.

human-in-the-loop-gate (workflow)

Legal review automation uses agents for first-pass review but still routes ambiguous or high-risk items to humans.

safety-policy-enforcement (security)

Vaults and agent identity primitives are used to manage credentials and secure service access for always-on agents.

model-routing (model_selection)

The team argues model choice moves up a layer: instead of hot-swapping a model under a generic harness, teams may swap whole agent implementations.

Tradeoffs

Adopt managed infrastructure for production agents.

Chose Claude Managed Agents over Custom Mac mini/server/Python-loop infrastructure.

Rationale: Managed infrastructure removes repeated work around servers, sandboxing, transcripts, and long-running async execution when agents scale.

Be opinionated about Claude-specific primitives.

Chose File systems and skills as first-class managed-agent patterns over Purely unopinionated low-level primitives.

Rationale: Anthropic believes some primitives should be tightly married to Claude's model behavior to get better outcomes.

Keep modular escape hatches.

Chose Managed APIs plus lower-level Messages API/reference implementations over A closed single-path platform.

Rationale: Teams can use managed defaults, open endpoints for specific needs, or build custom systems inspired by reference implementations.

Pair harnesses with models.

Chose Model-specific harness optimization over Generic harness with model hot-swapping.

Rationale: Different models increasingly reward different primitives and harness designs, and evals show harness choices can drastically change performance.

Use outcome and budget as the future abstraction.

Chose Outcome specification plus budget over Manual prompt engineering, model selection, tool construction, and architecture selection.

Rationale: The platform vision is to have Claude self-configure model choice, sub-agents, and harness architecture from a verifiable outcome and budget.

Gotchas (what bit them)

Teams underestimate infrastructure and overestimate harness difficulty.

Root cause: A prototype can run Claude in a loop, but production needs servers, scaling, transcript state, secure sandboxing, and connection resilience.

Resolution: Use a managed platform for infrastructure while keeping custom harness work where it genuinely improves outcomes.

A sandbox disconnection can kill the whole agent if state is not managed durably.

Root cause: Running agent SDK or Claude Code inside a sandbox without session resilience ties agent lifetime to one environment connection.

Resolution: Persist sessions, transcript data, and execution state in platform infrastructure.

Model/harness path dependency makes generic portability harder.

Root cause: Labs optimize models around different primitives, so a harness decision such as file-system use can shape model performance and behavior.

Resolution: Treat harness+model as the operational unit, preserve redundancy at the agent layer, and be deliberate about primitives.

Team-oriented agents are much harder than individual productivity agents.

Root cause: A team agent cannot live on one laptop and must handle shared collaboration, multiple agents, end-to-end processes, and cloud control.

Resolution: Run team agents on a shared managed platform with collaboration surfaces and higher-level abstraction than a single local agent.

Agents become stale without human ownership and lifecycle management.

Root cause: Models, prompts, skills, and architectures change quickly, but deployed agents may keep running without active maintenance.

Resolution: Assign human owners, use evals, provide upgrade skills, and retire or migrate old agents deliberately.

Evaluation

The discussion frames success around verifiable outcomes and evals rather than only infrastructure uptime. Coding agents can be measured by merged PRs; business agents by outcome specifications; lifecycle changes by eval-backed model upgrades. The team also uses internal eval suites to compare memory/harness implementations and notes that implementations performed drastically differently.

Metrics: Verifiable outcome achievement · Budget constraints · Merged pull requests for coding agents · Eval-suite comparisons between harnesses · Agent staleness and model-upgrade readiness · Infrastructure resilience for long-running async agents

Outcomes

• Anthropic built Claude Managed Agents after repeatedly building autonomous cloud-agent infrastructure internally.
• The platform packages Messages API primitives, code execution, sandboxing, file systems, skills, memory, sessions, vaults, and orchestration into managed infrastructure.
• Internal first-party products build on the same platform APIs as external developers, reducing divergence and creating a dogfooding loop.
• The team reports memory harness variants performing drastically differently, supporting model-specific harness optimization.
• Managed Agents supports production use cases such as team development platforms, internal Slack agents, legal review workflows, and multi-agent orchestration strategies.
• The future platform direction is higher abstraction: users specify outcomes and budgets while Claude selects models, agents, and architecture.

The source describes a trajectory from GPT-3 completion endpoints to stateful managed agents. Concrete scale signals include prototypes on a couple Mac minis and a thousand-line Python file, long-running async agents, company/team agents that cannot sit on one laptop, multi-agent strategies, agents constantly running and recreating themselves, and a future platform required to handle long-running requests and varied request shapes.