Claude Managed Agents, Explained: What They Are and Why They Matter
If you've been building with Claude and started wondering how to move from "AI that chats" to "AI that actually runs things" (long tasks, background jobs, agents that keep working after you close the laptop), you've probably bumped into a new term: Claude Managed Agents.
This guide breaks down what Managed Agents are, how they work, and why they're a big deal if you want to build a real agent-powered product instead of a glorified chatbot.
In Plain English: What Are Claude Managed Agents?
Normally, if you want Claude to act like an agent (reading files, running code, browsing the web, calling tools, working for minutes or hours at a stretch), you have to build all of that yourself. You'd write your own agent loop, stand up a sandbox to run code safely, wire up tool execution, handle retries, and figure out how to persist state between steps.
Claude Managed Agents does that work for you.
It's a pre-built, configurable agent harness that runs on Anthropic's managed infrastructure. Instead of assembling your own loop and sandbox, you define an agent once (its model, system prompt, tools, and skills) and Anthropic runs it for you in a secure environment. Claude can then read and write files, run shell commands, search the web, and call your own tools, all inside a session that can run for minutes, hours, or on a recurring schedule.
Think of it as the difference between building your own delivery fleet from scratch versus plugging into logistics infrastructure that already exists. You still decide what gets delivered and where; you just don't have to build the trucks.
How Managed Agents Work (The Simple Version)
Managed Agents is built around four core concepts:
| Concept | What it means |
|---|---|
| Agent | The definition: model, system prompt, tools, MCP servers, and skills. Create it once, reuse it everywhere. |
| Environment | Where the agent runs: an Anthropic-managed cloud sandbox, or infrastructure you host yourself. |
| Session | A live, running instance of an agent performing a specific task and producing outputs. |
| Events | The messages passed back and forth (your instructions, tool results, status updates), streamed in real time. |
In practice, a typical flow looks like this:
- Create an agent: define the model, prompt, tools, and skills, and reference it by ID from then on.
- Create an environment: a cloud sandbox, or your own self-hosted one for compliance or data-residency needs.
- Start a session: launch a run that points at your agent and environment.
- Send events, stream responses: Claude runs tools autonomously and streams results back over server-sent events.
- Steer or interrupt: send follow-up messages mid-run to redirect the agent, or stop it entirely.
Everything is persisted server-side, so a session can pause and resume without you having to rebuild its state from scratch.
Why Use Managed Agents? Here's What You Get
- Long-running execution: tasks that need multiple tool calls over minutes or hours, not a single request/response.
- A managed sandbox: secure, pre-configured environments with network access, instead of you building and hardening your own.
- Self-hosted execution: run sessions on your own infrastructure when compliance or data residency requires it.
- Less infrastructure to own: no agent loop, sandbox, or tool-execution layer to build and maintain yourself.
- Stateful sessions: persistent files and conversation history across multiple interactions with the same agent.
- Scheduled runs: recurring agent sessions on a cron schedule, useful for monitoring, reporting, or maintenance tasks.
Out of the box, agents get access to bash (running shell commands in the sandbox), file operations (read, write, edit, glob, grep), web search and fetch, and MCP servers for connecting to your own tools and data.
Managed Agents vs. the Messages API
Anthropic gives you two ways to build with Claude, and they're suited to different jobs.
| Messages API | Claude Managed Agents | |
|---|---|---|
| What it is | Direct model prompting access | Pre-built, configurable agent harness on managed infrastructure |
| Best for | Custom agent loops and fine-grained control | Long-running tasks and asynchronous work |
| You build | The loop, the sandbox, tool execution | Just the agent definition: the rest is handled |
| Typical use | Chat features, tight custom control flows | Background agents, research tasks, scheduled jobs |
Neither one is "better"; they answer different questions. If you need total control over every step of the loop, the Messages API is still the right tool. If you want Claude to go off and do a multi-step job without you hand-rolling the infrastructure, Managed Agents is built for exactly that.
What You Could Build With This
A few examples of the kind of thing Managed Agents is designed for:
- A research agent that spends 20 minutes gathering and summarizing information from the web, then hands you a report.
- A support agent that reads a customer's files, checks your systems via MCP, and drafts a resolution, checking in with a human before anything irreversible happens.
- A scheduled agent that runs every morning, checks a dashboard or inbox, and flags anything that needs attention.
- A multi-agent "squad," where one agent orchestrates several sub-agents to handle different parts of a larger job.
This is a meaningfully different shape of product than a chatbot with a system prompt. It's closer to hiring a very fast, very literal employee who can run for hours without getting tired, as long as you've set up the guardrails.
A Few Things to Know Before You Start
Managed Agents is currently in beta. A few practical notes if you're planning to build with it:
- All requests need the
managed-agents-2026-04-01beta header (the SDK sets this for you automatically). - You'll need a Claude API key, and access is enabled by default for API accounts.
- Because sessions are long-running and stateful (storing conversation history, sandbox state, and outputs server-side), Managed Agents isn't currently eligible for Zero Data Retention or HIPAA BAA coverage. You can still delete sessions and files at any time through the API.
- Features like MCP tunnels and "dreaming" are in a more limited research preview and need separate access.
Worth keeping an eye on the docs, since behaviors are still being refined as the beta matures.
Where This Fits Into Our Course
This is exactly the piece of infrastructure at the center of our new course, Build an AI Agent Platform with Claude Agents.
Instead of just reading about Managed Agents, you build a real, multi-user AI agent platform with it, end to end. That means:
- Creating and managing agents with Claude Managed Agents, and running real "missions" through live Sessions
- Wiring up authentication, database, and storage with Supabase (including row-level security)
- Connecting external tools like Google Drive securely through Pipedream
- Giving your agents knowledge by parsing Docs, Sheets, PDFs, and DOCX files
- Generating Google Doc, Sheet, and PDF outputs from agent runs
- Tracking token usage and cost, and building an admin dashboard
- Deploying to a custom domain on Vercel, ready for real customers
No prior coding experience is required; you'll be driving development with Claude Code and Codex the whole way through, so the focus is on understanding the why behind each piece, not memorizing syntax.
Final Thoughts
Claude Managed Agents removes a huge chunk of the plumbing that used to stand between "I have an idea for an agent" and "I have a working agent in production." You still design the agent, the tools it can use, and the guardrails around it, but you're no longer on the hook for building the sandbox, the loop, or the state management underneath it.
If you've been putting off building an agent-powered product because the infrastructure felt like too much, this is worth a second look.