Automation

Claude Managed Agents: The Complete Guide to Anthropic's New Agent Platform

April 9, 2026

TL;DR

On April 8, 2026, Anthropic launched Claude Managed Agents in public beta — a hosted service on the Claude Platform that runs production AI agents on Anthropic's infrastructure so you can skip the months of plumbing normally required to ship one.
You define an agent in natural language or YAML, set guardrails, and Anthropic handles sandboxed code execution, checkpointing, credential management, scoped permissions, identity, and execution tracing.
Pricing: standard Claude API token rates, plus $0.08 per session-hour of active runtime (idle time is free), plus $10 per 1,000 web searches.
Launch customers include Notion, Rakuten, Asana, Atlassian, and Sentry — all reporting agents shipped in days instead of months.
This piece breaks down what it actually is, the architecture Anthropic calls "brain, hands, session," how it stacks up against n8n, LangGraph, and Zapier, honest tradeoffs, a realistic pricing calculator, and a step-by-step guide to building your first agent.
The short version for operators: if you've been running agents on a VPS with n8n or LangGraph, Managed Agents is the first credible "we handle the infra" offer that's not a toy.

What Is Claude Managed Agents?

Claude Managed Agents is a hosted service on the Claude Platform (platform.claude.com) that provides the full runtime for production AI agents. Until now, Anthropic gave you the model and you brought the infrastructure. With Managed Agents, you bring the definition of what the agent should do and Anthropic brings everything else.

In Anthropic's own framing, shipping a production agent requires sandboxed code execution, checkpointing, credential management, scoped permissions, and end-to-end tracing — months of infrastructure work before you ship anything users see. Managed Agents handles that complexity. You define your agent's tasks, tools, and guardrails and Anthropic runs it on their infrastructure.

The service launched in public beta on April 8, 2026, accessible through the Claude Platform API. All Managed Agents endpoints require the managed-agents-2026-04-01 beta header, which the SDK sets automatically. Three advanced features — outcomes (self-evaluation against success criteria), multi-agent coordination, and persistent memory — are currently in research preview and require a separate access request.

Why This Launch Actually Matters

Every week for the last eighteen months, someone has announced "the agent platform that changes everything." Most of them didn't. So why is this one getting 2 million views on a single tweet and 39,000+ likes on launch day? Three reasons worth understanding before you evaluate whether to adopt it.

First, Anthropic solved the boring 70%. If you've built an agent in production, you already know the secret: the model is the easy part. Everything around the model — the sandbox it runs code in, the persistent state that survives a container crash, the credentials that tools use to authenticate, the permission scoping that stops the agent from deleting production data, the audit log the compliance team demands, the error recovery when a tool call fails halfway through — is where the months go. That's the part Managed Agents removes.

Second, the governance story is the real unlock for enterprise. Scoped permissions, identity management, and execution tracing are the three things that traditionally block enterprise rollouts of AI agents. CISOs and compliance leads don't care how clever your prompt is; they care whether they can answer "who did what when" in an audit. Managed Agents builds this in by default, which is why the launch customer list reads the way it does — Atlassian, Notion, Rakuten, and Asana are not companies that ship agents without a compliance sign-off.

Third, it's priced to actually use. At $0.08 per session-hour of active runtime — and critically, idle time doesn't count — the math works for the long-running async workloads that have been hardest to ship on existing platforms. A research agent that spends 2 hours reading documents and 22 hours waiting for new tasks costs you runtime for 2 hours, not 24.

The Architecture: Brain, Hands, Session

This is the piece that most launch coverage skipped, and it's the piece that matters if you're going to build on top of it. Anthropic published a companion engineering blog the same day as the launch explaining the design, and the core abstraction is worth internalizing.

Managed Agents virtualizes an agent into three separable components:

The Brain. The LLM itself (Claude) plus the harness that orchestrates its reasoning loop — deciding when to call tools, how to manage context, and how to recover from errors.

The Hands. A sandboxed, ephemeral execution environment where tools actually run. Code execution, file operations, web browsing, and MCP server calls all happen here. Critically, the hands are stateless — if a container crashes or gets corrupted, the system spins up a fresh one and the agent keeps going. A compromised container doesn't persist, which is a meaningful security property for anyone running untrusted tool output.

The Session. A durable, append-only event log that lives outside both the brain and the hands. It records every tool call, every result, every decision. If the brain needs to rewind and check what happened three steps ago, it reads from the session log. If the whole system restarts mid-task, the session picks up where it left off.

Why does this matter in practice? Because each piece can scale independently, and because the abstractions are stable even as the underlying implementation changes. In Anthropic's own words, this is designed as a "meta-harness" — unopinionated about the specific harness Claude will need in the future, but opinionated about the interfaces around it. That matters because harnesses encode assumptions about what the model can't do on its own, and those assumptions go stale fast as models improve. Building directly against a specific harness means re-platforming every time Anthropic ships a smarter model. Building against Managed Agents' interfaces means you don't.

What you actually define as a developer: the agent (model, system prompt, tools, MCP servers, and skills), the environment (a cloud container with pre-installed packages like Python, Node.js, Go, plus network rules and mounted files), and the session (which references both). Create the agent once and reference it by ID across sessions.

Pricing: What It Actually Costs

Pricing for Managed Agents stacks three components, all transparent and all documented in the official API pricing page:

1. Model tokens. Every token consumed by a Managed Agents session is billed at standard Claude API rates. Prompt caching multipliers apply identically. This means if you're running Sonnet 4.6, you pay Sonnet 4.6 rates; if you're running Opus 4.6, you pay Opus rates.

2. Session runtime. $0.08 per session-hour, measured to the millisecond, and billed only while the session's status is running. Time spent idle (waiting for your next message or a tool confirmation), rescheduling, or terminated does not count toward runtime. Session runtime replaces the Code Execution container-hour billing model — you are not separately billed for container hours on top of this.

3. Web search. $10 per 1,000 web searches triggered inside a session, identical to the standard web search tool rate elsewhere in the Claude API.

Notably, the following API modifiers do not apply to Managed Agents sessions: Batch API discount, Message Batches pricing, and Fast mode pricing. If you're cost-optimizing, those don't help you here.

Realistic Pricing Examples

A few worked examples, because the abstract numbers don't land until you see them applied.

Example 1: Inbox triage agent for a small team. Runs twice a day, averages 15 minutes of active runtime per run, processes ~50 emails using Sonnet 4.6, makes roughly 5 web searches per run. Monthly math: 30 days x 2 runs x 0.25 hours = 15 session-hours x $0.08 = $1.20 in runtime. Tokens: roughly $8–15/month at Sonnet rates. Web searches: 300/month x $0.01 = $3. Total: around $12–20/month.

Example 2: Lead enrichment agent for a B2B outbound team. Runs on demand when new leads hit the CRM, averages 3 minutes of active runtime per lead, processes 200 leads a month with Sonnet 4.6, does 4 web searches per lead. Math: 200 x 0.05 hours = 10 session-hours x $0.08 = $0.80 runtime. Tokens: roughly $20–40/month depending on context. Web searches: 800 x $0.01 = $8. Total: around $30–50/month.

Example 3: Always-on research agent monitoring a market. Active roughly 2 hours a day scanning news, generating reports, using Opus 4.6 for the synthesis step. Math: 60 session-hours/month x $0.08 = $4.80 runtime. Tokens at Opus rates: roughly $80–200/month depending on volume. Web searches: 3,000/month x $0.01 = $30. Total: around $120–240/month.

Example 4: A "24/7 always running" agent. This is the edge case worth flagging. If an agent is genuinely running continuously — actively processing, not idle — the math is 730 hours/month x $0.08 = $58.40/month just in runtime, plus tokens, plus web searches. Most real workloads don't run continuously; they run in bursts. If yours does, factor this in.

The key insight: idle time is free. This is what makes the pricing work for the kind of long-running, async, event-driven workloads that are the main use case for Managed Agents. An agent that waits 23 hours a day for a trigger costs you nothing during those 23 hours.

Claude Managed Agents vs. n8n vs. LangGraph vs. Zapier

This is the comparison everyone is actually Googling, so let's be direct about where each tool fits.

vs. n8n (self-hosted or cloud)

n8n is a workflow automation tool that excels at deterministic, trigger-based automations with lots of SaaS integrations — webhooks, scheduled jobs, Slack notifications, database writes. Its AI agent nodes let you bolt LLM reasoning onto a workflow, but n8n is fundamentally a workflow engine with AI features grafted on, not an agent runtime.

When n8n still wins: deterministic pipelines where every step is predictable. Cron-based jobs. Simple "if X happens, do Y, then Z" flows with 20+ SaaS integrations. Low-cost self-hosting on a VPS when you need absolute control.

When Managed Agents wins: open-ended tasks where the agent needs to decide the next step based on what it found in the previous one. Long-running sessions that might take hours. Workloads where the governance layer (scoped permissions, audit trail, identity) is non-negotiable. Anything where you need the agent to write and execute code safely in a sandbox.

The real split: n8n is for workflows with AI in them. Managed Agents is for agents with tools in them. If you're currently using n8n AI agent nodes and hitting walls around session length, context management, or security — that's your signal.

vs. LangGraph / LangChain

LangGraph is the open-source framework for building stateful multi-agent applications with explicit graph-based control flow. It's the tool most serious AI engineering teams have been using to build production agents over the last year.

When LangGraph still wins: when you need total control over the agent loop, want to run on your own infrastructure for compliance or cost reasons, need multi-model orchestration (mixing Claude, GPT, Gemini, open-source models), or want to customize every aspect of how state is managed.

When Managed Agents wins: when you want to stop maintaining the infrastructure layer entirely. When you're on Claude models anyway. When the months of work Anthropic did on checkpointing, compaction, and harness optimization are genuinely better than what your team would build. When you want the compliance and audit story handed to you.

The real split: LangGraph is a framework you host and maintain. Managed Agents is a service you rent. One gives you maximum flexibility; the other gives you maximum speed to production.

vs. Zapier / Make

Zapier and Make are SaaS automation platforms optimized for non-technical users connecting business apps. They're the right answer for "when a new row hits my Google Sheet, post to Slack and create a Trello card." They have AI features now, but they're not agent runtimes.

When Zapier/Make still win: when the person building the automation is not technical and the task is a well-defined linear pipeline between known SaaS apps.

When Managed Agents wins: when the task genuinely requires reasoning — reading documents, deciding what matters, writing code, conducting research. Things no amount of Zapier steps will solve cleanly.

The real split: Zapier is for connecting known apps with known logic. Managed Agents is for unknown logic that needs to figure itself out at runtime.

Step-by-Step: Build Your First Managed Agent

Here's the minimum viable path from "never touched it" to "shipped a working agent in production." Claude Managed Agents is accessed via the Claude Platform API (platform.claude.com), and the following steps assume you already have an Anthropic Console account with billing enabled.

Step 1: Plan the agent on paper first

Before writing a single line of YAML, write a one-page plan answering five questions:

What does the agent do, in one sentence? "Triage my inbox and draft responses to the 10 most important emails." Not "handle email."
What tools does it need access to? Gmail read/write, web search, maybe your calendar.
What are the guardrails? What is it never allowed to do? (e.g., "Never send email without my approval. Never delete anything.")
What does success look like? How will you know if the agent is actually working?
What's the trigger? Manual invocation, schedule, webhook, CRM event?

Skip this step and you'll spend the first week debugging symptoms of an underspecified problem.

Step 2: Define the agent

You have two options. For non-developers or quick prototypes, define the agent in natural language through the Claude Platform UI — describe what you want and Anthropic's tooling generates the underlying configuration. For anything you'll maintain in version control, use a YAML definition file with the agent's model, system prompt, tool list, MCP servers, and skills.

The agent definition is created once and referenced by ID across sessions. This is important: the same agent definition can serve many concurrent sessions without re-definition overhead.

Step 3: Configure the environment

The environment is the cloud container your agent's hands will run in. You specify pre-installed packages (Python, Node.js, Go, and others), network access rules (which domains the agent can reach), and any mounted files the agent needs.

Start locked down. Give it the minimum network access required, install only the packages you know you need, and mount only the specific files relevant to the task. You can always expand later; you cannot un-ship a data leak.

Step 4: Launch a session

A session references both the agent definition and the environment. Once launched, the agent runs autonomously — reasoning, calling tools, executing code, and persisting state to the session log. You can inspect any session through the Claude Console, including every tool call, decision point, and failure mode.

Step 5: Instrument and iterate

Session tracing, integration analytics, and troubleshooting guidance are built directly into the Claude Console. Use them. Review the first 20–50 sessions manually before you start trusting the agent to run unsupervised. Look for three patterns: tools the agent calls but shouldn't, tools it should call but doesn't, and places where it declared the task done prematurely.

Step 6: Harden for production

Once the agent is working, add the three things that separate a demo from a production system:

Scoped permissions. Give the agent the narrowest possible identity — a service account with read-only access to the systems it needs and write access only where absolutely necessary.
Human-in-the-loop checkpoints for any irreversible action. Sending an email, deleting a file, charging a credit card, publishing content — these should all require explicit approval until you have months of proof the agent handles them reliably.
Budget alerts. Set spend caps at the organization level and alerts well below the cap. An agent in an unintended loop can burn through tokens fast.

Honest Limitations (Day Two)

Every launch coverage article leaves these out. Here's what to actually watch for.

It's in public beta. Launched April 8, 2026. Production reliability across months of operation is unproven — early adopters are big names but widespread battle-testing takes time. Treat it as production-capable but not yet production-hardened.

Rate limits still apply. Existing Claude API rate limits don't disappear because you're using Managed Agents. If you're running 50 agents in parallel that all burn through tokens, you'll hit ceilings. Managed Agents endpoints are additionally rate-limited per organization, and Anthropic hasn't published specific numbers for the beta yet.

Lock-in is real. Once your agents run on Anthropic's infrastructure, with their tools, their session format, and their sandboxing, switching to another provider is non-trivial. This is not a dealbreaker — all SaaS has switching costs — but it's a consideration worth naming.

The advanced features you probably want are in research preview. Outcomes (self-evaluation against success criteria), multi-agent coordination, and persistent memory all require a separate access request and aren't generally available yet.

Cost predictability on long-running agents is tricky. Idle time being free is great. But if your agent enters an unintended loop of active work — say, a web search that keeps triggering more searches — the bill can climb fast. Budget alerts are mandatory.

Who Should Adopt This Now vs. Wait

Adopt now if:

You're already on Claude models for your agent workloads
You've been maintaining an n8n / LangGraph / custom harness setup and the infrastructure tax is killing your velocity
Your use case is long-running async work — research, document processing, content pipelines, lead enrichment
Governance, audit, and scoped permissions are required for your buyers to sign off

Wait if:

You need multi-model orchestration across Claude, GPT, and open-source models in the same agent loop
Your workload is simple deterministic automation better served by n8n or Zapier
You operate in a jurisdiction with strict data residency rules Anthropic doesn't yet meet for your data class
You need features that are still in research preview (multi-agent coordination, persistent memory)

FAQ

What is Claude Managed Agents? Claude Managed Agents is a hosted service on the Claude Platform that provides the full runtime for production AI agents — including sandboxed code execution, checkpointing, credential management, scoped permissions, identity management, and execution tracing. You define the agent; Anthropic runs it.

When was it launched? Public beta launched April 8, 2026. All endpoints require the managed-agents-2026-04-01 beta header.

How much does it cost? Standard Claude API token rates for model usage, plus $0.08 per session-hour of active runtime, plus $10 per 1,000 web searches. Idle time is not billed.

How does it compare to n8n? n8n is a workflow automation tool with AI features bolted on. Managed Agents is an agent runtime — purpose-built for open-ended reasoning tasks where the next step depends on the previous result. Use n8n for deterministic pipelines; use Managed Agents for autonomous agent work.

Can I self-host it? No. Managed Agents is a hosted service exclusively on the Claude Platform. If you need self-hosting, LangGraph or a custom harness is the right answer.

What launch customers are using it? Notion, Rakuten, Asana, Atlassian, and Sentry are public launch customers, with use cases ranging from coding agents to productivity teammates to document processing.

Do I need to be a developer to use it? For basic use cases, no — you can define agents in natural language through the Claude Platform UI. For anything production-grade, working knowledge of APIs and YAML is essentially required.

The Bottom Line for European Businesses

If you've been watching the agent space wondering when it becomes real for businesses that don't have a dedicated AI engineering team, this is probably that moment. Not because Managed Agents is perfect — it's a beta product with real limitations — but because it's the first credible "we handle the infrastructure" offer from a frontier lab that's both priced sanely and architected seriously.

For European SMBs and mid-market companies, the practical implication is that the build-vs-buy math just changed. Building a production agent used to mean a three-to-six month infrastructure project plus ongoing maintenance. Now it means writing a good specification and paying $0.08 per active hour. That shifts "should we ship an agent for this workflow?" from a capex decision to an opex decision.

If you're a founder, CTO, or operator trying to figure out what to actually do with this — not just nod knowingly on LinkedIn — that's the conversation we have at areza.digital every week. We help European businesses design, build, and run production AI agents. Book a 30-minute discovery call →

Written by Nikita Janochkin, founder of areza.digital. Sources: official Claude Platform documentation (platform.claude.com/docs), Anthropic engineering blog "Scaling Managed Agents: Decoupling the brain from the hands," claude.com launch announcement, The New Stack, SiliconANGLE, FindSkill.ai, Epsilla engineering blog. Pricing and feature availability verified against live docs as of April 9, 2026. Last updated April 9, 2026.

Stop losing leads to a slow website

Book a free friction audit and see exactly where your website is leaking money.

Book a call →