Claude Managed Agents is Anthropic’s hosted agent harness: you define an agent - a model, tools, MCP servers, and skills - and Anthropic runs it inside managed, sandboxed, stateful sessions. It lets you ship long-running autonomous agents without building the agent loop, the sandbox, or the infrastructure yourself, and it is billed at $0.08 per session-hour of active runtime plus standard model tokens.
- Claude Managed Agents is a hosted harness plus infrastructure - you configure the agent, and Anthropic runs the sandbox, the session, and the tool execution for you.
- It sits between the raw Messages API, where you build the entire agent loop yourself, and the open Claude Agent SDK, which gives you the same harness to run on your own infrastructure.
- Sessions are stateful and long-running: they pause, resume cleanly, and keep conversation history and sandbox state server-side, which is what makes multi-hour and scheduled work practical.
- Pricing is refreshingly simple - $0.08 per session-hour of active runtime on top of standard model tokens, so a typical one-hour task on Opus 4.8 lands around $0.70.
- The runtime is the easy part. Guardrails, evals, permission scoping, and tool design still decide whether an agent is safe to put in front of real users - and that is where production risk actually lives.
$0.08 / session-hour
Active-runtime billing, metered to the millisecond - idle time is free - charged on top of standard model tokens.
4 building blocks
Agent, Environment, Session, and Events are the entire mental model of the platform.
1M-token context
Available on Claude Fable 5, Opus 4.8, and Sonnet 5 for long-horizon agent work.
A demo agent and a production agent can look identical in a screen recording. The difference is everything you do not see: the sandbox the code runs in, the session that survives a restart, the credentials that never leak, the traces you read when something goes wrong. Building that layer is slow, and it is the reason most impressive agent prototypes never ship. Claude Managed Agents is Anthropic’s answer to exactly that problem - it hands you the harness and the infrastructure so you can spend your time on the agent, not the plumbing.
What are Claude Managed Agents?
Claude Managed Agents is a pre-built, configurable agent harness that runs inside Anthropic’s managed infrastructure. Instead of writing your own loop - call the model, run a tool, feed the result back, repeat - you define what the agent is and let Anthropic run it. The platform gives Claude a real computer: it can read and write files, run shell commands, search and fetch the web, and call external tools, all inside a secure sandbox with built-in prompt caching and context compaction. It is currently in public beta (every request carries the managed-agents-2026-04-01 beta header) and is enabled by default on API accounts.
The mental shift is that you stop thinking in single requests and start thinking in sessions. A session is a running agent working on a task over time, not a one-shot completion - and that single idea is what unlocks long-running, asynchronous, and scheduled work.
The four building blocks
The whole platform is built on four concepts. Learn these and the rest of the API is just detail.
| Concept | What it is |
|---|---|
| Agent | The definition - the model, system prompt, tools, MCP servers, and skills. You create it once and reference it by ID across many sessions. |
| Environment | Where sessions run - an Anthropic-managed cloud sandbox, or a self-hosted sandbox on infrastructure you control. |
| Session | A running instance of an agent inside an environment, doing a specific task and producing outputs. |
| Events | The messages exchanged with a session - your user turns, tool results, and streamed status updates. |
How a managed agent actually runs
The lifecycle is short and predictable. You create an agent, point it at an environment, start a session, and then stream events back and forth while Claude works.
- Create an agent - pick the model and describe its job, tools, MCP servers, and skills.
- Create an environment - choose a managed cloud sandbox or a self-hosted one.
- Start a session - launch a run that references your agent and environment.
- Send events and stream responses - Claude autonomously calls tools and streams results back over server-sent events, while the full event history is persisted server-side.
- Steer or interrupt - send more user events mid-run to redirect the agent, or stop it to change course.
Out of the box the agent gets a useful set of built-in tools - a Bash shell, file operations (read, write, edit, glob, grep), web search and fetch, and any MCP servers you connect for access to systems like GitHub, Slack, or your own database. The harness also handles the unglamorous performance work for you: prompt caching to cut cost on repeated context, and automatic compaction so a long session does not fall off the end of its context window.
Managed Agents vs the Agent SDK vs the Messages API
Anthropic gives you three ways to build with Claude, and they trade control against operational burden. Picking the right one is mostly a question of how much infrastructure you want to own.
| Messages API | Claude Agent SDK | Claude Managed Agents | |
|---|---|---|---|
| What it is | Direct model access | The Claude Code harness, as a library | A hosted harness plus infrastructure |
| You build | The whole agent loop | Your app around the harness | Just the agent config |
| Runs on | Your servers | Your servers | Anthropic’s managed cloud (or your self-hosted sandbox) |
| State | You persist it | You persist it | Stateful sessions, server-side |
| Best for | Custom loops, full control, low latency | Embedding a capable agent in your own product | Long-running, async, and scheduled work with minimal ops |
The Agent SDK is worth calling out because it is the same agent loop, tools, and context management that power Claude Code, exposed in Python and TypeScript. If you want the harness but need to run it inside your own product or on your own machines, that is the SDK. Managed Agents is what you reach for when you would rather not operate any of it.
Where your code runs: cloud vs self-hosted sandboxes
Every session runs in a sandbox, and you choose where that sandbox lives. The default is an Anthropic-managed cloud sandbox with packages pre-installed and network access ready to go - the fastest path to shipping. For teams with compliance or data-residency requirements, self-hosted sandboxes keep the agent’s code, filesystem, and network egress entirely inside your own environment while Anthropic still orchestrates the session.
One caveat is worth stating plainly, because it matters for regulated work: because Managed Agents is stateful and stores session history and outputs server-side, it is not currently eligible for Zero Data Retention or a HIPAA Business Associate Agreement. You can delete sessions and uploaded files at any time through the API, but if you operate under strict data controls, factor that in - or run the agent yourself with the SDK.
What does it cost?
Pricing has two parts and no surprises: the tokens the model uses, at standard per-model rates, plus a small charge for the time the session is actually running.
Session runtime is billed at $0.08 per session-hour, metered to the millisecond, and it only accrues while the session’s status is running - time spent idle, waiting on you, or waiting on a tool confirmation is free. Here is Anthropic’s own worked example for a one-hour coding session on Opus 4.8:
| Line item | Calculation | Cost |
|---|---|---|
| Input tokens | 50,000 x $5 / 1M | $0.25 |
| Output tokens | 15,000 x $25 / 1M | $0.375 |
| Session runtime | 1.0 hour x $0.08 | $0.08 |
| Total | $0.705 |
At the other end of the scale, Anthropic estimates processing 10,000 customer-support conversations on Haiku 4.5 at roughly $37 in total - the point being that your model choice, not the runtime fee, dominates the bill. Match the model to the task:
| Model | Input / output per million tokens | Use it for |
|---|---|---|
| Claude Haiku 4.5 | $1 / $5 | High-volume, latency-sensitive, simpler tasks |
| Claude Sonnet 5 | $2 / $10 (introductory, through Aug 31, 2026) | Most production workloads - the default workhorse |
| Claude Opus 4.8 | $5 / $25 | Complex reasoning and hard agentic work |
| Claude Fable 5 | $10 / $50 | The longest-horizon, highest-stakes autonomous work |
When should you use Managed Agents - and when not?
Managed Agents is the right tool when the shape of the work matches what it is built for:
- Long-running tasks that take minutes or hours across many tool calls.
- Asynchronous or scheduled jobs - recurring agent runs on a cron schedule, or work that outlives a single request.
- Stateful workflows that need to remember earlier steps and keep a persistent filesystem.
- Teams that want to ship without building and operating their own sandbox and tool-execution layer.
Reach for the Messages API or the Agent SDK instead when you need a tight, low-latency single-shot response, when you want to own every detail of the agent loop, or when strict Zero Data Retention or HIPAA requirements rule out server-side session storage. Different tool, same model.
Whichever tier you choose, notice what the platform does and does not solve. Managed Agents removes the infrastructure problem - the sandbox, the session, the scaling - which is real and valuable. What it does not remove is the engineering that makes an agent trustworthy: the guardrails that keep it in bounds, the evals that tell you it still works after a prompt change, the permission scoping that limits the blast radius, and the observability that lets you debug it in production. The model is the easy part now; the system around it is the job.
That system is the work we do at Sentient Arc - taking a capable agent harness like Managed Agents and turning it into something you can actually put in front of customers, with the reliability, safety, and instrumentation that production demands. If you are weighing whether to build agents on this stack, that is a problem worth engineering properly.
What are Claude Managed Agents?
Claude Managed Agents is Anthropic’s hosted agent harness. You define an agent - its model, system prompt, tools, MCP servers, and skills - and Anthropic runs it inside managed, sandboxed sessions, handling the agent loop, tool execution, checkpointing, credentials, and tracing for you. It is designed for long-running and asynchronous autonomous work, and it is currently in public beta.
How are Claude Managed Agents different from the Claude API?
The Messages API gives you direct model access and expects you to build your own agent loop - call the model, run a tool, feed the result back. Managed Agents provides that loop and the runtime for you, plus stateful sessions, sandboxing, and infrastructure that scales. Use the API for custom, low-latency, fine-grained control; use Managed Agents to ship long-running agents without operating the plumbing.
How much do Claude Managed Agents cost?
You pay standard model token rates plus $0.08 per session-hour of active runtime, metered to the millisecond and charged only while the session is actually running. Anthropic’s worked example puts a one-hour Opus 4.8 session at about $0.71 in total. In practice your model choice, not the runtime fee, drives the bill.
What is the difference between Managed Agents and the Claude Agent SDK?
They share the same harness. The Claude Agent SDK is an open toolkit - the same agent loop, tools, and context management that power Claude Code, in Python and TypeScript - that you run on your own infrastructure. Managed Agents is that harness hosted and operated by Anthropic. Choose the SDK for maximum control and self-hosting; choose Managed Agents for minimal operational overhead.
Can I run Claude agents on my own infrastructure?
Yes. Managed Agents supports self-hosted sandboxes, where the agent’s code, filesystem, and network egress stay entirely within your environment while Anthropic orchestrates the session. If you want to own the whole stack instead, the open Claude Agent SDK runs agents entirely on your own servers.
Which Claude models can I use with Managed Agents?
Any current Claude model, including Haiku 4.5 for fast, high-volume tasks, Sonnet 5 as the production default, Opus 4.8 for complex reasoning, and Fable 5 for the longest-horizon autonomous work. Fable 5, Opus 4.8, and Sonnet 5 offer a 1M-token context window for large tasks.
What happens if a managed agent runs for hours or gets interrupted?
Sessions are stateful by design. They run for as long as the task needs, pause and resume cleanly, and store conversation history and sandbox state server-side, so an interruption does not lose progress. You are only billed for runtime while the session status is running, not while it sits idle.
Are Claude Managed Agents production-ready and secure?
The platform is in public beta and ships strong primitives - sandboxed execution, scoped permissions, managed credentials that stay out of the sandbox, and end-to-end tracing. Note that it is not currently eligible for Zero Data Retention or a HIPAA BAA, because sessions are stateful. The harness is a strong foundation; the guardrails, evaluations, and permission design that make a specific agent safe are still your responsibility.