Claude Managed Agents Goes Public: Anthropic Will Run Your Agents For You

Anthropic shipped Claude Managed Agents in public beta today, April 8, 2026. It’s a fully managed agent harness, which is a phrase that sounds dry until you realize what it actually is: Anthropic is now running the container, the sandbox, the tool loop, the streaming layer, and the memory for you. You hand in a YAML file, you get back a running agent. Shipping production agents used to be months of infrastructure work. Anthropic wants that to be an afternoon.

Introducing Claude Managed Agents: everything you need to build and deploy agents at scale.

It pairs an agent harness tuned for performance with production infrastructure, so you can go from prototype to launch in days.

Now in public beta on the Claude Platform. pic.twitter.com/vHYfiC1G56
— Claude (@claudeai) April 8, 2026

The announcement is in Anthropic’s April 8 release notes, alongside a second launch that’s arguably just as important: a new command-line tool called ant that makes every Claude API resource, including Managed Agents, versionable as YAML files in your repository.

What You Actually Get

The product is organized around four concepts, lifted straight from the Managed Agents overview:

Agent. A reusable definition: model, system prompt, tools, MCP servers, skills. You create it once and reference it by ID.
Environment. A container template: Python, Node, Go, whatever packages you want, plus network rules and mounted files.
Session. A running agent instance inside an environment, chewing through a specific task.
Events. The messages flowing in both directions. User turns in, tool results out, streamed over server-sent events.

The key capability is that Claude runs autonomously inside a secure container you didn’t have to build. The harness gives it bash, file operations (read, write, edit, glob, grep), web search, web fetch, and MCP server connections out of the box. Tool execution happens server-side. Prompt caching and compaction are built in. Sessions are stateful, so the file system and conversation history persist across interactions, and you can steer or interrupt the agent mid-execution by sending new user events.

That last part is not a small detail. Every team that has tried to run Claude as a long-horizon agent in production has rebuilt the same stack: sandboxed code execution, checkpointing, credential management, scoped permissions, end-to-end tracing, recovery from errors. Anthropic is now offering all of it as a primitive, and according to The New Stack’s coverage, Anthropic claims this speeds up prototype-to-launch by roughly 10x.

The ant CLI, Which Is the Other Story

Launched on the same day: ant, a command-line client for the Claude API. On first read it sounds like an httpie for Anthropic. That undersells it.

Every API resource becomes a subcommand. You can pipe YAML into ant beta:agents create, and you can version-control that YAML in your repo. The CLI reference shows the full pattern:

# summarizer.agent.yaml
name: Summarizer
model: claude-sonnet-4-6
system: |
  You are a helpful assistant that writes concise summaries.
tools:
  - type: agent_toolset_20260401

Then:

ant beta:agents create < summarizer.agent.yaml

Check the YAML into git, update it through CI, and treat your agents like you treat Terraform resources. The CLI also ships GJSON-based response transforms, automatic pagination on list endpoints, an interactive TUI explorer (--format explore), and shell completions for bash, zsh, fish, and PowerShell. Beta resources automatically send the right anthropic-beta header. You do not need to remember it.

One quiet line in the docs is probably the most important detail for anyone already living in the terminal: “Claude Code understands how to use ant natively.” Which means you can ask Claude Code things like “pull the events for session session_01... and tell me where the agent got stuck,” and it will shell out to ant, parse the output, and reason over it. No custom integration code. This is Anthropic building the same agent infrastructure into its own developer tools that it’s now selling to everyone else.

What It Looks Like In Code

A minimal Managed Agents quickstart from Anthropic’s getting-started guide, in Python:

from anthropic import Anthropic

client = Anthropic()

agent = client.beta.agents.create(
    name="Coding Assistant",
    model="claude-sonnet-4-6",
    system="You are a helpful coding assistant. Write clean, well-documented code.",
    tools=[{"type": "agent_toolset_20260401"}],
)

environment = client.beta.environments.create(
    name="quickstart-env",
    config={"type": "cloud", "networking": {"type": "unrestricted"}},
)

session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
    title="Quickstart session",
)

with client.beta.sessions.events.stream(session.id) as stream:
    client.beta.sessions.events.send(
        session.id,
        events=[{
            "type": "user.message",
            "content": [{
                "type": "text",
                "text": "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
            }],
        }],
    )
    for event in stream:
        if event.type == "agent.message":
            for block in event.content:
                print(block.text, end="")
        elif event.type == "agent.tool_use":
            print(f"\n[Using tool: {event.name}]")
        elif event.type == "session.status_idle":
            break

Three API objects, one streaming loop, no container orchestration. The agent writes the file, runs it in the sandbox, verifies the output, and emits session.status_idle when it’s done.

The one catch: all Managed Agents endpoints require the managed-agents-2026-04-01 beta header. The official SDKs add it automatically. If you’re hand-rolling HTTP, you have to include it.

Pricing: The Session-Hour

Pricing is where Managed Agents gets interesting, because it introduces a new unit of billing that most teams haven’t had to think about before. According to the PYMNTS coverage, Managed Agents charges:

Standard API token prices for the underlying model (so Sonnet 4.6 is still $3/$15 per million tokens, Opus 4.6 is $5/$25).
$0.08 per session-hour of active runtime.
$10 per 1,000 web searches when the agent uses the built-in search tool.
Idle time does not count toward session runtime.

The session-hour charge is small in absolute terms but matters at scale, because agents running in cloud containers with network access and tool execution are not free to host. $0.08/hour is Anthropic’s line in the sand for what it costs to run a sandboxed container with a Claude-controlled tool loop on top of it. If you build your own equivalent on AWS, you’re probably paying more than that once you factor in orchestration and the engineer-hours to maintain it.

Rate limits are per organization: 60 create requests per minute, 600 read requests per minute. Normal account-tier rate limits also apply.

What’s Still Research Preview

Not everything announced today is open to every API account. Three features are gated behind a request form and labeled research preview:

Outcomes. A way to define what “done” means for an agent, so it knows when to stop.
Multi-agent. Running and orchestrating multiple agents together in a single workload.
Memory. Persistent memory that outlives any single session.

Outcomes is the interesting one. Most agent frameworks today decide when to stop by running out of budget or hitting a max-turn limit. An explicit outcome definition is a different philosophy: you tell the model the success criteria, and it keeps going until those criteria are verifiably met. If Anthropic can make this work reliably, it meaningfully changes what “agentic” means in production.

The Context: Anthropic Is Building a Walled Garden

Managed Agents does not arrive in a vacuum. Earlier this month, Anthropic started enforcing a policy that cut off third-party agent harnesses like OpenClaw from using Claude subscriptions, restricting those subs to first-party tools like Claude Code and Claude Cowork. Boris Cherny confirmed the enforcement will expand to all third-party harnesses.

Read those two announcements together. Anthropic is saying: if you want to run Claude as an agent, your options are narrowing to the first-party surfaces (Claude Code, Claude Cowork) or Managed Agents on the API. The Messages API is still there for teams that want to build their own loop, but the easy on-ramps for third-party agent frameworks are getting quietly removed.

This is not a coincidence, and it’s not hostile. It’s Anthropic pulling the agent runtime in-house so it can ship performance, reliability, and safety guarantees as a single product rather than leaving those concerns to whoever happens to wrap the API. There’s also a branding note in the Managed Agents overview that’s worth reading if you’re a partner: you can use “Claude Agent” or “YourAgentName Powered by Claude” in your product, but not “Claude Code Agent” or “Claude Cowork Agent.” The namespace is reserved.

What It Means

Four takeaways.

First, if you’ve been running Claude agents in production on your own infrastructure, you should evaluate whether Managed Agents replaces any of it. The tool set is comprehensive, the pricing is reasonable, and the harness gets the prompt-caching and compaction optimizations that Anthropic knows best how to tune. Anyone who has hand-rolled a sandbox-with-bash-and-file-ops will recognize how much work Anthropic just absorbed.

Second, the ant CLI is a bigger quality-of-life improvement than the release notes make it sound. YAML-defined agents checked into git and updated through CI is the right developer experience for this class of resource. It’s the pattern Kubernetes normalized for infrastructure, and it’s arriving for agents now.

Third, the $0.08 session-hour is a number to remember. It’s the first public price on “running a Claude agent as a service,” and every future comparison (AWS Bedrock, Google Vertex agent services, whatever OpenAI eventually ships) will be measured against it.

Fourth, Anthropic’s agent strategy is now clearly vertical. First-party products (Claude Code, Cowork), a first-party runtime (Managed Agents), a first-party CLI (ant), and a tightened policy around third-party harnesses. If you’re building on Claude and you’re not already on one of those rails, this is the moment to map your architecture to one.

Managed Agents is available today on the Claude Platform with the managed-agents-2026-04-01 beta header. The ant CLI installs via brew install anthropics/tap/ant or from the GitHub releases. Outcomes, multi-agent, and memory are research preview with a waitlist.