Claude Agent SDK vs Claude Managed Agents: Which Should You Run in Production?

Anthropic ships two ways to put a Claude agent into production, and they are easy to confuse because both run essentially the same agent loop.

The Claude Agent SDK is a library, available in Python and TypeScript, that runs that loop inside your own process, on your own infrastructure. Claude Managed Agents, launched in April 2026, is a hosted REST API where Anthropic runs the harness, the sandbox, and the session log for you.

The capabilities overlap almost entirely. Both give the model code execution, file manipulation, bash, web browsing, and MCP tool integrations. So the decision is not really about what the agent can do. It is about who operates the runtime, who absorbs the failure modes, and how you get billed for it.

This guide covers what each one is, when each wins, and the constraint they both share that neither page in Anthropic's docs will frame for you.

What Is the Claude Agent SDK?

The Claude Agent SDK is the same agent loop that powers Claude Code, packaged as a library you can run yourself. You import it, define your tools, and execute the loop inside your own service: a background worker, an API handler, a container in your cluster.

Because the loop runs in your process, you own everything around it. You define each step, the fallbacks, the error states, the retry logic, and where session state lives. You also own the operational surface: scaling the workers, provisioning sandboxes if your agent executes code, and keeping the whole thing alive across restarts.

That ownership is the entire value proposition. If your agent needs to run inside an existing service, share a database transaction with your application, respect infrastructure that already exists, or stay inside a network boundary your compliance team drew, the SDK is the only one of the two that can do it. Anthropic's own guidance is to prototype with the Agent SDK and graduate to Managed Agents for production. That is reasonable advice for most teams, and exactly backwards for teams whose constraint is the infrastructure.

Best for: Teams who need the agent loop to run inside their own systems and are willing to operate it.

What Is Claude Managed Agents?

Claude Managed Agents is the hosted version. You call a REST API, and Anthropic runs the harness, provisions and tears down the sandbox, manages context across a long session, and persists the session log. There is no runtime for you to operate.

Pricing is standard Claude token rates plus a per-session-hour charge for active runtime, reported at $0.08 per session-hour with the first 50 hours per day free across all sessions. That free allowance matters more than it first appears: for teams running a modest number of agent sessions, the runtime cost rounds to zero and the entire bill is tokens.

The tradeoff is that the run happens on Anthropic's infrastructure. Your agent's reasoning trace, tool inputs and outputs, and intermediate files all live there for the duration of the session. For most teams that is fine. For anyone with a VPC requirement, data residency obligations, or an air-gapped environment, it is a hard stop rather than a preference.

Best for: Teams running multi-hour agent workloads who want zero operational burden and have no data residency constraint.

When to Choose the Claude Agent SDK

You need the loop inside an existing service. If the agent has to share a transaction, call internal services over a private network, or run as one step in a larger pipeline, embedding the SDK is the only option that fits.

Compliance draws a boundary around your infrastructure. VPC-only, on-prem, or air-gapped deployments rule out the hosted path entirely. The SDK runs wherever your code runs.

You want predictable, token-only costs. Without a runtime charge, your bill is a direct function of tokens. For high-volume workloads past the free session-hour allowance, that predictability is easier to model and cap.

You need to customize the loop itself. Custom retry semantics, unusual tool-approval logic, or a bespoke context strategy require access to the loop, which the hosted API abstracts away by design.

When to Choose Claude Managed Agents

Long-running, multi-hour tasks. Session persistence, context management, and sandbox lifecycle across a multi-hour run are genuinely hard to build well. This is what the managed option is for.

You have no appetite for operating a runtime. Small teams without platform engineering support get to production dramatically faster by not owning workers, sandboxes, and session storage.

Your volume sits inside the free allowance. If your usage fits comfortably within the free session-hours, you get managed infrastructure at token-only cost, which beats self-hosting on economics alone.

You are committed to Claude regardless. If the model decision is settled for reasons beyond cost, the main argument for a self-operated runtime weakens considerably.

The Constraint Both Options Share

Here is what the comparison above cannot resolve, because it is true of both: the Claude Agent SDK and Claude Managed Agents are both Anthropic-only.

Self-hosting the SDK buys you infrastructure control. It does not buy you model control. Every task still runs on a Claude model, which means every task is billed at frontier rates regardless of whether it needed frontier capability. On an agent that runs thousands of times a day, most tasks do not.

This matters because the model is where the money is. The agent loop re-processes the system prompt and tool definitions on every turn, and every tool round-trip ships the growing context back to the model. The single largest cost lever available to any agent platform is routing a task to a cheaper model when the task does not need an expensive one, and neither of these options exposes it.

So the real decision space is larger than two options. Alongside "who hosts it," there is "which model runs it". And that question is only available if the agent harness itself is model-neutral.

TrueForge: An Open-Source Alternative to Claude Managed Agents, Up to 75% Cheaper

TrueForge is TrueFoundry's open-source, vendor-neutral agent harness for teams that want more control over how their agents run in production. Instead of tying the runtime to a single model provider, TrueForge lets you bring your own models, MCP servers, and infrastructure while handling the agent loop, tool execution, context management, approvals, and sandboxing.

Where a self-hosted agent like Hermes leaves much of the production infrastructure to the developer, TrueForge provides the surrounding control plane needed to operate agents across teams and environments. This includes centralized MCP access and credentials, human-in-the-loop approvals, sandboxed execution, observability, and governance.

You can run it locally with npx @truefoundry/trueforge or deploy it for a team with Docker Compose or Helm.

TrueForge also separates the agent runtime from the model layer. This means teams can switch models or route workloads to different providers without rebuilding the agent itself.Combined with TrueFoundry's AI Gateway, teams can also apply model routing and cost controls to avoid using expensive frontier models for tasks that don't require them. The result is a middle ground between a fully managed runtime and building the entire agent infrastructure yourself: an open-source agent harness with the operational controls needed to run production agents at scale.‍

In TrueFoundry's benchmark against Claude Managed Agents, TrueForge reached roughly the same task accuracy while using about 40% as many tokens when both were run on Opus 4.8, making it about 30% cheaper per run. When the same benchmark was run with GLM-5.2 on TrueForge, it achieved the same ~11/14 task score at about $2.90 per run versus $11.80 for Claude Managed Agents, roughly 75% lower cost.

TrueFoundry also provides a second lever for reducing model costs through AI Gateway's Auto Routing. Instead of sending every request to a frontier model, Auto Routing classifies requests by complexity and routes them to different model tiers. In TrueFoundry's benchmark across 550 prompts, routing between Haiku, Sonnet, and Opus reduced cost by 69% while retaining 98% of baseline quality, and mean latency dropped from 7.6 seconds to 4.0 seconds. On production-shaped traffic, the overall cost reduction reached 80%.

These two layers address different parts of the cost equation. TrueForge reduces the overhead of running the agent itself, while model routing lets you avoid using an expensive model when the task doesn't require one. For teams running agents at scale, having both controls can matter more than the price of the model alone.

TrueForge is open source and MIT licensed, while TrueFoundry's AI Gateway adds the operational layer teams need when moving from individual agents to production: centralized model access, budgets, guardrails, credential management, and unified traces.

If you're comparing Claude Managed Agents with a more configurable architecture, TrueFoundry is worth considering when model flexibility, infrastructure control, and agent cost optimization matter alongside the agent runtime itself.

An Open-Source Alternative to Claude Managed Agents, Up to 75% Cheaper

Run production-ready AI agents on your own infrastructure with TrueForge, using your choice of models, tools, and sandbox providers.

View on GitHub

Docs

FAQ

Q: What is the Claude Agent SDK?

‍A: The Claude Agent SDK is a Python and TypeScript library that runs the same agent loop powering Claude Code inside your own process and infrastructure. You get full control over the loop, tools, retries, and session state, and you take on responsibility for hosting, scaling, and sandboxing.

Q: What is the difference between Claude Agent SDK and Claude Managed Agents?

‍A: The Agent SDK is a library you run yourself; Managed Agents is a hosted API where Anthropic runs the harness, sandbox, and session log. Capabilities largely overlap. The difference is who operates the runtime and how you are billed. The SDK charges tokens only; Managed Agents adds a per-session-hour runtime charge.

Q: Is the Claude Agent SDK free?

‍A: The SDK itself carries no separate platform fee. You pay standard Claude API token rates for what your agent consumes, plus whatever your own infrastructure costs to run.

Q: Can either option run non-Claude models?

‍A: No. Both the Claude Agent SDK and Claude Managed Agents are Anthropic-only, so every task runs on a Claude model regardless of whether it needed frontier capability. Routing tasks across open models like Llama, GLM, or Qwen requires a model-neutral harness such as TrueForge.

Q: Can I run an agent harness in my own VPC or on-prem?

‍A: With the Agent SDK or an open-source harness, yes. TrueForge runs from a single npx command locally, or via Docker Compose and Helm for team deployments with Postgres, Redis, replicas, and OIDC login. TrueFoundry's managed version also runs self-hosted, on-prem, air-gapped, or hybrid, so no data leaves your domain. Claude Managed Agents does not offer this.

Q: How do I govern models and MCP servers across many agents?

‍A: Through a gateway layer. TrueFoundry's AI Gateway provides 1,000+ LLMs behind one OpenAI-compatible API at roughly ~3–4 ms added latency and 350+ RPS on a single vCPU, with RBAC, budgets, guardrails, and credential rotation, plus an MCP Gateway for tool-level access control and OpenTelemetry traces into Grafana, Datadog, or Prometheus.

Related reading

• Introducing TrueForge: the open-source agent harness we run in production: architecture and design decisions
• TrueForge vs Claude Managed Agents: Up to 75% Cheaper: full Enterprise-Bench methodology and results
• Why Agent Harnesses Should Be Open: the case against renting this layer
• How TrueFoundry's own AskTFY runs on TrueForge: a production agent built on the harness
• TrueFoundry Agent Harness documentation: the managed, governed deployment path

Conclusion

Choosing between the Claude Agent SDK and Claude Managed Agents comes down to a single question: do you need the agent loop to run inside your own infrastructure? If yes, the SDK is the only option that fits. If no, Managed Agents will get you to production faster and, inside the free session-hour allowance, for very little more than token cost.

What neither answers is which model runs the task, and at production volume that is where most of the bill lives. If that is becoming your constraint, see how TrueFoundry's Agent Harness runs the same agent loop on any model, in your own infrastructure.