Agentes administrados de Claude: conecte 49 herramientas MCP en una configuración

Tienes un agente codificador. Lee archivos, ejecuta pruebas y escribe código. Pero cuando le pides que compruebe si su certificado SSL caduca la próxima semana, valide el correo electrónico de un cliente o genere un código QR para su URL de implementación, choca contra una pared. No tiene acceso al mundo exterior.

MCP (Protocolo de contexto modelo) soluciona el problema de acceso a la herramienta. Los agentes administrados reparan la infraestructura problema. En lugar de crear su propio bucle de agente con descubrimiento de herramientas, manejo de errores y espacio aislado, envía una configuración a la API de Anthropic y obtiene un agente completamente orquestado que transmite los resultados sobre ESS.

Este tutorial conecta el servidor botoi MCP (49 herramientas de desarrollo) a un agente administrado por Claude. por el Al final, tendrás un agente autónomo que podrá buscar registros DNS, validar correos electrónicos, comprobar SSL certificados, cadenas hash, decodificación de JWT y más; todo desde una única llamada API.

¿Qué son los agentes administrados por Claude?

Los agentes administrados se lanzaron en versión beta pública el 8 de abril de 2026. La idea central: Anthropic ejecuta el agente bucle del lado del servidor. Usted define el modelo, el indicador del sistema, las herramientas y los servidores MCP. Mangos antrópicos sandboxing, orquestación de herramientas, ejecución multiturno y streaming.

El agente se ejecuta dentro de una sesión. Cada sesión tiene su propio entorno aislado, se ejecuta hasta un número configurable de turnos y transmite eventos a su cliente a través de SSE. cuando el agente necesita una herramienta, la llama de forma autónoma, lee el resultado y continúa razonando.

Todos los puntos finales de los agentes administrados requieren la managed-agents-2026-04-01 encabezado beta. El precio es el estándar de tarifas de token API de Claude más $0.08 por hora de sesión. Web La búsqueda, si está habilitada, cuesta $10 por cada 1000 búsquedas.

Crear un agente administrado con botoi MCP

La configuración es una llamada API. Pasas la URL del servidor botoi MCP en el mcp_servers matriz, y el agente administrado descubre las 49 herramientas al inicio de la sesión.

rizo

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 respuesta confirma el servidor MCP conectado y muestra cuántas herramientas se descubrieron:

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

Sin autenticación

Para realizar pruebas rápidas, omita por completo la clave API de botoi:

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

Ejecutar una sesión: ejemplo real

Con el agente creado, inicia una sesión. Este ejemplo le pide al agente que verifique tres cosas sobre stripe.com en un solo mensaje. El agente determina a qué herramientas MCP llamar y las llama secuencia y elabora un informe.

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

La secuencia SSE muestra el razonamiento del agente, las llamadas a las herramientas y el resultado 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"}

Tres herramientas llamadas, tres resultados recopilados, un resumen generado. El agente eligió lookup_ssl, lookup_email, y lookup_dns por sí solo basado en el mensaje. No hay lógica de enrutamiento de herramientas de su lado.

Ejemplos de Python y Node.js

Pitón

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 (Mecanografiado)

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);
  }
}

Qué cubren las 49 herramientas

El servidor botoi MCP en https://api.botoi.com/mcp expone 49 herramientas seleccionadas. Aquí está qué incluye cada categoría:

Todas las herramientas son de sólo lectura (excepto cifrar/descifrar). El agente no puede modificar el estado externo, lo que hace que sea seguro funcionar de forma autónoma sin puertas de aprobación.

Desglose de costos

El precio de los agentes administrados tiene tres componentes:

• Tasas de tokens: Precio estándar de Claude API para el modelo que elijas (Sonnet, Opus o Haiku)
• Tarifa por hora de sesión: $0.08 por hora de sesión, prorrateado al segundo
• búsqueda web (opcional): $10 por cada 1000 búsquedas

Las llamadas de la herramienta MCP a botoi son gratuitas en el lado antrópico. Solo paga por el uso de la API de botoi y el El nivel gratuito cubre 100 solicitudes por día. Así es como se ve una sesión típica:

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

Una sesión de 3 minutos para verificar certificados SSL, validar correos electrónicos y consultar DNS cuesta menos de $0,10. La tarifa por hora de sesión ($0,004 por 3 minutos) es insignificante en comparación con los costos simbólicos.

Agentes administrados versus crear su propio bucle de agentes

Puede conectar las herramientas MCP a Claude usted mismo utilizando la API de mensajes con el uso de herramientas. la pregunta es si los gastos generales de infraestructura valen la pena.

# 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 necesita un control detallado sobre el enrutamiento de herramientas, puertas de aprobación personalizadas o reintentos no estándar políticas, cree su propio circuito. Si desea que un agente se ejecute en producción con un código mínimo, Los agentes administrados eliminan el texto repetitivo.

Cuándo utilizar qué enfoque

• Agentes administradas: herramientas internas, chatbots con acceso a herramientas, scripts de automatización únicos, prototipos rápidos que necesitan datos del mundo real
• Tu propio bucle: productos orientados al usuario donde necesita una experiencia de usuario personalizada por llamada de herramienta, flujos de trabajo que requieren aprobación humana en el circuito, lógica de ramificación compleja que el agente no debería decidir de forma autónoma
• Ambas: comience con agentes administrados para el prototipo, extraiga a su propio bucle cuando llegue a un muro de personalización