Anthropic shipped Claude Managed Agents into public beta on Tuesday. It’s an API for running autonomous AI agents inside Anthropic’s own cloud — not yours — and it landed without much fanfare in a week dominated by model benchmarks and pricing posts. Worth a closer look, I think, than it’s been getting.

It’s plumbing rather than spectacle, but it’s the kind of plumbing that changes what you can build on top of it. The Messages API gave you the model. Managed Agents gives you the whole runtime around it.

What managed agents actually is

To understand why this matters, think about who runs the agent loop. Until this week, the answer was always: you do.

First up, the Messages API. You send a prompt, you get a response. If you want the model to use tools, search the web, write a file, run some code, you build the loop yourself. Call the model, parse the tool request, execute the tool, feed the result back, repeat. It’s basically a function call with a very clever engine behind it: arguments in, result out, and anything that happens between those two points is your problem. You’re the one spinning up containers, catching tool errors, keeping state around between calls, and waking up at 3am when a session stalls halfway through.

Second, and this is the new bit, Managed Agents. You define an agent: its system prompt, its tools, its permissions. You define a sandboxed environment with whatever packages and network access it needs. Then you start a session, give it a task, and walk away. Anthropic runs the loop. Anthropic manages the container. Anthropic handles the tool execution, the context, the error recovery, the credentials, and even end-to-end tracing so you can see what the agent actually did.

The whole pitch fits in a sentence: you describe what you want done, and the infrastructure figures out how to do it.

Worth noting on what’s actually shipped: core execution, sandboxing, permissions, persistent memory and tracing are all in public beta as of Tuesday. The more interesting stuff — multi-agent coordination and outcome-driven workflows — is still in research preview, which means it works but Anthropic isn’t promising it’ll work next week the same way it works today.

Why this is more than an API update

There’s a pattern I keep seeing in AI adoption. Every organisation goes through roughly the same progression: chatbot, then copilot, then autonomous agent. Most are stuck somewhere between the first two. They’ve got Claude or ChatGPT in a browser tab, maybe plugged into a coding tool, and they’re using it the way they used to use Google: as a very clever search engine that writes prose.

The jump to autonomous agents has been technically possible for a while. You could build your own agent loop with the Messages API. You could spin up containers, manage state, handle failures. Some people have. But “you could” and “you practically will” are separated by months of infrastructure work that has nothing to do with the actual problem you’re trying to solve.

Managed Agents removes that gap. The underlying models are the same — what’s different is that the operational side has disappeared from your job description. Sandboxing, credential management, session persistence, context compaction, end-to-end tracing, all handled. You’re left with the interesting decisions: what should this agent do, what tools does it need, and what guardrails should it have?

This is the infrastructure moment. The models haven’t suddenly got smarter — what’s changed is how much friction sits between you and actually using them this way. And friction, in my experience, is what determines whether a technology gets used or stays in a demo.

Anthropic’s launch post claims up to a 10-point improvement in task success rates on structured file generation, with the biggest gains on the hardest problems. Take that with the usual pinch of salt — it’s self-reported, there’s no external benchmark, and nobody has independently reproduced it yet. I’d want to see real-world numbers from someone with no commercial interest in the answer. But the mechanism is plausible enough: when the scaffolding is built by the people who built the model, it tends to fit the model better than scaffolding built by everybody else.

From laptop to cloud: a practical example

A practical example, from my own workflow. For the past year or so, I’ve been running AI agents through Claude Cowork — Anthropic’s desktop tool for giving Claude extended tasks with tool access. It works well. The agent can read files, run code, connect to external services through MCP servers, and chew through complex multi-step tasks without me hovering over it.

But Cowork runs on my Mac. If the laptop sleeps, the agent stops. If I’m away from my desk, I can’t kick off a task. If I want two agents running in parallel, one researching and one writing, I can’t. It’s a single-threaded, single-machine setup tethered to whatever device I happen to be sitting in front of.

Now map that onto Managed Agents. Same agent, same system prompt, same tools, same MCP connections to WordPress and Notion and Google Drive — but running in Anthropic’s cloud. I could start a session from my phone, from an iPad, from a webhook triggered by an RSS feed. I could run three sessions simultaneously, each doing different work, each in its own container. If my laptop is off, the work carries on regardless.

The work is no longer coupled to a device. It’s coupled to an API call. That’s a different kind of thing entirely.

The economics are surprisingly sane

The obvious question is cost. Autonomous agents can burn through tokens at a rate that makes your API bill look like a phone bill from 2005.

Managed Agents is billed on two dimensions: tokens and runtime. Tokens are charged at standard API rates, the same as the Messages API. Runtime is $0.08 per session-hour, measured to the millisecond, and only while work is actually happening. Idle time, whether waiting for a tool to return or for you to give the next instruction, doesn’t count. Web searches are metered separately at roughly $10 per thousand.

The runtime charge is almost a rounding error. Where it gets interesting is the token cost, and that’s entirely a function of how you architect the work. Point Opus at everything and let the session balloon, and the bill will sting. Route research to Sonnet and reserve Opus for the parts that actually need it, and the maths looks very different. The same discipline that makes normal API usage affordable — careful prompting, reuse of context, model selection — applies here too, just with higher stakes, because now the loop is making those decisions on your behalf.

I don’t have reliable public benchmarks on what a real-world session costs yet. Nobody does. Give it a month and the numbers will start appearing in blog posts with suspiciously specific dollar amounts. For now, the honest answer is: cheaper than you’d expect, more expensive than you’d like, and almost entirely in your control.

Where this is heading

Right now, Managed Agents is API-only. It’s a developer tool. You need to write code to create agents, start sessions, and handle events. Fine for people building products on top of Claude, but not how most people interact with AI.

For everyone else, AI means Claude’s chat interface: the web app, the mobile app, the desktop app. And that interface already has many of the building blocks: file creation, code execution, web search, MCP connectors. Cowork already demonstrates the concept of giving Claude an extended task and letting it work autonomously.

The logical next step, and I’d be surprised if it doesn’t happen within months, is that Managed Agents infrastructure replaces the local VM that Cowork currently runs on. Instead of your Mac spinning up a container, the work happens in Anthropic’s cloud. Same experience, same interface, but untethered from your device.

Interesting for a few reasons. Claude on an iPad becomes a real work tool rather than just a chat window. You could start a task on your phone during your commute and check the results on your laptop when you arrive. “Give Claude a job and come back later” starts working the way it should — as a background process, not a foreground application.

Whether Anthropic actually takes that step is genuinely unclear to me. They might decide the developer audience is where the value sits and keep the consumer products on the current architecture. Or they might do it next month and I’ll look prescient. I’ve also been wrong about Anthropic’s product roadmap before — I thought Artifacts would quietly get deprecated in favour of Claude Code, and instead they’re still kicking. So take my prediction here as a hunch that feels right, not a forecast I’d bet serious money on.

Zooming out

Under all of this there’s a structural shift worth naming, even though it’s the kind of point that can sound grander than it actually is. The progression from chatbot to copilot to autonomous agent isn’t just about capability; it’s about where the work physically happens and who’s on the hook for keeping it running.

Chatbots live in your browser and copilots live in your IDE, but an autonomous agent doesn’t really have anywhere obvious to live. It needs to persist somewhere, keep running while you’re not watching, survive your laptop going to sleep, and handle the inevitable crashes and retries along the way. Until this week, the honest answer to “where does it live” was “wherever you happen to have built the infrastructure to support it” — which in practice meant autonomous agents were mostly a large-company game. You needed engineers, containers, orchestration, monitoring, the full DevOps stack, and someone whose job it was to worry about all of it.

Managed Agents democratises all that. A solo operator with an API key can now deploy autonomous agents with the same infrastructure an enterprise team would build. The barrier isn’t technical capability any more. It’s imagination — figuring out which parts of your work can be expressed as a task with clear inputs, tools, and success criteria.

This connects directly to an argument I’ve been making for a while: agents are what make this AI wave structural rather than cyclical. Once a single person with initiative can direct multiple agents in parallel, the competitive economics of small teams shift permanently. And I’ve already seen what that looks like in practice, with engineering teams going from 36 people to 30 and nearly doubling throughput. Managed Agents is the infrastructure layer that makes that pattern deployable outside of well-funded engineering orgs.

So the question this technology poses isn’t “can AI do my job?” It’s “which parts of my job are actually just well-defined tasks waiting for someone to describe them properly?”

The people who answer that well are going to have a significant advantage. The technology isn’t secret or expensive. The skill is knowing what to ask for.