How to Build & Sell AI Agents with Claude Managed Agents

The exact playbook for turning Anthropic's new platform into $5K+/month recurring revenue

What Just Happened

Anthropic quietly launched Claude Managed Agents — and almost nobody understood what it actually means for people who build AI systems.

Here's the short version:

Previously, building a production-ready AI agent meant months of infrastructure work. Sandboxing. State management. Error handling. Authentication. You'd spend all that time before a single user saw anything.

Claude Managed Agents handles all of that for you.

You define what the agent does. Anthropic runs it on their servers. The agent works autonomously — for hours — without you touching anything. It can even spawn other agents to handle subtasks in parallel.

This changes the business model completely.

The Business Model in Plain English

You are now in the business of selling outcomes, not software.

Here's the structure:

10 clients × $500/month = $5,000 MRR

Maintenance time per client: roughly 1 hour per month.

This is not hypothetical. Companies like Rakuten, Notion, Asana, and Sentry are already using Managed Agents in production — and Rakuten deployed agents across five departments in under a week each.

Step 1: Pick Your Niche

The fastest path to revenue is solving one repetitive problem for one type of business.

Good starting niches:

• Real estate agencies → Lead follow-up, property listing summaries, document processing

• E-commerce brands → Customer support, returns handling, product description generation

• Coaches & consultants → Onboarding automation, proposal drafting, client Q&A

• Law firms / accountants → Document intake, invoice processing, client intake forms

• Marketing agencies → Content repurposing, reporting, client brief generation

Pick one. Don't try to serve everyone.

Step 2: Identify Their #1 Repetitive Problem

Book a discovery call. Ask:

"What does your team do every day that you wish you could just hand off completely?"

You're looking for tasks that are:

• ✅ Repetitive (done weekly or daily)

• ✅ Rule-based (clear inputs → clear outputs)

• ✅ Time-consuming (currently takes hours)

• ✅ High-stakes enough that they'd pay to fix it

Common answers: following up with leads, processing inbound emails, generating reports, summarising documents, drafting first-draft proposals.

That task becomes your agent.

Step 3: Build the Agent

Go to: platform.claude.com/docs/en/managed-agents/overview

You'll define four things:

1. The Agent

• Which Claude model to use

• System prompt (what the agent is, what it does, its rules)

• Tools it can access (web search, file operations, bash, MCP integrations)

2. The Environment

• A cloud container with the packages your agent needs

• Network access rules

• Any files it should have access to

3. Sessions

• A session is one "run" of the agent working on a task

• Sessions persist even if you disconnect

• You can send messages mid-session to steer the agent

4. Success Criteria (Self-Evaluation)

This is the part most people missed in the announcement.

You can tell the agent what success looks like, and it will keep iterating until it gets there on its own. It self-evaluates. It's not just following instructions — it's working toward an outcome.

"Draft a proposal for this client. The proposal is complete when it includes a problem statement, three solution options with pricing, and a clear next step. If any of those are missing, revise and try again."

Step 4: Connect It to Their Tools

Claude Managed Agents supports MCP (Model Context Protocol) — which means your agent can plug directly into:

• HubSpot / Salesforce

• Gmail / Outlook

• Notion / Asana

• Slack / Teams

• Google Drive

• GitHub

• And hundreds more

Your agent doesn't just generate text. It takes real actions inside real systems.

This is what separates a chatbot from an actual employee.

Step 5: Price It and Sell It

Pricing structure

How to find clients

1. Post about it — Document what you're building on LinkedIn or Instagram. Show the process. Show the output.

2. Cold outreach — Pick 20 businesses in your niche. Send a 3-sentence message: what you saw their team probably does manually, what an agent could do instead, ask if they'd want to see it.

3. Offer a free pilot — Build one agent for free in exchange for a testimonial and case study. Use that to close the next ten clients.

4. Referrals — Happy clients in a niche talk to each other. One client in real estate leads to five more.

What the Costs Actually Look Like

Claude Managed Agents pricing:

• Token costs: Standard Claude Platform rates (same as the API)

• Session runtime: $0.08 per session-hour of active agent runtime

For most business use cases, a well-scoped agent runs a session in under an hour. At $0.08/hour, your infrastructure cost is almost nothing compared to what you're charging.

Your margin is 90%+.

The "Self-Evaluating Agent" Unlock

Most people skipped past this in the announcement. Don't.

In traditional agent setups, if the agent produces a bad output, it just stops. You have to go back, fix the prompt, re-run it.

With Managed Agents' outcome mode (in research preview), you define what "done" looks like — and the agent evaluates its own output against that definition and retries until it gets there.

In internal testing, this improved task success rates by up to 10 percentage points compared to standard prompt loops — with the biggest gains on the hardest, most complex tasks.

For your clients, this means:

• Fewer errors reaching them

• Less hand-holding from you

• More autonomous operation over time

It genuinely behaves more like an employee than a tool.

Multi-Agent: The Scaling Play

Once you're comfortable with single agents, the next level is multi-agent pipelines.

One "orchestrator" agent breaks a complex task into pieces and delegates to "worker" agents running in parallel.

Example for a marketing agency:

• Orchestrator: "Research this brand, then produce a full content calendar"

• Worker 1: Researches the brand and competitors

• Worker 2: Drafts the content calendar

• Worker 3: Writes copy for each post

• Worker 4: Formats everything into a client-ready doc

All running simultaneously. Delivering in minutes what used to take a day.

This feature is currently in research preview — request access at the link below.

How to Actually Build Your First Agent (Technical Quickstart)

This is the part most guides skip. Here's exactly how to go from zero to a running agent.

What you need

• An Anthropic Console account → console.anthropic.com

• An API key → console.anthropic.com/settings/keys

• The Anthropic SDK installed

Step 1: Install the SDK

Python:

pip install anthropic
export ANTHROPIC_API_KEY="your-api-key-here"

Node/TypeScript:

npm install @anthropic-ai/sdk
export ANTHROPIC_API_KEY="your-api-key-here"

Step 2: Create Your Agent

This defines what your agent is — its model, personality, and tools.

from anthropic import Anthropic

client = Anthropic()

agent = client.beta.agents.create(
    name="Lead Follow-Up Agent",
    model="claude-sonnet-4-6",
    system="You are a sales follow-up assistant for a real estate agency. When given a lead's name and enquiry details, draft a personalised follow-up email and log a summary of next steps.",
    tools=[
        {"type": "agent_toolset_20260401"},  # gives access to bash, file ops, web search
    ],
)

print(f"Agent ID: {agent.id}")  # save this — you'll reuse it for every session

The agent_toolset_20260401 tool type gives your agent access to the full built-in toolkit: bash commands, file read/write, web search, and more. You can also connect it to external tools via MCP (HubSpot, Gmail, Slack, etc.) — covered below.

Step 3: Create an Environment

The environment is the cloud container your agent runs inside.

environment = client.beta.environments.create(
    name="real-estate-agent-env",
    config={
        "type": "cloud",
        "networking": {"type": "unrestricted"},  # lets agent access the web
    },
)

print(f"Environment ID: {environment.id}")  # save this too

Step 4: Start a Session and Send It a Task

A session is one "job run." You create a session, send it a message, and stream the results back in real time.

# Create the session
session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
    title="Follow up with John Smith",
)

# Open the stream and send your task
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": "Lead name: John Smith. Enquiry: 3-bed house in Grey Lynn under $1.2M. Came through the website yesterday. Draft a follow-up email and list next steps.",
                    }
                ],
            }
        ],
    )

    # Watch the agent work in real time
    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[Tool: {event.name}]")
            case "session.status_idle":
                print("\n\nDone.")
                break

Your output will look something like:

I'll draft a follow-up email for John Smith's enquiry.

[Tool: write]

Hi John, thank you for reaching out about your search for a 3-bedroom home in Grey Lynn...

Next steps:
1. Send email within 24 hours
2. Schedule viewing for this weekend
3. Pull comparable listings under $1.2M

Done.

Step 5: Connect to Real Tools via MCP

This is what makes the agent actually take actions inside your client's systems — not just generate text.

When creating your agent, add MCP servers to connect it to external platforms:

agent = client.beta.agents.create(
    name="CRM Agent",
    model="claude-sonnet-4-6",
    system="You are a CRM assistant. Update HubSpot contact records and draft follow-up emails based on the task given.",
    tools=[{"type": "agent_toolset_20260401"}],
    mcp_servers=[
        {
            "type": "url",
            "url": "https://mcp.hubspot.com",   # HubSpot
            "name": "hubspot"
        },
        {
            "type": "url",
            "url": "https://gmail.mcp.claude.com/mcp",  # Gmail
            "name": "gmail"
        }
    ]
)

Now the agent can read and write to HubSpot, send emails via Gmail, and do it all autonomously within a session — no human in the loop.

Popular MCP integrations:

• HubSpot / Salesforce → CRM updates, pipeline management

• Gmail / Outlook → Email drafting and sending

• Notion / Asana → Task creation and project updates

• Slack / Teams → Posting summaries, notifications

• Google Drive → Reading documents, saving outputs

• GitHub → Opening PRs, reviewing code

Step 6: Define Outcomes (Self-Evaluation Mode)

Instead of telling the agent how to do something, tell it what success looks like and let it figure out the rest.

This feature is in research preview — request access at platform.claude.com.

session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
    title="Process new leads",
    outcome={
        "description": "For each lead: a follow-up email is drafted, the HubSpot record is updated with a next-step note, and a summary is saved to followups.txt. The task is complete only when all three are done for every lead provided."
    }
)

The agent will keep iterating until it meets that definition of done — on its own.

Pricing Reality Check

A well-scoped agent session typically runs in under an hour. Your infrastructure cost per client task: pennies. Your charge to the client: hundreds per month. The margin is the business.

Full docs

• Overview: platform.claude.com/docs/en/managed-agents/overview

• Quickstart: platform.claude.com/docs/en/managed-agents/quickstart

• Tools reference: platform.claude.com/docs/en/managed-agents/tools

• MCP connector: platform.claude.com/docs/en/managed-agents/mcp-connector

Your Next Steps

1. Get API access: platform.claude.com

2. Read the docs: platform.claude.com/docs/en/managed-agents/overview

3. Read the launch post: claude.com/blog/claude-managed-agents

4. Pick your niche and identify the one task you'll automate first

5. Build your first agent — aim to have a working demo within 48 hours

6. Send 10 outreach messages to businesses in your niche this week

Quick Reference