Claude managed agents: the honest starter guide

The actual definition

Anthropic frames it as a choice between two ways of building. The Messages API is "direct model prompting access", best for "custom agent loops and fine-grained control". Managed Agents is a "pre-built, configurable agent harness that runs in managed infrastructure", best for "long-running tasks and asynchronous work" (overview).

In plain English: normally, if you want Claude to work on something for an hour, you have to build the loop yourself, plus a safe place to run commands, plus the plumbing that feeds results back in. Managed Agents hands you that harness pre-built. The interesting part is not that it writes code for you. It is that the babysitting layer is someone else's problem now.

What the internet says versus what the docs say

I went through the popular claims one at a time against Anthropic's own documentation, because this is the kind of feature that gets described enthusiastically and inaccurately. Here is where each one lands.

What the sandbox actually provisions

Every session runs in an isolated Linux container. This is the concrete list, straight from the cloud sandbox reference, so you know exactly what the agent can reach for without installing anything.

• 🖥️ The machine: Ubuntu 22.04 LTS, x86_64, up to 8 GB memory and up to 10 GB disk.
• 👩‍💻 Languages ready to go: Python 3.12+, Node.js 20+, Go 1.22+, Rust 1.77+, Java 21+, Ruby 3.3+, PHP 8.3+, and C/C++ with GCC 13+, each with its usual package manager.
• 🗄️ Data: SQLite fully available locally, plus psql and redis-cli clients for connecting out to databases you already run.
• 🔧 Utilities: git, curl, wget, jq, ripgrep, tree, htop, tmux, make and cmake, the standard text-processing tools, and Docker with limited availability.
• 🌐 Network: environments created through the API default to unrestricted networking, so the agent can reach the internet unless you narrow it deliberately.

The built-in toolset gives the agent bash, file reading and writing, editing, glob and grep, plus web search and web fetch. You can also attach up to twenty MCP servers with credentials held in vaults rather than pasted into a prompt (tools, MCP connector).

What it actually costs

This is the number nobody quotes, and it is the friendliest surprise in the whole feature. Billing has two dimensions: the tokens the session uses at normal model rates, and the time the session spends actually running.

• ⏱️ Session runtime: $0.08 per session-hour, measured to the millisecond, and it accrues only while the session status is running. Time spent idle waiting for your next message does not count.
• 🔤 Tokens at standard model rates. Prompt caching multipliers apply the same way they do everywhere else, which matters a lot on long sessions.
• 🔍 Web search inside a session: $10 per 1,000 searches, on top of tokens. Web fetch adds no charge beyond the tokens for what it pulls in.
• 🚫 No batch discount. Sessions are stateful and interactive, so there is no batch mode to discount. It is also not available on Bedrock or Google Cloud.

The real quickstart, from zero

This is the documented path, in order. You need a Claude Console account and an API key. Note that this is Claude API billing, which is separate from a Claude Pro or Max subscription: it is pay as you go, and new accounts get a small amount of free credit to test with.

1. 🔑 Get an API key. Sign in at platform.claude.com and create a key under Settings, then API keys. Managed Agents access is enabled by default for all API accounts, so there is no waitlist for the core feature.
2. 📥 Install the CLI. On macOS with Homebrew, run brew install anthropics/tap/ant, then confirm it worked with ant --version. On Linux, download the release binary from the releases page.
3. 📦 Install an SDK. You need this for the streaming step, because the docs note that streaming "does not translate well to a one-off shell command". Python is pip install anthropic, TypeScript is npm install @anthropic-ai/sdk.
4. 🔐 Set your key as an environment variable. Run export ANTHROPIC_API_KEY="your-api-key-here" so nothing sensitive ends up pasted into a file you might share later.
5. 🧠 Create the agent. This is the reusable configuration. The agent_toolset_20260401 tool type switches on the full built-in toolset in one line.
6. 📦 Create the environment. One call, and you get the cloud sandbox described above.
7. ▶️ Start a session and stream it. Sessions reference the agent ID and environment ID you saved. You open the stream, send your first user event, then read events as they arrive until you see session.status_idle, which is the agent telling you it has nothing left to do.

The three creation calls, using the CLI:

AGENT_ID=$(ant beta:agents create \
  --name "Coding Assistant" \
  --model '{id: claude-opus-5}' \
  --system "You are a helpful coding assistant. Write clean, well-documented code." \
  --tool '{type: agent_toolset_20260401}' \
  --transform id --raw-output)

ENVIRONMENT_ID=$(ant beta:environments create \
  --name "quickstart-env" \
  --config '{type: cloud, networking: {type: unrestricted}}' \
  --transform id --raw-output)

SESSION_ID=$(ant beta:sessions create \
  --agent "$AGENT_ID" \
  --environment-id "$ENVIRONMENT_ID" \
  --title "Quickstart session" \
  --transform id --raw-output)

Then the streaming step in Python, which is where the agent actually does the work:

with client.beta.sessions.events.stream(session.id) as stream:
    client.beta.sessions.events.send(
        session.id,
        events=[{
            "type": "user.message",
            "content": [{"type": "text", "text": "Your task here"}],
        }],
    )

    for event in stream:
        match event.type:
            case "agent.message":
                for block in event.content:
                    print(block.text, end="")
            case "agent.tool_use":
                print(f"\n[Using tool: {event.name}]")
            case "session.status_idle":
                print("\n\nAgent finished.")
                break

The system prompt that makes an agent behave

The --system value in that first command is where almost all of your agent's quality lives, and "You are a helpful assistant" wastes it. A long-running agent needs to know when to stop, when to ask, and what to leave alone. Paste this in as your starting point and edit the bracketed parts.

You are an autonomous agent running in a sandboxed Linux container with bash, file tools, web search and web fetch. Your job is: [describe the one task in a sentence, for example "take a folder of raw CSV exports and produce a cleaned, deduplicated summary report as a markdown file"].

Work in this order. First, before doing anything that writes or deletes, explore and state your plan in one short paragraph: what you found, what you intend to do, and what could go wrong. Second, do the work in small verifiable steps, and after each step check the result rather than assuming it worked. Third, when you believe you are finished, verify your own output against the original request and say explicitly what you checked.

Hard rules you never break. Never delete or overwrite a file you did not create in this session. Never run a command whose effect you cannot describe in one sentence. If a task needs a credential you were not given, stop and say exactly what is missing rather than improvising a workaround. If you have tried the same approach twice without progress, stop and report what is blocking you instead of trying a third time.

Keep me informed as you go: a short line before each tool use explaining why. When you are done, finish with a summary listing what you produced, where it is, what you verified, and anything you were unsure about.

Four first builds that suit this shape

Managed Agents earns its keep on work that is long, repetitive and unsupervised. Chat-shaped work is better and cheaper on the Messages API. These four fit the shape well, and Anthropic publishes runnable examples for several of them in the quickstarts repo.

What actually gives you an agent today

If the last few sections read like another language, that is a fair reaction and not a failure on your part. Managed Agents is aimed at people shipping software. The good news is that the everyday version of "Claude does jobs for me without me watching" already exists in the app you have, and none of it needs an API key.

1. 🔗 Connect your tools. In Claude, open Customize, then Connectors. This is where Claude gets the ability to act in other software rather than only talk about it, and it is the same MCP standard the developer product uses underneath.
2. 🧩 Teach it your processes as skills. Open Customize, then Skills, then Add, then Upload a skill. A skill is a folder with a SKILL.md inside describing when to use it and what to do, and Claude reaches for it automatically when your request matches. Skills work on every plan from Free through Enterprise (creating custom skills).
3. 🧠 Give it standing context. Put your recurring work in a Project so every chat starts already knowing your situation. Projects are available on all plans, with up to five on a free account (Projects).
4. 💻 Graduate to Claude Code when you want files changed. Claude Code is the step between chatting and building: it works on real files on your own machine, and it is where most people who eventually reach for Managed Agents started.

Proof

Claude Managed Agents overview, beta status and eligibility
Managed Agents quickstart, the commands used above
Cloud sandbox reference, specs and pre-installed software
Built-in tools · MCP connector · Environments
Pricing, session runtime and the worked example
Anthropic's launch post · Runnable example apps