MCP vs A2A: escolhendo o protocolo de agente de IA certo

Seu agente de IA precisa chamar uma API de pesquisa de DNS. Ele também precisa entregar uma tarefa de pesquisa a um agente separado em outro servidor. Estes são dois problemas diferentes, e a indústria construiu dois protocolos diferentes para resolvê-los: PCM (Protocolo de Contexto Modelo) da Antrópica e A2A (Agente para Agente) do Google.

Os desenvolvedores continuam perguntando qual escolher. A resposta: eles resolvem problemas diferentes. MCP conecta um modelo a ferramentas. A2A conecta agentes a agentes. Este guia detalha a arquitetura, o formato da mensagem, o modelo de autenticação e a adoção de cada protocolo para que você possa fazer a chamada certa para o seu sistema.

MCP em 60 segundos

MCP é um protocolo aberto que dá aos modelos de IA acesso a ferramentas e dados externos. Pense nisso como uma porta USB-C para IA: uma interface padrão, muitas ferramentas. O modelo envia uma solicitação JSON-RPC descrevendo qual ferramenta chamar e com quais parâmetros. O servidor MCP executa a ferramenta e retorna dados estruturados.

Esta é a aparência de uma chamada de ferramenta MCP na transmissão:

// MCP tool call: model asks the server to execute a tool
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "lookup_dns",
    "arguments": {
      "domain": "stripe.com",
      "type": "MX"
    }
  },
  "id": 1
}

// MCP tool result: server returns structured data
{
  "jsonrpc": "2.0",
  "result": {
    "content": [
      {
        "type": "text",
        "text": "{\"domain\":\"stripe.com\",\"type\":\"MX\",\"records\":[{\"priority\":1,\"value\":\"aspmx.l.google.com\",\"ttl\":300}]}"
      }
    ]
  },
  "id": 1
}

O modelo nunca toca a rede diretamente. Ele descreve a intenção ("procurar registros MX para stripe.com") e o servidor MCP cuida da execução. Isso mantém o modelo em área restrita, ao mesmo tempo que lhe dá acesso a dados do mundo real.

Botoi executa um servidor MCP em api.botoi.com/mcp com 49 ferramentas de desenvolvedor. Conecte-o ao Claude, Cursor ou VS Code em uma linha:

# Connect botoi's 49 tools via MCP in one command
claude mcp add botoi --transport streamable-http https://api.botoi.com/mcp

# Now your agent can call tools like:
# lookup_dns, lookup_whois, ssl_check, jwt_sign,
# pii_detect, email_validate, hash, uuid_generate,
# json_format, base64_encode, and 39 more

A2A em 60 segundos

A2A é um protocolo aberto para comunicação entre agentes. Enquanto o MCP conecta um modelo a ferramentas, o A2A conecta um agente a outros agentes. Cada agente publica um “Cartão de Agente” em uma URL conhecida, descrevendo suas habilidades, capacidades e requisitos de autenticação. Outros agentes descobrem este cartão e enviam tarefas.

Aqui está um cartão de agente:

// A2A Agent Card: published at /.well-known/agent.json
{
  "name": "invoice-processor",
  "description": "Extracts line items from PDF invoices and returns structured data",
  "url": "https://agents.example.com/invoice",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": false
  },
  "skills": [
    {
      "id": "extract-invoice",
      "name": "Extract Invoice Data",
      "description": "Parses a PDF invoice and returns line items as JSON"
    }
  ],
  "authentication": {
    "schemes": ["bearer"]
  }
}

E é assim que um agente envia uma tarefa para outro:

// A2A task/send: one agent asks another to do work
{
  "jsonrpc": "2.0",
  "method": "tasks/send",
  "params": {
    "id": "task-abc-123",
    "message": {
      "role": "user",
      "parts": [
        {
          "type": "text",
          "text": "Extract line items from this invoice PDF"
        },
        {
          "type": "file",
          "mimeType": "application/pdf",
          "uri": "https://storage.example.com/invoices/2026-march.pdf"
        }
      ]
    }
  },
  "id": 2
}

A principal diferença do MCP: as tarefas A2A são opacas. O agente chamador não sabe nem controla como o agente receptor conclui o trabalho. Poderia usar ferramentas MCP, chamar outros agentes via A2A ou executar lógica proprietária. A2A define o contrato entre agentes, não entre um modelo e uma ferramenta.

Tabela de comparação

Dimensão	MCP (protocolo de contexto de modelo)	A2A (agente para agente)
Criado por	Antrópico (novembro de 2024)	Google (abril de 2025)
Objetivo principal	Conecte modelos de IA a ferramentas e dados	Conecte agentes de IA entre si
Padrão de comunicação	Ferramenta de chamadas de modelo, obtém resultado	Agente delega tarefa ao agente
Formato de fio	JSON-RPC 2.0	JSON-RPC 2.0
Transporte	stdio (local), HTTP streamável (remoto)	HTTPS
Descoberta	Servidor expõe lista de ferramentas via tools/list	Agente publica Cartão de Agente em /.well-known/agent.json
Modelo de autenticação	Definido pelo servidor (chave de API, OAuth, nenhum)	Cartão de agente declara esquemas (portador, OAuth 2.0, chave API)
Transmissão	Eventos enviados pelo servidor para resultados da ferramenta	Eventos enviados pelo servidor para atualizações de tarefas
Estado	Sem estado ou baseado em sessão	Ciclo de vida da tarefa (enviada, funcionando, concluída, com falha)
Multimodal	Resultados da ferramenta baseada em texto	Texto, arquivos, imagens, dados estruturados em partes da mensagem
Escopo de execução	Chamada de ferramenta única com entradas/saídas definidas	Tarefa aberta; o agente decide como concluí-lo

Arquitetura: como elas se encaixam

O MCP opera na camada de ferramenta. A2A opera na camada de orquestração. Num sistema multiagente, o orquestrador utiliza A2A para delegar tarefas a agentes especializados. Cada especialista utiliza o MCP para acessar suas ferramentas.

Orchestrator Agent (A2A client)
  |
  |-- A2A task/send --> Research Agent
  |                        |-- MCP tools/call --> lookup_dns
  |                        |-- MCP tools/call --> lookup_whois
  |                        |-- MCP tools/call --> ssl_check
  |
  |-- A2A task/send --> Compliance Agent
  |                        |-- MCP tools/call --> pii_detect
  |                        |-- MCP tools/call --> email_validate
  |
  |-- A2A task/send --> Report Agent
                           |-- MCP tools/call --> markdown_to_html
                           |-- MCP tools/call --> pdf_from_html

O agente orquestrador recebe uma solicitação como "auditar a postura de segurança de example.com". Ele divide isso em subtarefas e as delega via A2A: um agente pesquisa DNS e SSL, outro verifica a exposição de PII, um terceiro compila o relatório. Cada agente usa o MCP para chamar as ferramentas específicas de que necessita.

Quando usar o MCP

• Seu modelo de IA precisa chamar APIs, consultar bancos de dados ou ler arquivos
• Você quer um único agente com acesso a muitas ferramentas (como as 49 ferramentas no servidor Botoi MCP)
• Você precisa de chamadas de ferramentas determinísticas com esquemas de entrada/saída definidos
• Você está construindo dentro de um único limite de confiança; o modelo e as ferramentas pertencem ao mesmo sistema
• Você deseja amplo suporte ao cliente: Claude Desktop, Claude Code, Cursor, VS Code, Windsurf e ChatGPT oferecem suporte a MCP

Quando usar A2A

• Você tem vários agentes que precisam delegar trabalho uns aos outros
• Os agentes ultrapassam os limites organizacionais (seu agente conversa com o agente de um fornecedor)
• As tarefas são abertas; o agente chamador não prescreve como o trabalho será feito
• Você precisa de um ciclo de vida de tarefa com rastreamento de status (enviado, funcionando, concluído, com falha)
• Os agentes trocam conteúdo rico: arquivos, imagens e dados estruturados, não parâmetros de ferramentas

Modelos de autenticação e confiança

O MCP tem uma história de autenticação simples. O servidor MCP decide sua própria autenticação. Alguns servidores não precisam de autenticação (acesso ao sistema de arquivos local). Outros exigem uma chave API ou token OAuth. O cliente passa credenciais nos cabeçalhos. Não há negociação de autenticação em nível de protocolo.

A2A incorpora autenticação na camada de descoberta. Cada Cartão de Agente declara seus esquemas de autenticação suportados. O agente chamador lê o cartão, escolhe um esquema e autentica antes de enviar tarefas. Isso funciona bem para cenários entre organizações em que os agentes precisam negociar a confiança em tempo de execução.

Para o servidor Botoi MCP, o acesso anônimo oferece 5 solicitações por minuto e 100 por dia. Adicione uma chave de API no Authorization cabeçalho para limites mais altos:

{
  "mcpServers": {
    "botoi": {
      "type": "streamable-http",
      "url": "https://api.botoi.com/mcp"
    }
  }
}

Adoção em 2026

O MCP tem uma vantagem inicial. A Anthropic lançou o MCP em novembro de 2024 e, no início de 2026, todos os principais assistentes de codificação de IA o suportam. Claude Desktop, Claude Code, Cursor, VS Code (GitHub Copilot), Windsurf e ChatGPT atuam como clientes MCP. O ecossistema possui milhares de servidores MCP que cobrem bancos de dados, APIs, sistemas de arquivos, navegadores e ferramentas de desenvolvedor.

A2A é mais recente. O Google lançou a especificação em abril de 2025. A adoção está crescendo em ambientes empresariais onde a orquestração multiagente é importante: automação da cadeia de suprimentos, pipelines de processamento de documentos e sistemas de atendimento ao cliente com agentes especializados. O mecanismo de descoberta do Agent Card facilita a criação de mercados e diretórios de agentes.

Se você está construindo hoje um sistema de chamada de ferramenta de agente único, o MCP tem o ecossistema. Se você estiver construindo uma orquestração multiagente, o A2A fornece a camada de coordenação necessária.

Um exemplo concreto de MCP: as 49 ferramentas do botoi

Servidor MCP do Botoi em api.botoi.com/mcp mostra como é o MCP em produção. Ele expõe 49 ferramentas de desenvolvedor selecionadas em cinco categorias:

Categoria	Contar	Ferramentas de exemplo
Pesquisa	12	dns_lookup, whois_lookup, ssl_check, email_validate, tech_detect
Texto e dados	10	json_format, base64_encode, csv_to_json, markdown_to_html
Desenvolvedora	12	jwt_sign, uuid_generate, hash, cron_describe, regex_test
Segurança	5	aes_encrypt, pii_detect, totp_generate, credit_card_validate
Transformar	5	minify_js, sql_format, code_format, json_to_typescript

O servidor usa transporte HTTP Streamable, é executado em Cloudflare Workers na borda e não requer nenhuma configuração além da configuração de uma linha. Cada ferramenta possui um esquema de entrada digitado e retorna JSON estruturado. O manifesto completo da ferramenta está em api.botoi.com/v1/mcp/tools.json.

Este é o MCP em sua essência: um servidor, muitas ferramentas, E/S estruturada e um protocolo padrão ao qual qualquer cliente compatível pode se conectar.

Quadro de decisão

Faça estas três perguntas:

1. O seu modelo de IA precisa chamar ferramentas externas? Utilize o MCP. Conecte-se a um servidor MCP (ou crie o seu próprio) e seu modelo terá acesso estruturado à ferramenta.
2. Você tem vários agentes que precisam colaborar? Utilize A2A. Publique cartões de agente, envie tarefas e acompanhe seu ciclo de vida.
3. Você tem os dois? Use ambos. A2A na camada de orquestração, MCP na camada de ferramentas. Eles operam em níveis diferentes e não entram em conflito.

A escolha não é MCP ou A2A. É MCP, A2A ou MCP + A2A, dependendo da complexidade do seu sistema. Comece com o MCP se precisar de acesso à ferramenta. Adicione A2A quando precisar de coordenação de agentes.

Comece com o MCP

Conecte seu assistente de IA a 49 ferramentas de desenvolvedor por meio do servidor Botoi MCP. Verifique o Documentos de configuração do MCP para configurações para Claude Desktop, Claude Code, Cursor, VS Code e Windsurf. Navegue pelo Documentos da API para obter a lista completa de mais de 150 endpoints atrás do servidor MCP.