Claude Managed Agents: The April 2026 Cloud Deployment Guide

Anthropic launched Claude Managed Agents on April 8, 2026, and it is the first serious attempt by a frontier model provider to own the infrastructure layer for agent execution. The pitch is simple: you write the agent logic, Anthropic runs it in an isolated container, bills you by model tokens plus a runtime rate, and hands you observability by default.

We deployed three production workflows to Managed Agents in the week after launch (a customer support triage bot, a code review agent, and a nightly data enrichment pipeline) and this guide is the engineering write-up.

What Managed Agents Actually Is

Claude Managed Agents is Anthropic's cloud-hosted runtime for long-running agent workflows. Each agent you deploy gets:

• An isolated Linux container, spun up on demand
• A Claude model attached (Opus 4.6, Sonnet 4.6, or Haiku 4.5)
• Filesystem access scoped to the container
• Outbound network access with per-agent allow/deny lists
• Built-in MCP server connections (filesystem, bash, web search, custom HTTP)
• Structured event logging streamed to Anthropic's observability UI or exported via API
• Optional persistent storage that survives between runs

The mental model is "serverless agent runtime." You do not manage the VM, the runtime, or the orchestrator. You deploy a definition, trigger runs (HTTP, webhook, cron, or programmatic), and read results.

Pricing

Two meters run in parallel:

Meter	Rate (April 2026)	Notes
Model usage	Standard Claude API rates	Input, output, cache hits all billed as normal
Runtime	$0.08 per agent runtime hour	Billed per second, $0.0000222/sec

Runtime is prorated from container spin-up to final message. A 30-second agent invocation costs ~$0.0007 in runtime plus model tokens. A four-hour overnight data enrichment agent costs $0.32 in runtime plus model tokens.

There is no storage fee for the first 10GB of persistent disk per agent. Network egress is included up to 100GB/month per agent.

Compared to the DIY alternative (AWS Lambda + container + DynamoDB + CloudWatch + IAM + VPC + MCP orchestration), the Managed Agents fully-loaded cost was lower for every workload we tested below 1,000 agent-hours per month. Above that threshold, DIY on AWS is cheaper — but you pay in engineering hours.

Deploying Your First Agent

An agent is defined by a YAML config and a prompt file. The minimum viable deployment looks like this:

# agent.yaml
name: support-triage
model: claude-haiku-4-5
system_prompt: ./prompt.md

mcp_servers:
  - type: filesystem
    path: /workspace
    permissions: [read, write]
  - type: http
    url: https://api.zendesk.com
    headers:
      Authorization: ${ZENDESK_TOKEN}

triggers:
  - type: webhook
    path: /new-ticket
  - type: cron
    schedule: "*/15 * * * *"
    input: "Review open tickets older than 4 hours"

timeout: 600  # seconds
max_iterations: 20

observability:
  log_level: info
  capture_tool_calls: true
  capture_reasoning: false  # false for privacy-sensitive workloads

Deploy with the Anthropic CLI:

anthropic agents deploy --config agent.yaml

The CLI returns an agent ID, a webhook URL, and a dashboard link. First deploy-to-running takes about 45 seconds.

Observability

This is where Managed Agents earns its keep versus rolling your own. Every agent run produces a structured trace:

Event type	Captured data
run_started	trigger source, input payload, model, budget
reasoning	model's thinking trace (optional, off by default)
tool_call	tool name, arguments, container state
tool_result	return value, latency, errors
message	model output at each step
run_completed	final output, token counts, total cost
run_failed	error details, stack trace, state at failure

The observability UI renders these traces as a timeline. You can click into any tool call to see exact arguments and responses, and you can replay a run with modifications (different input, different system prompt) to debug regressions.

For teams running Claude Code locally, the UX is familiar — this is the same execution model applied to a hosted context.

Isolation: What Actually Runs Where

Each agent runs in a gVisor-isolated container on Anthropic infrastructure. Network egress is default-deny; you explicitly allow domains in the config. Filesystem access is scoped to a writable /workspace and a read-only /source. There is no shared state between agents unless you explicitly wire it through an external system.

This is meaningfully better isolation than most teams get running their own agents on a shared VM, and it matters because production agents run untrusted model-generated commands. A prompt-injection attack that would have catastrophic blast radius on a shared EC2 instance is contained to a single container run on Managed Agents.

Pay once, own it

Skip the $19/mo subscription

One payment of $69 replaces years of monthly billing. 50+ AI models, yours forever.

Get Lifetime — $69

Three Workloads, Three Outcomes

Workload 1: Customer Support Triage

10,000 incoming tickets per month, each classified and routed. Agent runs Haiku 4.5, averages 3.2 seconds per ticket, uses 1,200 input tokens + 400 output tokens per run.

Cost line	Monthly cost
Model tokens	$28
Runtime	$7.10
Observability, logs, storage	$0
Total	$35.10

Previously ran on AWS Lambda + custom orchestration: $82/month plus roughly 4 hours/month of engineer time. Managed Agents cut the bill 57% and eliminated the ops load.

Workload 2: Code Review Agent

Triggered on every PR opened against our backend repo. Reads the diff, runs automated checks, leaves comments. Uses Sonnet 4.6 because Haiku consistently missed subtle issues.

Average PR takes 4.5 minutes of agent runtime. ~800 PRs/month.

Cost line	Monthly cost
Model tokens	$186
Runtime	$4.80
Total	$190.80

Runtime is negligible here. Model usage dominates, which is the typical pattern for any agent using Sonnet or Opus.

Workload 3: Nightly Data Enrichment

Processes 5,000 records nightly, each requiring 2-3 API calls and LLM reasoning. Runs ~3.5 hours end-to-end. Uses Haiku 4.5 for most records, escalates to Sonnet 4.6 for complex ones.

Cost line	Monthly cost (30 nights)
Model tokens	$340
Runtime (3.5h × 30 × $0.08)	$8.40
Storage (persistent progress state)	$0
Total	$348.40

The runtime meter barely registers because Claude token usage dwarfs it. For long-running agents, the economics are essentially "Claude API costs plus small overhead."

What Doesn't Work Yet

Four limitations we hit that are worth knowing before you commit:

No GPU workloads. Managed Agents does not support GPU-accelerated containers. If your agent needs to run local ML inference (image embedding, local LLM fallback, audio transcription), it has to call an external service.

Max 24-hour runs. Hard ceiling. Longer workflows must checkpoint and restart.

Limited language runtimes pre-installed. Containers ship with Python 3.12 and Node 22 by default. Go, Rust, Ruby, Java require custom container definitions, which add 2-3 minutes to cold start.

No MCP server installation at runtime. MCP servers must be declared at deploy time. You cannot have the agent dynamically add servers mid-run. This is a deliberate security constraint that we agree with, but it surprised us coming from local Claude Code where adding MCP servers mid-session is common.

When to Use Managed Agents vs Alternatives

If you need...	Use
Hosted agent runtime with minimal ops	Claude Managed Agents
Agents with GPU or specialized runtime	DIY on AWS/GCP/Modal
Ultra-low-latency sub-100ms agent calls	In-process library (Anthropic SDK)
Agents in your VPC with private data	Claude on Bedrock + your own orchestration
Maximum cost optimization at >10K agent-hours/month	DIY on container platform
Multi-provider model flexibility	LangGraph/LlamaIndex on your infra

For the median team — 10 to 500 agent-hours per month, wanting MCP tool access, wanting observability, not wanting to manage infrastructure — Managed Agents is now the default answer.

Migration Notes

If you have agents already running on LangChain, LlamaIndex, or custom orchestration, the migration path is:

1. Port your tool definitions to MCP servers (see our MCP production server tutorial for the pattern).
2. Rewrite your system prompt as a standalone markdown file.
3. Define triggers (webhook, cron, programmatic) in YAML.
4. Deploy, validate with a test input, then cut over traffic incrementally.

The porting step is a one-to-two-day effort for a typical agent. We have not yet seen a case where the finished Managed Agents deployment was harder to reason about than the original custom stack it replaced.

The Bigger Shift

Claude Managed Agents is the first cloud product from a frontier lab that treats agents as a first-class compute primitive. AWS, GCP, and Azure will ship competing services within six months — Google's Vertex AI agents are already close. The net effect is that "run an agent" will be as commoditized by 2027 as "run a container" is today.

For engineering teams, the right move in April 2026 is to treat agent infrastructure as ephemeral. Build your agent logic (prompts, tool definitions, evals) so it is portable across runtimes, because which runtime wins in 2027 is not obvious and the switching cost needs to be small.

AI Magicx uses a mix of Managed Agents and self-hosted MCP runners depending on workload shape. Try AI Magicx to see agent-powered content workflows built on this architecture.