Claude Managed Agents: conecte 49 ferramentas MCP em uma configuração

Você tem um agente de codificação. Ele lê arquivos, executa testes e escreve código. Mas quando você pede para verifique se o seu certificado SSL expira na próxima semana, valide o e-mail de um cliente ou gere um código QR para o seu URL de implantação, ele atinge um muro. Não tem acesso ao mundo exterior.

MCP (Model Context Protocol) corrige o problema de acesso à ferramenta. Agentes gerenciados consertam a infraestrutura problema. Em vez de criar seu próprio loop de agente com descoberta de ferramentas, tratamento de erros e sandbox, você envia uma configuração para a API da Anthropic e recebe de volta um agente totalmente orquestrado que transmite resultados sobre SSE.

Este tutorial conecta o servidor botoi MCP (49 ferramentas de desenvolvedor) a um agente gerenciado Claude. Pelo No final, você terá um agente autônomo que pode consultar registros DNS, validar e-mails, verificar SSL certificados, strings hash, decodificação de JWTs e muito mais; tudo a partir de uma única chamada de API.

O que são agentes gerenciados por Claude

Agentes gerenciados lançados em versão beta pública em 8 de abril de 2026. A ideia central: a Anthropic administra o agente loop do lado do servidor. Você define o modelo, o prompt do sistema, as ferramentas e os servidores MCP. Alças antrópicas sandboxing, orquestração de ferramentas, execução multiturno e streaming.

O agente é executado dentro de uma sessão. Cada sessão obtém seu próprio ambiente em sandbox, executa até um número configurável de turnos e transmite eventos de volta ao seu cliente via SSE. Quando o agente precisa de uma ferramenta, chama-a de forma autônoma, lê o resultado e continua raciocinando.

Todos os endpoints de Agentes Gerenciados exigem o managed-agents-2026-04-01 cabeçalho beta. O preço é a taxa de token padrão da API Claude mais US$ 0,08 por sessão-hora. Rede a pesquisa, se habilitada, custa US$ 10 por 1.000 pesquisas.

Crie um agente gerenciado com botoi MCP

A configuração é uma chamada de API. Você passa a URL do servidor botoi MCP no mcp_servers matriz, e o agente gerenciado descobre todas as 49 ferramentas no início da sessão.

enrolar

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

A resposta confirma o servidor MCP conectado e mostra quantas ferramentas foram descobertas:

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

Sem autenticação

Para testes rápidos, ignore totalmente a chave da API botoi:

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

Execute uma sessão: exemplo real

Com o agente criado, inicie uma sessão. Este exemplo pede ao agente para verificar três coisas sobre stripe.com em um único prompt. O agente descobre quais ferramentas MCP chamar, liga para elas sequência e monta um relatório.

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

O fluxo SSE mostra o raciocínio do agente, as chamadas de ferramentas e o 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"}

Três ferramentas chamadas, três resultados coletados, um resumo gerado. O agente escolheu lookup_ssl, lookup_email, e lookup_dns por conta própria com base no prompt. Nenhuma lógica de roteamento de ferramentas do seu lado.

Exemplos de Python e Node.js

Pitão

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

O que as 49 ferramentas cobrem

O servidor botoi MCP em https://api.botoi.com/mcp expõe 49 ferramentas selecionadas. Aqui está o que cada categoria inclui:

Cada ferramenta é somente leitura (exceto criptografar/descriptografar). O agente não pode modificar o estado externo, o que torna seguro operar de forma autônoma, sem portas de aprovação.

Detalhamento de custos

O preço dos Agentes Gerenciados tem três componentes:

• Taxas de token: Preço padrão da API Claude para o modelo que você escolher (Sonnet, Opus ou Haiku)
• Taxa por hora de sessão: US$ 0,08 por sessão-hora, proporcional ao segundo
• Pesquisa na web (opcional): US$ 10 por 1.000 pesquisas

As chamadas da ferramenta MCP para o botoi são gratuitas no lado Antrópico. Você paga apenas pelo uso da API botoi, e o o nível gratuito cobre 100 solicitações por dia. Esta é a aparência de uma sessão 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

Uma sessão de 3 minutos para verificar certificados SSL, validar e-mails e consultar DNS custa menos de US$ 0,10. A taxa por hora de sessão (US$ 0,004 por 3 minutos) é insignificante em comparação com os custos do token.

Agentes gerenciados vs. construir seu próprio ciclo de agentes

Você mesmo pode conectar ferramentas MCP ao Claude usando a API de mensagens com uso de ferramentas. A questão é se a sobrecarga de infraestrutura vale a 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}],
)

Se você precisar de controle refinado sobre roteamento de ferramentas, portas de aprovação personalizadas ou novas tentativas fora do padrão políticas, construa seu próprio ciclo. Se você quiser um agente rodando em produção com o mínimo de código, Os Agentes Gerenciados eliminam o clichê.

Quando usar qual abordagem

• Agentes gerenciados: ferramentas internas, chatbots com acesso a ferramentas, scripts de automação pontuais, protótipos rápidos que precisam de dados do mundo real
• Seu próprio circuito: produtos voltados para o usuário onde você precisa de UX personalizada por chamada de ferramenta, fluxos de trabalho que exigem aprovação humana, lógica de ramificação complexa que o agente não deve decidir de forma autônoma
• Ambas: comece com Agentes Gerenciados para o protótipo, extraia para seu próprio loop quando você atingir um limite de personalização