How Claude Managed Agents Simplify Building AI Agents

Claude Managed Agents

Developers building AI agents often spend more time wiring loops, tools, and context management than delivering product features. Claude Managed Agents, a fully managed cloud runtime from Anthropic, promises to eliminate this overhead by handling agent cycles, tool execution, sandboxing, and session persistence automatically.

Two Anthropic Releases

Claude Managed Agents – a fully managed framework that runs agents on Anthropic’s infrastructure; you only define the agent, task, and tools.

Claude Agent SDK – a Python/TypeScript library (formerly Claude Code SDK) that embeds the same agent loop in your own environment, requiring you to host the runtime.

The article focuses on Managed Agents because it represents the more impactful release for most developers.

Four Core Building Blocks

Agent – configuration that includes model, system prompt, tools, MCP server, and skills. Defined once and referenced by ID.

Environment – a cloud container pre‑installed with packages (e.g., Python, Node.js, Go) and network rules, serving as the agent’s workspace.

Session – an instance of the agent running in an environment, persisting files, conversation history, and context for the duration of the task.

Events – messages flowing between your application and the agent (user turns, tool results, status updates, streamed responses).

Creating an Agent, Environment, and Session (Python)

import anthropic
client = anthropic.Anthropic()
# Create the agent – do this once, reuse by ID
agent = client.beta.agents.create(
    model="claude-sonnet-4-6",
    system="You are a software engineer. Fix bugs, run tests, and report results.",
    tools=[{"type": "bash"}, {"type": "file_operations"}, {"type": "web_search"}],
    name="bug-fixer"
)
print(agent.id)  # Save this – you’ll reference it across sessions

Next, create an environment and start a session:

# Create an environment with required packages
environment = client.beta.environments.create(packages=["pytest", "requests"])
# Start a session referencing the agent and environment
session = client.beta.sessions.create(
    agent_id=agent.id,
    environment_id=environment.id
)
# Send a task as an event
response = client.beta.sessions.events.create(
    session_id=session.id,
    content="Find and fix the failing tests in auth.py"
)

Agent Loop Mechanics

When a session starts, Claude runs a continuous loop: receive a prompt, evaluate the task, invoke tools, process results, and repeat until the task completes. Each full round is a "turn".

Example task – fixing failing tests:

Turn 1: Claude runs the test suite via Bash, reports three failures.

Turn 2: Claude reads auth.py to understand the problem.

Turn 3: Claude edits the file and re‑runs the tests; all pass.

Final turn: Claude returns a plain‑text response indicating completion.

async for event in client.beta.sessions.stream(
    session_id=session.id,
    event={"type": "user", "content": "Find and fix the failing tests in auth.py"}
):
    if event.type == "assistant_message":
        print(event.content)
    if event.type == "result":
        print(f"Done: {event.result}")
        print(f"Turns used: {event.num_turns}")
        print(f"Cost: ${event.total_cost_usd:.4f}")

Context Management

Each turn adds to the context window (prompts, tool definitions, file contents, command output, conversation history). When the window nears its limit, Managed Agents automatically summarize older history to free space while preserving recent interactions and key decisions.

Three Control Parameters

Effort level – controls the depth of Claude’s reasoning per turn (affects token usage and cost).

Max turns and budget – caps the number of tool‑use turns or total spend (e.g., max_turns=20, max_budget_usd=0.50).

Permission mode – determines which actions Claude may perform without explicit approval (e.g., default, acceptEdits, bypassPermissions).

You can also send mid‑session events to redirect, add context, or stop the agent, and you can resume a persisted session using its ID.

Built‑In Tools

Managed Agents ships with a comprehensive set of native tools, grouped by category:

File operations : Read, Write, Edit Search : Glob, Grep Execution : Bash (run shell commands, scripts, Git, install packages, run tests)

Web : WebSearch, WebFetch Orchestration : Task, Skill, AskUserQuestion, TodoWrite External services can be connected via MCP servers and custom tool handlers.

Quick Start

Claude Managed Agents is currently in beta. With a Claude API key you can begin immediately.

pip install anthropic

export ANTHROPIC_API_KEY=your-api-key

Example of a minimal agent (≈20 lines) that lists Python files in a directory:

import anthropic, asyncio
client = anthropic.Anthropic()
async def main():
    agent = client.beta.agents.create(
        model="claude-sonnet-4-6",
        system="You are a helpful engineering assistant.",
        tools=[{"type": "bash"}, {"type": "file_operations"}],
        name="my-first-agent"
    )
    env = client.beta.environments.create(packages=["pytest"])
    sess = client.beta.sessions.create(agent_id=agent.id, environment_id=env.id, max_turns=10, max_budget_usd=0.25)
    async for ev in client.beta.sessions.stream(session_id=sess.id, event={"type": "user", "content": "List all Python files in this directory"}):
        if ev.type == "result":
            print(ev.result)
            print(f"Cost: ${ev.total_cost_usd:.4f}")
asyncio.run(main())

Key research‑preview features include outcomes, multi‑agent coordination, and persistent memory, which require separate access approval.

Conclusion

Claude Managed Agents abstracts away weeks of infrastructure work, offering a single configuration file and API call to run production‑grade agents. While the quality of output still depends on prompt engineering, the platform marks a significant step toward rapid, reliable AI agent development.