13  Claude Managed Agents: Get to Production 10x Faster

13.1 From Local Tool to Managed Platform

On April 8, 2026, Anthropic launched Claude Managed Agents — a suite of composable APIs for building and deploying cloud-hosted agents at scale. The launch addressed a gap that had become increasingly visible: developers could build impressive agent prototypes with Claude Code and the Agent SDK, but deploying them to production — with reliable state management, memory, permissions, and scheduled execution — required building significant infrastructure from scratch.

Managed Agents eliminated that gap by pairing Anthropic’s own agent harness (the orchestration layer that drives Claude Code) with production infrastructure that organizations would otherwise have to build themselves. The pitch was direct: get to production 10x faster by composing managed building blocks instead of reinventing them.

This chapter covers what Managed Agents is, its architecture, key features, pricing, and primary use cases.

13.2 The Problem: Infrastructure Tax on Agent Development

Before Managed Agents, the typical path from agent prototype to production looked like this:

1. Build a prototype using the Claude API or Agent SDK. This part was fast — Claude is capable, and the SDK provides good primitives.
2. Hit production concerns. The prototype worked in a demo, but production needed: persistent state across sessions, memory of past interactions, permission management for sensitive actions, sandboxed code execution, scheduled or long-running execution, observability and auditing.
3. Build the infrastructure. Teams found themselves building (or buying) state stores, memory systems, sandboxing solutions, scheduling frameworks, and observability stacks — none of which were differentiating, all of which consumed engineering time.

The result was an infrastructure tax: a large fraction of agent development effort went into building generic infrastructure rather than the agent’s actual logic. Managed Agents was designed to eliminate this tax.

13.3 What Managed Agents Provides

Managed Agents is a suite of composable APIs, each addressing a specific production concern. You use the pieces you need; they work together when combined.

13.3.1 Anthropic-Managed Harness

At the core is the agent harness — the same orchestration layer that powers Claude Code. The harness manages the agent loop: receiving a task, deciding on actions, calling tools, processing results, and iterating until the task is complete. By offering the harness as a managed service, Anthropic ensured that production agents benefit from the same orchestration quality as Claude Code, without teams having to reimplement it.

13.3.2 State Management

Agents need to maintain state across interactions — what they’ve done, what they’re working on, what they’ve learned. Managed Agents provides built-in state management that persists across sessions, so an agent can be interrupted and resumed without losing progress.

13.3.3 Memory

A dedicated memory layer (covered in Chapter 12) lets agents learn from every session and carry knowledge forward. Memory is scoped, auditable, and programmatically controllable.

13.3.4 Permissions

Agents that take actions in the world (calling APIs, modifying files, executing code) need permission management to ensure they act within authorized boundaries. Managed Agents provides a permission system that gates sensitive actions.

13.3.5 Scheduled Execution

Agents can run on schedules (Chapter 15) — not just in response to user prompts but on cron schedules, enabling proactive and recurring work.

13.4 Key Features

13.4.1 Secure Sandboxing

Agents that execute code — whether running generated scripts, testing changes, or interacting with systems — need secure sandboxes to execute safely. Managed Agents provides managed sandboxes that isolate execution, with network policies, resource limits, and audit logging. (Chapter 14 covers the option to self-host sandboxes on your own infrastructure.)

Note

Sandboxing is the foundation of safe agent deployment. Without it, an agent executing code or calling tools operates with whatever permissions its runtime has — a significant security risk in production. Managed sandboxes isolate execution and enforce policies deterministically.

13.4.2 Long-Running Sessions

Production agents often need to run for hours, not seconds. A coding agent might work on a complex task for an extended period; a research agent might gather and synthesize information over hours; a migration agent might process a large codebase. Managed Agents supports long-running sessions that persist and can be monitored throughout.

13.4.3 Multi-Agent Coordination

For complex tasks, Managed Agents supports multi-agent coordination (Chapter 13) — a lead agent delegating to specialists with their own models, prompts, and tools, working in parallel on a shared filesystem.

13.4.4 Trusted Governance

Enterprise deployment requires governance: audit trails, access controls, compliance posture. Managed Agents provides governance features including audit logs, permission scopes, and observability into every agent action.

13.5 Architecture Overview

┌─────────────────────────────────────────────┐
│              Your Application                │
│                  / API                       │
└──────────────────┬──────────────────────────┘
                   │
        ┌──────────▼──────────┐
        │  Managed Agent APIs  │
        │  (harness, state,    │
        │   memory, perms)     │
        └──────────┬──────────┘
                   │
         ┌─────────┴─────────┐
         ▼                   ▼
  ┌──────────────┐   ┌──────────────┐
  │  Claude API  │   │  Sandbox     │
  │  (inference) │   │  (execution) │
  └──────────────┘   └──────────────┘

The agent loop and orchestration run on Anthropic’s managed infrastructure. Tool execution happens in sandboxes (managed or self-hosted). Your application interacts with the agent through APIs, receiving results and monitoring progress.

13.6 Pricing

Managed Agents pricing has two components:

Component	Cost
Token usage	Standard Claude API token rates
Session-hours	$0.08 per session-hour

The token component is the same as any Claude API usage — you pay for the tokens consumed by inference. The session-hour component covers the managed infrastructure: state management, memory, permissions, scheduling, and the harness itself.

Tip

The $0.08/session-hour model means you pay for active agent time, not for idle infrastructure. An agent that runs for 2 hours to complete a task costs $0.16 in session fees, plus tokens. This aligns cost with usage and avoids the overhead of always-on infrastructure you’re not using.

13.7 Primary Use Cases

13.7.1 Coding Agents

The most direct use case: cloud-hosted coding agents that can work on repositories, run builds, execute tests, and ship code — all in a managed, sandboxed environment. This is Claude Code’s model, deployed as a managed service that teams can invoke programmatically.

13.7.2 Productivity Agents

Agents that handle recurring productivity tasks: triaging email, managing schedules, preparing reports, monitoring dashboards. These benefit from Managed Agents’ memory (learning user preferences over time) and scheduling (running on a cadence).

13.7.3 Finance and Legal Agents

Domain-specific agents for regulated industries: a finance agent that analyzes transactions and flags anomalies; a legal agent that reviews contracts and highlights risks. These use cases benefit from the governance features (audit trails, permission controls) and the ability to run long, thorough analyses.

13.8 Comparison: Managed Agents vs. Building Yourself

Concern	Build Yourself	Managed Agents
Agent harness	Implement and maintain	Provided (same as Claude Code)
State management	Build/buy a state store	Built-in
Memory	Custom solution	Built-in (Chapter 12)
Permissions	Custom authz layer	Built-in
Sandboxing	Set up and secure	Managed or self-hosted options
Scheduling	Cron + infrastructure	Built-in (Chapter 15)
Governance	Custom audit/compliance	Built-in
Observability	Custom tracing/logging	Built-in
Time to production	Weeks to months	Days to weeks

13.9 Getting Started

Managed Agents is accessed via APIs. A typical flow:

1. Create an agent with a specified model, system prompt, and tool set.
2. Configure state and memory scopes.
3. Set up permissions for the actions the agent will take.
4. Deploy — the agent runs on Anthropic’s managed infrastructure.
5. Invoke the agent via API, receiving results and monitoring progress.

# Conceptual API usage
from anthropic import ManagedAgent

agent = ManagedAgent.create(
    model="claude-opus-4-7",
    system_prompt="You are a code review agent...",
    tools=[read_file, run_tests, comment_on_pr],
    memory_scope="project-reviews",
    sandbox="managed"
)

result = agent.run(task="Review PR #1234 for security issues")

13.10 The Composable API Philosophy

A defining characteristic of Managed Agents is its composable design. Rather than a monolithic platform that does everything, it’s a suite of APIs that each handle one concern. You compose the APIs you need and ignore the rest.

13.10.1 The Building Blocks

API	Concern	Composable With
Agent	The agent itself (model + prompt + tools)	All others
State	Persistent state across sessions	Agent, Memory
Memory	Long-term knowledge store	Agent, State
Permissions	Action authorization	Agent, Sandbox
Sandbox	Code execution environment	Agent, Permissions
Schedule	Time-based execution	Agent, State
Vault	Secure secret storage	Agent, Sandbox
Orchestration	Multi-agent coordination	Agent, Sandbox

Each API is independent but designed to work with the others. An agent can use memory without scheduling. A sandbox can be used without vaults. This modularity means you adopt only what you need.

13.10.2 Example Compositions

Minimal agent (just inference + harness):

agent = ManagedAgent.create(
    model="claude-sonnet-4",
    system_prompt="You are a helpful assistant."
)
result = agent.run(task="Summarize this document")

Production coding agent (full stack):

agent = ManagedAgent.create(
    model="claude-opus-4-7",
    system_prompt="You are a code review agent...",
    tools=[read_file, run_tests, comment_on_pr],
    memory_scope="project-reviews",
    sandbox="self-hosted:cloudflare",
    vault=["GITHUB_TOKEN", "SENTRY_DSN"],
    schedule="0 9 * * 1"  # Every Monday at 9 AM
)

The second agent has memory, self-hosted sandboxing, secure secrets, and scheduled execution — all composed from independent APIs.

Note

The composable philosophy is important because it means you’re not locked into a specific architecture. You can start with a minimal agent and add capabilities (memory, scheduling, vaults) as your needs evolve. You can also swap components — managed sandbox to self-hosted, one model to another — without rewriting your agent.

13.11 The Harness: What You’re Getting

The agent harness is the core value proposition. It’s the orchestration layer — the “brain” that manages the agent loop. Understanding what it provides clarifies why Managed Agents is more than just a Claude API wrapper.

13.11.1 What the Harness Does

The harness manages the complete agent loop:

1. Receives a task from your application.
2. Plans an approach (what tools to use, in what order).
3. Executes the plan — calling tools, processing results, reasoning.
4. Monitors progress and adjusts the plan as needed.
5. Determines completion — decides when the task is done.
6. Returns results to your application.

This is the same loop that powers Claude Code — battle-tested across millions of interactions. By offering it as a managed service, Anthropic ensures that managed agents benefit from the same orchestration quality.

13.11.2 What You Don’t Have to Build

Without the managed harness, building a production agent loop requires implementing:

• Tool-use orchestration — deciding which tools to call and in what order.
• Error handling — recovering from tool failures, API errors, and unexpected results.
• Context management — deciding what to keep in context, when to summarize, when to clear.
• Progress tracking — monitoring where the agent is in its task.
• Completion detection — determining when the task is actually done (not just when the model stops talking).

Each of these is non-trivial. Together, they represent weeks to months of engineering effort. The managed harness eliminates this work.

13.12 Enterprise Governance Features

For enterprise adoption, governance is non-negotiable. Managed Agents provides several governance features:

13.12.1 Audit Trails

Every agent action is logged:

• What the agent did (tool calls, file edits, API calls).
• When it did it (timestamps for every action).
• Why it did it (the reasoning that led to the action, where applicable).
• What resulted (the outcome of each action).

This audit trail supports compliance requirements (SOC 2, ISO 27001, HIPAA) and enables post-hoc analysis of agent behavior.

13.12.2 Access Controls

Agent actions are subject to access controls:

• Permission scopes define what each agent can do.
• Role-based access controls who can create, modify, and invoke agents.
• Resource limits cap what agents can consume (tokens, execution time, API calls).

13.12.3 Observability

Managed Agents provides built-in observability:

• Console tracing — see every step of an agent’s execution.
• Metrics — token consumption, execution time, success rates.
• Logs — structured logs for every action, searchable and exportable.

This observability is essential for debugging, cost management, and building trust in autonomous agent behavior.

13.13 Pricing in Practice

Let’s make the pricing concrete with example scenarios:

13.13.1 Scenario 1: Coding Agent (Moderate Use)

An agent that does code reviews for a team of 10 developers, invoked ~50 times/day, each session averaging 5 minutes:

• Sessions: 50/day × 5 min = 250 session-minutes/day = ~4.2 session-hours/day
• Session cost: 4.2 × $0.08 = ~$0.34/day
• Monthly session cost: ~$10/month
• Token cost: Varies with usage; for code review, typically 10-50K tokens/session

The session-hour cost is modest; tokens dominate total cost.

13.13.2 Scenario 2: Scheduled Security Scanner

An agent that runs nightly security scans, each session lasting 30 minutes:

• Sessions: 1/day × 0.5 hours = 0.5 session-hours/day
• Session cost: 0.5 × $0.08 = $0.04/day
• Monthly session cost: ~$1.20/month
• Token cost: Security scans are token-heavy (reading many files)

Again, session costs are low; tokens are the primary cost driver.

Tip

The pricing model is agent-friendly because session-hours are cheap ($0.08/hour) relative to token costs. An agent that runs for an hour consuming 500K tokens at $15/Mtoken costs $7.50 in tokens and $0.08 in session fees. The session fee is ~1% of total cost. This means you can run long, thorough agents without worrying about the session-hour cost — focus on token efficiency instead.

13.14 Comparison with Alternatives

13.14.1 vs. Claude API (Direct)

Using the Claude API directly gives you maximum control but requires building everything yourself (harness, state, memory, permissions, sandboxing). Suitable for teams with infrastructure expertise and unique requirements. Managed Agents is better for teams that want to focus on agent logic, not infrastructure.

13.14.2 vs. Agent SDK

The Agent SDK provides libraries for building agents in your own code. It’s more flexible than Managed Agents (you run it yourself) but requires you to handle deployment, scaling, and infrastructure. Managed Agents is the managed deployment of what the SDK helps you build.

13.14.3 vs. Custom Platforms

Some organizations build custom agent platforms (like TELUS’s internal platform). This gives maximum customization but requires significant ongoing engineering investment. Managed Agents is the right choice when you want platform capabilities without building them.

13.15 Key Takeaways

• Managed Agents is a suite of composable APIs for building and deploying cloud-hosted agents at scale, launched April 8, 2026.
• It pairs Anthropic’s agent harness (the orchestration layer from Claude Code) with production infrastructure (state, memory, permissions, scheduling).
• The goal: get to production 10x faster by composing managed building blocks instead of building generic infrastructure.
• Key features: secure sandboxing, long-running sessions (hours), multi-agent coordination, and trusted governance (audit, permissions, observability).
• Pricing: standard token rates + $0.08 per session-hour — you pay for active agent time, not idle infrastructure.
• Primary use cases: coding agents, productivity agents, finance/legal agents in regulated industries.
• The infrastructure tax is eliminated: state, memory, permissions, sandboxing, scheduling, and governance are provided, not built.
• Architecture: the agent loop runs on Anthropic’s managed infrastructure; tool execution happens in sandboxes (managed or self-hosted); your application interacts via APIs.