Claude Managed Agents: Verbinden Sie 49 MCP-Tools in einer Konfiguration

Sie haben einen Codierungsagenten. Es liest Dateien, führt Tests aus und schreibt Code. Aber wenn Sie es darum bitten Überprüfen Sie, ob Ihr SSL-Zertifikat nächste Woche abläuft, validieren Sie eine Kunden-E-Mail oder generieren Sie einen QR-Code Für Ihre Bereitstellungs-URL stößt es an eine Wand. Es hat keinen Zugang zur Außenwelt.

MCP (Model Context Protocol) behebt das Tool-Zugriffsproblem. Managed Agents reparieren die Infrastruktur Problem. Anstatt eine eigene Agentenschleife mit Toolerkennung, Fehlerbehandlung und Sandboxing aufzubauen, Sie senden eine Konfiguration an die API von Anthropic und erhalten einen vollständig orchestrierten Agenten zurück, der Ergebnisse streamt über SSE.

Dieses Tutorial verbindet den botoi MCP-Server (49 Entwicklertools) mit einem Claude Managed Agent. Durch die Am Ende verfügen Sie über einen autonomen Agenten, der DNS-Einträge nachschlagen, E-Mails validieren und SSL prüfen kann Zertifikate, Hash-Strings, JWTs dekodieren und mehr; alles über einen einzigen API-Aufruf.

Was sind Claude Managed Agents?

Managed Agents starteten am 8. April 2026 in der öffentlichen Betaversion. Die Kernidee: Anthropic betreibt den Agenten Schleife serverseitig. Sie definieren das Modell, die Systemeingabeaufforderung, die Tools und die MCP-Server. Anthropische Griffe Sandboxing, Tool-Orchestrierung, Multi-Turn-Ausführung und Streaming.

Der Agent wird innerhalb einer Sitzung ausgeführt. Jede Sitzung erhält ihre eigene Sandbox-Umgebung und führt bis zu a configurable number of turns, and streams events back to your client via SSE. Wenn der Agent benötigt ein Werkzeug, ruft es selbstständig auf, liest das Ergebnis und setzt seine Überlegungen fort.

Alle Managed Agents-Endpunkte erfordern das managed-agents-2026-04-01 Beta-Header. Bei den Preisen handelt es sich um die Standard-API-Token-Preise von Claude zuzüglich 0,08 $ pro Sitzungsstunde. Web Wenn die Suche aktiviert ist, kostet sie 10 US-Dollar pro 1.000 Suchanfragen.

Erstellen Sie einen verwalteten Agenten mit botoi MCP

Das Setup ist ein API-Aufruf. Sie übergeben die Botoi-MCP-Server-URL im mcp_servers Array, und der verwaltete Agent erkennt alle 49 Tools beim Sitzungsstart.

Locken

curl https://api.anthropic.com/v1/managed_agents \\
  --header "x-api-key: \$ANTHROPIC_API_KEY" \\
  --header "anthropic-version: 2023-06-01" \\
  --header "anthropic-beta: managed-agents-2026-04-01" \\
  --header "content-type: application/json" \\
  --data '{
    "model": "claude-sonnet-4-6",
    "name": "devops-agent",
    "system": "You are a DevOps assistant. Use the available MCP tools to check infrastructure health, validate configurations, and generate reports.",
    "mcp_servers": [
      {
        "type": "streamable_http",
        "url": "https://api.botoi.com/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_BOTOI_API_KEY"
        }
      }
    ],
    "max_turns": 20
  }'

Die Antwort bestätigt die Verbindung zum MCP-Server und zeigt, wie viele Tools entdeckt wurden:

{
  "id": "agent_01ABC123",
  "name": "devops-agent",
  "model": "claude-sonnet-4-6",
  "mcp_servers": [
    {
      "type": "streamable_http",
      "url": "https://api.botoi.com/mcp",
      "status": "connected",
      "tools_discovered": 49
    }
  ],
  "max_turns": 20,
  "created_at": "2026-04-11T10:30:00Z"
}

Ohne Authentifizierung

Überspringen Sie zum schnellen Testen den Botoi-API-Schlüssel vollständig:

"mcp_servers": [
  {
    "type": "streamable_http",
    "url": "https://api.botoi.com/mcp"
  }
]

Führen Sie eine Sitzung durch: echtes Beispiel

Nachdem der Agent erstellt wurde, starten Sie eine Sitzung. In diesem Beispiel wird der Agent aufgefordert, drei Dinge zu überprüfen Stripe.com in einer einzigen Eingabeaufforderung. Der Agent findet heraus, welche MCP-Tools er anrufen muss, und ruft sie an Sequenz und stellt einen Bericht zusammen.

curl https://api.anthropic.com/v1/managed_agents/agent_01ABC123/sessions \\
  --header "x-api-key: \$ANTHROPIC_API_KEY" \\
  --header "anthropic-version: 2023-06-01" \\
  --header "anthropic-beta: managed-agents-2026-04-01" \\
  --header "content-type: application/json" \\
  --data '{
    "messages": [
      {
        "role": "user",
        "content": "Check the SSL certificate for stripe.com, validate the email security@stripe.com, and look up their DNS MX records."
      }
    ],
    "stream": true
  }'

Der SSE-Stream zeigt die Argumentation des Agenten, Toolaufrufe und die endgültige Ausgabe:

event: message_start
data: {"type": "message_start", "session_id": "sess_01XYZ"}

event: content_block_delta
data: {"type": "text", "text": "I'll check three things for stripe.com. Let me start."}

event: tool_use
data: {"type": "tool_use", "name": "lookup_ssl", "input": {"domain": "stripe.com"}}

event: tool_result
data: {"type": "tool_result", "content": {"issuer": "DigiCert", "valid_to": "2027-01-15", "days_remaining": 279, "expired": false}}

event: tool_use
data: {"type": "tool_use", "name": "lookup_email", "input": {"email": "security@stripe.com"}}

event: tool_result
data: {"type": "tool_result", "content": {"valid": true, "mx_found": true, "disposable": false}}

event: tool_use
data: {"type": "tool_use", "name": "lookup_dns", "input": {"domain": "stripe.com", "type": "MX"}}

event: tool_result
data: {"type": "tool_result", "content": {"records": [{"priority": 1, "value": "aspmx.l.google.com"}, {"priority": 5, "value": "alt1.aspmx.l.google.com"}]}}

event: content_block_delta
data: {"type": "text", "text": "Here's the summary:\\n\\n1. **SSL**: Valid until Jan 15, 2027 (279 days). Issued by DigiCert.\\n2. **Email**: security@stripe.com is valid with MX records present.\\n3. **MX Records**: Stripe uses Google Workspace (aspmx.l.google.com)."}

event: message_stop
data: {"type": "message_stop", "session_id": "sess_01XYZ"}

Drei Tools aufgerufen, drei Ergebnisse gesammelt, eine Zusammenfassung generiert. Der Agent wählte lookup_ssl, lookup_email, Und lookup_dns von alleine basierend auf der Eingabeaufforderung. Keine Tool-Routing-Logik auf Ihrer Seite.

Beispiele für Python und Node.js

Python

import anthropic

client = anthropic.Anthropic()

# Create the agent once
agent = client.beta.managed_agents.create(
    model="claude-sonnet-4-6",
    name="devops-agent",
    system="You are a DevOps assistant. Use MCP tools to check infrastructure.",
    mcp_servers=[
        {
            "type": "streamable_http",
            "url": "https://api.botoi.com/mcp",
            "headers": {
                "Authorization": "Bearer YOUR_BOTOI_API_KEY",
            },
        }
    ],
    max_turns=20,
    betas=["managed-agents-2026-04-01"],
)

# Run a session
with client.beta.managed_agents.sessions.stream(
    agent_id=agent.id,
    messages=[
        {
            "role": "user",
            "content": "Check SSL expiry for github.com and stripe.com. Flag any cert expiring within 30 days.",
        }
    ],
    betas=["managed-agents-2026-04-01"],
) as stream:
    for event in stream:
        if event.type == "content_block_delta":
            print(event.delta.text, end="", flush=True)
        elif event.type == "tool_use":
            print(f"\\n[calling {event.name}]")

Node.js (TypeScript)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

// Create agent
const agent = await client.beta.managedAgents.create({
  model: "claude-sonnet-4-6",
  name: "devops-agent",
  system: "You are a DevOps assistant. Use MCP tools to check infrastructure.",
  mcp_servers: [
    {
      type: "streamable_http",
      url: "https://api.botoi.com/mcp",
      headers: {
        Authorization: "Bearer YOUR_BOTOI_API_KEY",
      },
    },
  ],
  max_turns: 20,
  betas: ["managed-agents-2026-04-01"],
});

// Run a session with streaming
const stream = await client.beta.managedAgents.sessions.stream(agent.id, {
  messages: [
    {
      role: "user",
      content: "Validate the email admin@example.com and check if example.com has SPF records.",
    },
  ],
  betas: ["managed-agents-2026-04-01"],
});

for await (const event of stream) {
  if (event.type === "content_block_delta") {
    process.stdout.write(event.delta.text);
  }
}

Was die 49 Tools abdecken

Der botoi MCP-Server unter https://api.botoi.com/mcp stellt 49 kuratierte Werkzeuge vor. Hier ist Was jede Kategorie beinhaltet:

Jedes Tool ist schreibgeschützt (außer verschlüsseln/entschlüsseln). Der Agent kann den externen Status nicht ändern macht den autonomen Betrieb ohne Genehmigungstore sicher.

Kostenaufschlüsselung

Die Preisgestaltung für Managed Agents besteht aus drei Komponenten:

• Token-Preise: Standard-Claude-API-Preise für das von Ihnen gewählte Modell (Sonnet, Opus oder Haiku)
• Sitzungsstundengebühr: 0,08 $ pro Sitzungsstunde, sekundengenau anteilig
• Websuche (optional): 10 $ pro 1.000 Suchanfragen

MCP-Tool-Aufrufe an Botoi sind auf der Anthropic-Seite kostenlos. Sie zahlen nur für die Nutzung der Botoi-API und die Das kostenlose Kontingent umfasst 100 Anfragen pro Tag. So sieht eine typische Sitzung aus:

Session duration:     3 minutes (0.05 hours)
Session-hour cost:    0.05 x \$0.08 = \$0.004
Input tokens:         12,400 (Sonnet: \$3/MTok) = \$0.037
Output tokens:        3,800 (Sonnet: \$15/MTok) = \$0.057
MCP tool calls:       6 (botoi free tier)
──────────────────────────────────
Total:                \$0.098

Eine 3-minütige Sitzung zur Überprüfung von SSL-Zertifikaten, zur Validierung von E-Mails und zur Abfrage von DNS kostet weniger als 0,10 $. Die Gebühr für die Sitzungsstunde (0,004 USD für 3 Minuten) ist im Vergleich zu den Token-Kosten vernachlässigbar.

Verwaltete Agenten im Vergleich zum Aufbau einer eigenen Agentenschleife

Sie können MCP-Tools mithilfe der Nachrichten-API mit Tool-Nutzung selbst mit Claude verbinden. Die Frage ist, ob sich der Infrastrukturaufwand lohnt.

# Your own agent loop (pseudocode)
while not done:
    response = call_claude(messages)
    for tool_call in response.tool_calls:
        # You handle MCP client connection
        # You handle tool discovery
        # You handle input validation
        # You handle error recovery
        # You handle sandboxing
        result = mcp_client.call(tool_call)
        messages.append(result)

# Managed Agent (one API call)
session = client.beta.managed_agents.sessions.create(
    agent_id=agent.id,
    messages=[{"role": "user", "content": prompt}],
)

If you need fine-grained control over tool routing, custom approval gates, or non-standard retry Richtlinien, erstellen Sie Ihre eigene Schleife. If you want an agent running in production with minimal code, Managed Agents eliminieren den Standard.

Wann welchen Ansatz verwenden?

• Verwaltete Agenten: interne Tools, Chatbots mit Tool-Zugriff, einmalige Automatisierungsskripte, schnelle Prototypen, die reale Daten benötigen
• Ihre eigene Schleife: benutzerorientierte Produkte, bei denen Sie eine benutzerdefinierte Benutzeroberfläche pro Tool-Aufruf benötigen, Arbeitsabläufe, die eine Genehmigung durch den Menschen erfordern, komplexe Verzweigungslogik, über die der Agent nicht autonom entscheiden sollte
• Beide: Beginnen Sie mit Managed Agents für den Prototyp und extrahieren Sie ihn in Ihre eigene Schleife, wenn Sie auf eine Anpassungsbarriere stoßen