Claude Managed Agents: The Build-vs-Buy Decision for AI Agent Infrastructure

What Managed Agents actually gives you

Most coverage of Claude Managed Agents stops at the headline: Anthropic runs your agent infrastructure for you. What that means in technical terms is more specific.

When you configure an agent through Managed Agents, you get two things your team would otherwise have to build.

First is the execution harness: an orchestration layer that manages the observe-think-act loop, decides when to call each tool, handles context as it grows, and recovers execution when something breaks mid-task. This isn’t a thin API wrapper. It’s the same architecture Anthropic uses internally for its own agent systems, now exposed as a service.

Second are pre-configured cloud containers: environments with Python, Node.js, and Go pre-installed, network access rules configured, and support for mounting your own files into the execution environment. The agent runs in these containers. You don’t touch the underlying compute.

The configuration surface is well-designed. To activate the full toolset, you pass agent_toolset_20260401 when creating the agent. You can disable specific tools or override their settings from there. Custom tools are also supported: your application executes the tool, returns the result to the API, and Claude continues the task. All endpoints require the managed-agents-2026-04-01 beta header.

One detail worth understanding: guardrails run at the infrastructure layer, not just in the system prompt. You define what URLs the agent can reach, what files it can read, what operations it can execute. This is meaningfully different from prompt-only constraints, which degrade when context grows long or edge cases appear that the original prompt didn’t anticipate.

The actual cost of building your own

Before Managed Agents, shipping a production agent meant building most of this from scratch. Teams consistently underestimate how long it takes.

The agent logic itself, the prompting, tool definitions, and task design, typically takes 1-2 weeks for a focused team with a clear use case. The infrastructure to run it reliably in production is where timelines collapse.

Containerization, execution loop management, timeout and retry handling, logging and observability, network security, file mounting, context window management at scale: none of this is novel engineering, but all of it takes time. In our work building AI and LowCode systems at Kreante across 165+ production projects, that phase consistently runs 4 to 8 weeks of backend engineering time even for teams that have done it before.

The cost in headcount terms: a senior DevOps or backend engineer in the US runs $120,000 to $180,000 in annual total compensation. Even if they’re only spending 30% of their time on agent infrastructure, that’s $36,000 to $54,000 per year in engineering cost generating zero business value.

Managed Agents converts that fixed overhead to a variable cost tied directly to agent usage.

How the pricing math actually works

Runtime is billed at $0.08 per hour of execution, independent of what the agent does during that time. Token costs are additive at standard Claude API pricing.

A few concrete scenarios to calibrate against:

An agent handling internal operations tasks, triggered by events and active roughly 4 hours a day across 22 working days, runs 88 hours of monthly runtime. That’s $7.04 in runtime fees. Token costs scale with context length and task complexity, but for moderate-volume internal automation, total monthly cost for this agent is likely under $50.

An agent running continuously (24/7) for monitoring, data processing, or customer-facing workflows accumulates 720 hours of runtime per month, about $57.60 in runtime fees. Add tokens for a busy agent processing significant text volume, and you’re looking at $150 to $400 per month total for a genuinely high-throughput use case.

The relevant frame isn’t whether those numbers are cheap. It’s what you’d spend to achieve equivalent reliability with self-managed infrastructure: ongoing DevOps attention for updates, scaling events, security patches, and incidents. That overhead doesn’t disappear when the agent is idle. Managed Agents does.

Who’s already shipping with it

Three early adopters were featured at launch. Each illustrates a different pattern.

Notion has the platform in private alpha. Teams assign work directly to Claude within Notion workspaces. Dozens of tasks run in parallel; people collaborate on the outputs without leaving their existing workflow. Eric Liu from Notion noted that offloading infrastructure let their engineering team focus on the collaborative experience rather than container management.

Asana built AI Teammates: agents that appear as team members inside Asana, receive task assignments the same way any human would, and execute them. Their engineering time went to the multiplayer product experience, not to runtime plumbing.

Sentry adopted the platform in early access. Given Sentry’s core product is error monitoring and debugging, the likely use case is automated triage and incident analysis, categories where agents significantly reduce time-to-response.

The shared pattern: engineering capacity went to the differentiating product because infrastructure was already handled.

Build vs. buy: a decision framework

The choice is clean when you map it to your actual constraints.

Managed Agents makes sense when: Infrastructure is your bottleneck, not your advantage. If your team is spending time on containers, retry logic, and execution loops rather than on what the agent actually does, you’re not building anything proprietary. Managed Agents removes that entirely.

You don’t have dedicated DevOps coverage. Most product teams and agencies don’t. Running agent infrastructure without it creates fragility that shows up at the worst time.

You need to get to production in weeks. The fastest path from a working prototype to a production-grade agent with proper error handling, security, and observability is to use Managed Agents. Building your own extends that by months.

Build your own when: You have hard infrastructure constraints: on-premise deployment, air-gapped networks, specific data residency requirements in jurisdictions where Anthropic’s cloud doesn’t operate, or hardware requirements for specialized workloads.

You’re at a scale where self-hosted economics flip. At very high volumes (millions of agent-hours per month), the math changes. That’s a problem most teams won’t face in their first 12 months.

You need to run a different model. Managed Agents is Claude-specific. If your architecture requires mixing models or running open-source LLMs for specific tasks, you’re managing your own runtime regardless.

For the majority of product teams building their first or second production agent, the first category is the relevant one.

What this changes about how AI products get built

The more significant shift isn’t operational. It’s about where engineering judgment goes when infrastructure is commoditized.

Remy Gasill, who built one of the most-distributed agent architectures in early 2026, articulates the underlying principle clearly: the 3 inputs a builder actually controls are the prompting, the knowledge available to the agent, and the tools it can call. Everything else is execution overhead. When execution overhead is a solved problem, the quality gap between teams is determined entirely by how well they define those 3 things.

For agencies building AI products for clients, this has a concrete implication. A project that previously needed a DevOps budget line now doesn’t. The same total budget can go deeper into agent design quality, user research, or iteration cycles before launch.

The projects that stall, in our experience at Kreante, aren’t the ones where the agent logic is wrong. They stall on infrastructure: getting a reliable execution environment set up, keeping it running under load, handling the edge cases that only appear in production. Managed Agents takes that class of problem off the table.

Where to start

The public beta is live on the Claude Platform. The quickstart is at platform.claude.com/docs/en/managed-agents/quickstart.

For teams migrating an existing prototype from Claude Code or another harness: define your tool schemas in the Managed Agents format, update your API calls to include the beta header, and the execution harness takes over the loop you were managing manually. The migration surface is limited.

For teams starting from scratch: the quickstart covers the minimum configuration for a functional agent in a managed environment. The design work that follows is the actual product work: what tasks the agent handles, what tools it needs, and what guardrails are appropriate for your use case and your users.

Beta is the right time to evaluate it. Pricing and feedback access during beta are typically better than post-GA.