Agents gérés Claude : connectez 49 outils MCP dans une seule configuration

Vous disposez d'un agent de codage. Il lit les fichiers, exécute des tests et écrit du code. Mais quand tu le demandes vérifiez si votre certificat SSL expire la semaine prochaine, validez un email client ou générez un code QR pour votre URL de déploiement, elle se heurte à un mur. Il n'a pas accès au monde extérieur.

MCP (Model Context Protocol) résout le problème d’accès aux outils. Les agents gérés réparent l'infrastructure problème. Au lieu de créer votre propre boucle d'agent avec la découverte d'outils, la gestion des erreurs et le sandboxing, vous envoyez une configuration à l'API d'Anthropic et récupérez un agent entièrement orchestré qui diffuse les résultats sur l'ESS.

Ce tutoriel connecte le serveur botoi MCP (49 outils de développement) à un agent géré Claude. Par le à la fin, vous disposerez d'un agent autonome capable de rechercher les enregistrements DNS, de valider les e-mails, de vérifier SSL certificats, chaînes de hachage, décodage des JWT, etc. ; le tout à partir d’un seul appel API.

Que sont les agents gérés par Claude

Agents gérés lancés en version bêta publique le 8 avril 2026. L'idée de base : Anthropic exécute l'agent boucle côté serveur. Vous définissez le modèle, l'invite système, les outils et les serveurs MCP. Poignées anthropiques sandboxing, orchestration d’outils, exécution multi-tours et streaming.

L'agent s'exécute au sein d'une session. Chaque session dispose de son propre environnement sandbox, exécute jusqu'à un nombre configurable de tours et diffuse les événements vers votre client via SSE. Lorsque l'agent a besoin d'un outil, il l'appelle de manière autonome, lit le résultat et continue son raisonnement.

Tous les points de terminaison des agents gérés nécessitent le managed-agents-2026-04-01 en-tête bêta. Le prix correspond aux taux standards des jetons API Claude plus 0,08 $ par heure de séance. Web la recherche, si elle est activée, coûte 10 $ pour 1 000 recherches.

Créer un agent géré avec botoi MCP

La configuration est un appel API. Vous transmettez l'URL du serveur botoi MCP dans le mcp_servers tableau, et l'agent géré découvre les 49 outils au démarrage de la session.

boucle

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
  }'

La réponse confirme le serveur MCP connecté et indique combien d'outils ont été découverts :

{
  "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"
}

Sans authentification

Pour des tests rapides, ignorez complètement la clé API botoi :

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

Exécuter une session : exemple réel

Une fois l'agent créé, démarrez une session. Cet exemple demande à l'agent de vérifier trois choses sur stripe.com en une seule invite. L'agent détermine quels outils MCP appeler et les appelle séquence et assemble un rapport.

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
  }'

Le flux SSE affiche le raisonnement de l'agent, les appels d'outils et le résultat final :

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"}

Trois outils appelés, trois résultats collectés, une synthèse générée. L'agent a choisi lookup_ssl, lookup_email, et lookup_dns tout seul en fonction de l'invite. Aucune logique de routage d’outils de votre côté.

Exemples Python et 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);
  }
}

Ce que couvrent les 49 outils

Le serveur botoi MCP sur https://api.botoi.com/mcp expose 49 outils sélectionnés. Voici ce que comprend chaque catégorie :

Chaque outil est en lecture seule (sauf chiffrer/déchiffrer). L'agent ne peut pas modifier l'état externe, ce qui permet de fonctionner de manière autonome en toute sécurité sans portes d'approbation.

Répartition des coûts

La tarification des agents gérés comporte trois éléments :

• Tarifs des jetons: Tarification API Claude standard pour le modèle que vous choisissez (Sonnet, Opus ou Haiku)
• Tarif par heure de séance: 0,08 $ par heure de séance, au prorata de la seconde
• Recherche sur le Web (facultatif) : 10 $ pour 1 000 recherches

Les appels de l'outil MCP à botoi sont gratuits du côté Anthropic. Vous ne payez que pour l'utilisation de l'API botoi, et le le niveau gratuit couvre 100 demandes par jour. Voici à quoi ressemble une séance typique :

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

Une session de 3 minutes vérifiant les certificats SSL, validant les e-mails et interrogeant DNS coûte moins de 0,10 $. Les frais par heure de session (0,004 $ pour 3 minutes) sont négligeables par rapport aux coûts des jetons.

Agents gérés ou création de votre propre boucle d'agents

Vous pouvez connecter vous-même les outils MCP à Claude à l'aide de l'API Messages avec utilisation d'outils. La question est de savoir si les frais généraux liés à l'infrastructure en valent la peine.

# 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}],
)

Si vous avez besoin d'un contrôle précis sur le routage des outils, les portes d'approbation personnalisées ou les nouvelles tentatives non standard politiques, créez votre propre boucle. Si vous souhaitez qu'un agent s'exécute en production avec un minimum de code, Les agents gérés éliminent le passe-partout.

Quand utiliser quelle approche

• Agents gérés: outils internes, chatbots avec accès aux outils, scripts d'automatisation ponctuels, prototypes rapides nécessitant des données réelles
• Votre propre boucle: produits destinés aux utilisateurs pour lesquels vous avez besoin d'une UX personnalisée par appel d'outil, flux de travail nécessitant l'approbation d'un humain dans la boucle, logique de branchement complexe que l'agent ne devrait pas décider de manière autonome
• Les deux: commencez par les agents gérés pour le prototype, extrayez-les dans votre propre boucle lorsque vous heurtez un mur de personnalisation