Claude Managed Agents — What They Are & How to Set Them Up

Imagine telling an AI: "Go find the bug in my code, write a fix, and open a pull request." Then walking away while it actually does it.

That's what Claude Managed Agents makes possible. Anthropic launched it in public beta on April 8, 2026, and it's already being used by companies like Notion, Asana, and Atlassian.

Let me break down what this is, why it matters, and how to set it up — even if you've never touched an API before.

What Are Managed Agents, Really?

Think of a regular AI chatbot as a conversation partner. You ask a question, it answers. You ask another, it answers again. It can't do things on its own.

A managed agent is more like a virtual employee. You give it a task, and it goes off and works on it — writing code, searching the web, reading files, running commands — all by itself. When it's done, it comes back with the result.

The "managed" part means Anthropic handles all the behind-the-scenes infrastructure. You don't need to figure out how to run the agent, keep it alive, or recover from errors. You just define what the agent should do, and Anthropic takes care of how it runs.

Before this, building an AI agent that could actually do things required 3–6 months of engineering work. Now you can go from idea to working agent in days.

The Core Concepts (Plain English)

There are only four things you need to understand:

Think of it like hiring a contractor:

• The Agent is the contractor's résumé and skill set
• The Environment is the office you set up for them
• The Session is the specific project you assign
• Events are your conversations about the project

How It Works (The Simple Version)

Here's the five-step flow:

1. Create an Agent — Tell Anthropic what your AI worker should know and what tools it can use
2. Create an Environment — Set up the virtual workspace with the right software installed
3. Start a Session — Give your agent a specific task to work on
4. Send Messages & Watch — Send your instructions and watch the agent work in real time
5. Guide or Redirect — If the agent goes off track, send a new message to steer it back

That's it. The agent handles everything else — running commands, reading files, writing code, fetching data from the web.

What Can an Agent Actually Do?

When you create an agent, it comes with a toolbox of built-in abilities:

You can also create custom tools — for example, a tool that checks the weather, queries your database, or sends a Slack message. You define what input the tool needs, and Claude decides when to use it.

An agent with the right tools can do in minutes what would take a human hours.

Setting It Up: Step by Step

Don't worry — this is simpler than it looks. I'll walk you through every step.

What You Need First

1. An Anthropic account — Sign up free at platform.claude.com
2. An API key — This is like a password that lets your code talk to Claude. Generate one at platform.claude.com/settings/keys

Step 1: Install the Tools

You'll need two things: the Anthropic CLI (a command-line tool) and the SDK (a code library).

Install the CLI:

# On Mac
brew install anthropic/tap/ant

# On Linux or Windows (WSL)
curl -fsSL https://cli.anthropic.com/install.sh | sh

# Check it worked
ant --version

Install the SDK (choose your language):

# If you use Python
pip install anthropic

# If you use JavaScript/TypeScript
npm install @anthropic-ai/sdk

Save your API key so you don't have to type it every time:

export ANTHROPIC_API_KEY="your-api-key-here"

Step 2: Create Your Agent

This is where you define your AI worker. You give it a name, pick a model, and write instructions for how it should behave.

Run this command in your terminal (replace nothing — this is a working example):

curl -sS https://api.anthropic.com/v1/agents \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{
    "name": "My First Agent",
    "model": "claude-sonnet-4-6",
    "system": "You are a helpful assistant.",
    "tools": [{"type": "agent_toolset_20260401"}]
  }'

This creates an agent with access to all the built-in tools. Save the id it returns — you'll need it in the next steps.

Think of the system field as the agent's personality and job description. Tell it exactly what role to play.

Step 3: Create an Environment

The environment is the virtual computer your agent works inside. Here, you can pre-install software packages and control internet access.

curl -sS https://api.anthropic.com/v1/environments \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{
    "name": "my-env",
    "config": {
      "type": "cloud",
      "packages": {
        "pip": ["pandas", "numpy"],
        "npm": ["express"]
      },
      "networking": {"type": "unrestricted"}
    }
  }'

The packages section is like a shopping list — tell the environment what software to have ready. The networking part controls whether the agent can access the internet.

Step 4: Start a Session

Now combine your agent and environment into a working session:

curl -sS https://api.anthropic.com/v1/sessions \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{
    "agent": "YOUR_AGENT_ID",
    "environment_id": "YOUR_ENVIRONMENT_ID",
    "title": "First session"
  }'

Replace YOUR_AGENT_ID and YOUR_ENVIRONMENT_ID with the IDs you got from the previous steps.

Step 5: Give It a Task and Watch It Work

Send a message to your agent:

curl -sS \
  "https://api.anthropic.com/v1/sessions/$SESSION_ID/events" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{
    "events": [{
      "type": "user.message",
      "content": [{
        "type": "text",
        "text": "Create a Python script that generates Fibonacci numbers"
      }]
    }]
  }'

Then open the live stream to watch Claude work in real time:

curl -sS -N \
  "https://api.anthropic.com/v1/sessions/$SESSION_ID/stream" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "Accept: text/event-stream"

That's it. Your agent is now working autonomously — writing code, running it, and delivering the result.

What Does It Cost?

The pricing has two parts:

Some real-world examples:

For most use cases, this is dramatically cheaper than building and hosting your own agent infrastructure.

Who's Already Using This?

These aren't small experiments — these are production deployments at major companies:

• Notion — Teams delegate coding, slides, and spreadsheets to Claude directly inside Notion
• Asana — Built "AI Teammates" that pick up tasks assigned in projects and draft deliverables
• Rakuten — Deployed specialist agents across sales, marketing, finance, and HR — each live in under a week
• Sentry — Built an agent that goes from flagged bug → written fix → opened pull request, with zero human intervention
• Atlassian — Developers assign tasks to a Claude agent directly inside Jira

Asana's CTO said they shipped advanced features "dramatically faster" using Managed Agents.

A Few Pro Tips

For security in production, restrict your agent's internet access. Instead of "unrestricted", use "limited" and list only the websites your agent needs:

"networking": {
  "type": "limited",
  "allowed_hosts": ["api.yourservice.com"]
}

Turn off tools you don't need. If your agent doesn't need web access, disable it:

"tools": [{
  "type": "agent_toolset_20260401",
  "configs": [
    {"name": "web_fetch", "enabled": false},
    {"name": "web_search", "enabled": false}
  ]
}]

Be aware of rate limits. You can create up to 60 agents, sessions, or environments per minute, and make up to 600 read requests per minute.

Coming Soon (Research Preview)

These features are in early access — you can request them at claude.com/form/claude-managed-agents:

• Multi-Agent Coordination — One agent can spin up other agents and divide work between them
• Self-Evaluation — Define what "success" looks like and let the agent keep iterating until it gets there
• Memory — Agents remember context from previous sessions, so they learn and improve over time

The Bottom Line

Claude Managed Agents turns AI from a chat partner into a virtual worker. You define the job, give it the right tools, and let it go.

The setup takes about 15 minutes. The infrastructure is handled for you. And the pricing is pay-as-you-go.

If you've been waiting for AI agents to become practical and accessible — this is it.

Define the job. Give it the tools. Let it work.