What Are Claude Managed Agents? Architecture, How They Work, and When to Use Them

Building an AI agent isn't difficult because calling an LLM is difficult. The harder part is everything around the model: the agent loop, tool execution, sandbox, state, runtime, and permissions required to let an agent actually complete a task.

Claude Managed Agents packages this infrastructure into a managed agent runtime, so developers can configure an agent and let Anthropic handle much of the underlying execution infrastructure.

What Are Claude Managed Agents?

Claude Managed Agents is Anthropic’s pre-built, configurable agent harness that runs in managed infrastructure, designed for long-running and asynchronous agent workloads, giving agents access to tools, execution environments, sessions, and other infrastructure needed to complete multi-step tasks.

The easiest way to understand Managed Agents is to compare it with Anthropic's Messages API.

With the Messages API, you get direct access to Claude. Your application is responsible for building the agent loop around the model: maintaining conversation history, deciding when to call tools, executing those tools, passing results back to Claude, and determining when the task is complete.

With Claude Managed Agents, Anthropic provides the agent harness and the infrastructure around the model. Instead of implementing the complete execution loop yourself, you configure an agent and its environment, then create sessions in which the agent can perform work.

The distinction can be summarized as:

Everything runs behind the managed-agents-2026-04-01 beta header, which the official SDKs set for you. Access is enabled by default on API accounts, and the service is also available through Claude Platform on AWS with some differences in feature availability and session behaviour. Anthropic has named Notion, Rakuten and Sentry among the early teams building on it.

The word doing the most work in "Anthropic Managed Agents" is managed. You are not getting a new model or a new capability - Claude could already use tools. You are getting someone else's operations team.

How do Claude Managed Agents Work?

The lifecycle is five steps, and it's worth understanding because each one maps to a resource you create and pay for.

1. Create an agent. Define the model, system prompt, tools, MCP servers and skills. The agent is created once and referenced by ID across every session that uses it.
2. Create an environment. Configure where sessions actually execute - either an Anthropic-managed cloud sandbox, or a self-hosted sandbox running on infrastructure you control, which exists largely for compliance and data-residency requirements.
3. Start a session. A session is a running instance of your agent inside an environment, working on one specific task.
4. Send events and stream responses. Your application sends user turns as events; Claude autonomously calls tools and streams results back over server-sent events. Event history is persisted server-side and can be fetched in full afterwards.
5. Steer or interrupt. You can inject additional user events mid-execution to redirect the agent, or interrupt it outright.

Step five is the one people underestimate. A long-horizon agent that can't be redirected halfway through is a batch job with extra latency.

The Four Core Concepts

Claude Managed Agents is built around a few core concepts that separate the agent configuration from the individual task it performs.

Agent

An Agent is the reusable configuration that defines how the agent behaves. It can specify the Claude model, system prompt, tools, MCP servers, and skills available to the agent.

For example, an agent could be configured as:

Research Agent
├── Model: Claude
├── System prompt: Research analyst
├── Tools
├── MCP servers
└── Skills

‍Once the agent is configured, you can create sessions using that definition rather than rebuilding the configuration for every task.

Environment

The environment is where the agent actually performs its work.

This is important because an agent needs somewhere to execute commands, manipulate files, run code, and interact with tools. Managed Agents can use Anthropic-managed sandbox environments, while Anthropic also provides support for self-hosted sandbox configurations.

This separates the agent's reasoning from the environment in which its actions are executed.

Session

A session represents a running instance of an agent performing a task.

Instead of treating every model call as an isolated request, a session gives the agent a persistent execution context in which it can work through a task, interact with tools, and maintain state.

A simplified flow looks like:

Agent configuration
       ↓
   Environment
       ↓
     Session
       ↓
 Agent performs work
       ↓
Tools / files / code / MCP

This session-based model is particularly relevant for long-running workloads where an agent may need to perform many actions before producing a final result.

Events

Applications interact with Managed Agent sessions through events. These can represent user messages, agent activity, tool results, and other changes in the session.

This allows an application to start an agent session and stream its progress rather than implementing the entire orchestration loop itself.

At a high level:

Your application
      │ Start / send event
      ↓
Managed Agent session
      ├── Reason
      ├── Call tool
      ├── Execute code
      ├── Read / write files
      └── Continue working
      ↓
Stream events back
      ↓
Your application

The result is a separation between the application that requests work and the infrastructure that executes the agent.

That separation is the core idea behind Managed Agents: the developer defines the agent and its capabilities, while the managed runtime handles much of the machinery required to keep the agent running.

What Happens When a Claude Managed Agent Runs?

Once an agent, environment, and session are configured, the Managed Agents runtime handles the execution loop.

1. Your application sends a task to the session.
2. The runtime provisions the environment where the agent will work.
3. Claude decides what actions to take based on the task and available tools.
4. Tools execute inside the configured environment, and their results are returned to Claude.
5. The loop continues until the agent completes the task, while events can be streamed back to your application.

In simplified form:

Task
↓
Claude reasons
↓
Tool call
↓
Tool result
↓
Claude reasons again
↓
...
↓
Final result

The key difference from building an agent with the Messages API is that your application doesn't have to orchestrate each model call and tool result itself. Managed Agents handles that loop and exposes the execution through the session and event interfaces.

What's Built In

The value of any agent gateway or managed harness is measured by what you no longer have to write. Managed Agents ships with:

• A built-in tool set. Bash for shell commands inside the sandbox; file operations for read, write, edit, glob and grep; web search and fetch, optionally constrained to a domain allowlist or blocklist; and MCP server connections for external tool providers.
• Secure sandboxing. Execution isolation, authentication and secret management are handled by Anthropic. No servers to provision, no container escape logic to write.
• Stateful sessions with checkpointing. Persistent filesystems and conversation history across interactions, with sessions resuming cleanly after pauses or disconnects.
• Context management. Prompt caching and compaction are part of the harness rather than something you bolt on when your token bill spikes.
• Scheduled execution. Recurring agent runs on a cron schedule through scheduled deployments.
• Scoped permissions and identity. Define which tools and data sources a given agent can reach, with execution tracing attached.
• Console observability. Session tracing, integration analytics and troubleshooting live in the Claude Console, so you can inspect individual tool calls, decisions and failure modes.

Anthropic reports that in internal testing on structured file generation, Managed Agents improved task success by up to 10 points over a standard prompting loop, with the largest gains on the hardest problems. That is a claim about the harness, not the model and it's a fair illustration of why harness quality matters at all.

Worth keeping separate in your head: several of the headline capabilities are not generally available. Multi-agent coordination, self-evaluation against success criteria, MCP tunnels and dreaming sit in research preview behind a separate access request. If your architecture depends on agents spawning and directing other agents, that's a request form today, not an API.

Claude Managed Agents vs the Claude Agent SDK vs Building Your Own

Most teams evaluating this are really choosing between three points on a spectrum. The Claude Agent SDK comparison goes deeper, but here's the shape of it:

The pattern is consistent: every row you hand to Anthropic buys you time and costs you optionality. For a first agent, that's usually the right trade. For the twentieth, running across three teams with different compliance requirements, it usually isn't.

When Managed Agents Is the Right Call

Managed Agents works best when:

• The task is genuinely long-horizon - minutes or hours of execution with many tool calls, not a single request-response.
• Your team has already standardised on Claude and has no near-term plan to run open or multi-vendor models.
• You have little or no platform engineering capacity to spend on agent infrastructure.
• The work is asynchronous or scheduled - overnight reconciliation, recurring research, batch document generation.
• Sessions need to survive interruption, with a filesystem and history that persist between interactions.
• You need to be in production in days, and you'd rather revisit the architecture once the use case is proven.

That last one is the honest case for it. Renting a harness to validate whether an agent is worth building is a reasonable engineering decision.

Where Teams Hit Limits

Three constraints come up repeatedly once an agent moves from pilot to real traffic.

The model choice is made for you. The harness is purpose-built for Claude, which is exactly why it performs well and exactly why you can't route the 80% of your tasks that don't need a frontier model to something cheaper. On an agent running thousands of times a day, that's where the bill lives.

Cost has two components, not one. You pay standard Claude token rates plus a session-based charge for the managed runtime. Session-hour pricing is widely quoted in third-party write-ups, but check current rates against Anthropic's own pricing page before you model it. We break the full picture down in our Claude Managed Agents pricing analysis.

Data retention is a real gate for regulated teams. Because Managed Agents is stateful by design - sessions store conversation history, sandbox state and outputs server-side.- Anthropic's documentation states it is not currently eligible for Zero Data Retention or HIPAA Business Associate Agreement coverage. You retain control in the sense that you can delete sessions and uploaded files through the API at any time, but if your compliance posture requires ZDR or a BAA, this is a hard blocker rather than a procurement conversation. The self-hosted sandbox option addresses where code executes, not what the platform retains.

TrueForge: An Open-Source Alternative to Claude Managed Agents, Up to 75% Cheaper

TrueForge is TrueFoundry's open-source, vendor-neutral agent harness for teams that want more control over how their agents run in production. Instead of tying the runtime to a single model provider, TrueForge lets you bring your own models, MCP servers, and infrastructure while handling the agent loop, tool execution, context management, approvals, and sandboxing.

Where a self-hosted agent like Hermes leaves much of the production infrastructure to the developer, TrueForge provides the surrounding control plane needed to operate agents across teams and environments. This includes centralized MCP access and credentials, human-in-the-loop approvals, sandboxed execution, observability, and governance.

You can run it locally with npx @truefoundry/trueforge or deploy it for a team with Docker Compose or Helm.

TrueForge also separates the agent runtime from the model layer. This means teams can switch models or route workloads to different providers without rebuilding the agent itself.Combined with TrueFoundry's AI Gateway, teams can also apply model routing and cost controls to avoid using expensive frontier models for tasks that don't require them. The result is a middle ground between a fully managed runtime and building the entire agent infrastructure yourself: an open-source agent harness with the operational controls needed to run production agents at scale.‍

In TrueFoundry's benchmark against Claude Managed Agents, TrueForge reached roughly the same task accuracy while using about 40% as many tokens when both were run on Opus 4.8, making it about 30% cheaper per run. When the same benchmark was run with GLM-5.2 on TrueForge, it achieved the same ~11/14 task score at about $2.90 per run versus $11.80 for Claude Managed Agents, roughly 75% lower cost.

TrueFoundry also provides a second lever for reducing model costs through AI Gateway's Auto Routing. Instead of sending every request to a frontier model, Auto Routing classifies requests by complexity and routes them to different model tiers. In TrueFoundry's benchmark across 550 prompts, routing between Haiku, Sonnet, and Opus reduced cost by 69% while retaining 98% of baseline quality, and mean latency dropped from 7.6 seconds to 4.0 seconds. On production-shaped traffic, the overall cost reduction reached 80%.

These two layers address different parts of the cost equation. TrueForge reduces the overhead of running the agent itself, while model routing lets you avoid using an expensive model when the task doesn't require one. For teams running agents at scale, having both controls can matter more than the price of the model alone.

TrueForge is open source and MIT licensed, while TrueFoundry's AI Gateway adds the operational layer teams need when moving from individual agents to production: centralized model access, budgets, guardrails, credential management, and unified traces.

If you're comparing Claude Managed Agents with a more configurable architecture, TrueFoundry is worth considering when model flexibility, infrastructure control, and agent cost optimization matter alongside the agent runtime itself.

An Open-Source Alternative to Claude Managed Agents, Up to 75% Cheaper

Run production-ready AI agents on your own infrastructure with TrueForge, using your choice of models, tools, and sandbox providers.

View on GitHub

Docs

The Layer Managed Agents Doesn't Cover

Managed Agents governs one agent's runtime very well. What it doesn't do is govern a fleet which is the problem that shows up around agent number five, when finance asks what any of this costs and security asks who approved the credentials.

An agent harness controls how an agent works. An AI Gateway controls how that agent accesses models.

For example, an organization might run agents using Claude Managed Agents or TrueForge while routing model requests through an AI Gateway.
TrueFoundry's AI Gateway sits in front of every model and MCP call an agent makes, applying centralized model access, per-team budgets, rate limits, guardrails, credential management and unified traces - across whichever agents and frameworks your teams are running. It supports 1,000+ LLMs through a single OpenAI-compatible API, adds roughly 3–4 ms of overhead, and handles 350+ RPS on a single vCPU, so it can sit in the hot path of a long-running agent without becoming the bottleneck. It runs in your own VPC, on-prem or air-gapped.

This becomes particularly useful when an organization runs agents across multiple models rather than relying on a single model provider.

Agent runtime: manages the agent loop, tools, state, and execution.

AI Gateway: manages model access, routing, policies, observability, and provider abstraction.

This separation lets teams change or add models without having to redesign the agent itself.

Conclusion

Claude Managed Agents moves agent development up a level: instead of building the execution infrastructure around Claude yourself, you can use a managed harness designed for long-running, asynchronous agent workloads.

The important distinction is between the model and everything around it. The model provides the reasoning, while the agent harness manages the loop, tools, sandbox, sessions, and execution. Managed Agents packages much of that infrastructure into Anthropic's platform, while open-source approaches such as TrueForge give teams more control over the harness and runtime.

For production AI systems, the choice is therefore not only about which model to use. It is also about where the agent runtime lives, who operates it, how much control you need, and how you govern model access.

As agents become more capable and handle increasingly complex workflows, these infrastructure decisions will become an increasingly important part of building reliable production agents.

FAQ

Q: What are Claude Managed Agents?

‍A: Claude Managed Agents is Anthropic's suite of composable APIs for building and running cloud-hosted AI agents on the Claude Platform. It provides a pre-built agent harness — the tool-calling loop, sandboxed execution, session state, scoped permissions and tracing — so teams deploy agents without building their own runtime. It launched in public beta on 8 April 2026 and is built around four concepts: agents, environments, sessions and events.

Q: What's the difference between Claude Managed Agents and the Claude Agent SDK?

‍A: The Claude Agent SDK runs the agent loop inside your own process and infrastructure; Claude Managed Agents runs it on Anthropic's. With the SDK you own the runtime, the sandbox and the operational burden. With Managed Agents you hand all three to Anthropic and get production infrastructure, persistence and console tracing in return. Both are Claude-only.

Q: How much do Claude Managed Agents cost?

‍A: Cost has two parts - standard Claude API token rates for the model, plus a session-based charge for the managed runtime. Because agents run for long periods and the harness itself consumes tokens for tool calls and context management, the token side usually dominates the bill. Our pricing breakdown works through the full per-run math.

Q: Can I deploy TrueFoundry in my own VPC or on-prem?

‍A: Yes. TrueFoundry runs in your VPC, on-prem, air-gapped, hybrid or across multiple clouds, and no data leaves your domain. This is the main reason regulated enterprises choose it over SaaS-only gateways - particularly relevant here, since Managed Agents is not currently eligible for Zero Data Retention or HIPAA BAA coverage.

Q: Does TrueFoundry support MCP and AI agents?

‍A: Yes. TrueFoundry includes an MCP Gateway, Agent Gateway and an MCP & Agents Registry with tool-level access control. Agents built on LangGraph, CrewAI, AutoGen, the Claude Agent SDK or custom frameworks can all be deployed and governed centrally.

Q: How many LLMs does TrueFoundry support?

‍A: 1,000+ LLMs through a single OpenAI-compatible API. You switch models by changing the model name in the request — same URL, same credentials — which is what makes routing cheap tasks to cheap models a config change rather than a rewrite.

Related reading

• Claude Managed Agents Alternatives the five options worth evaluating if managed isn't the right fit
• TrueForge vs Claude Managed Agents: the benchmark full Enterprise-Bench methodology and cost-per-run numbers
• What is Multi-Agent Orchestration? the layer above a single agent runtime
• LLM Agents: architecture and patterns the primer behind this post
• AI Agent Registry how to keep track of agents once you're running more than a handful