MCP vs A2A: picking the right AI agent protocol

Your AI agent needs to call a DNS lookup API. It also needs to hand off a research task to a separate agent on another server. These are two different problems, and the industry built two different protocols to solve them: MCP (Model Context Protocol) from Anthropic and A2A (Agent-to-Agent) from Google.

Developers keep asking which one to pick. The answer: they solve different problems. MCP connects a model to tools. A2A connects agents to agents. This guide breaks down the architecture, message format, auth model, and adoption of each protocol so you can make the right call for your system.

MCP in 60 seconds

MCP is an open protocol that gives AI models access to external tools and data. Think of it as a USB-C port for AI: one standard interface, many tools. The model sends a JSON-RPC request describing which tool to call and with what parameters. The MCP server executes the tool and returns structured data.

Here's what an MCP tool call looks like on the wire:

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

The model never touches the network directly. It describes intent ("look up MX records for stripe.com"), and the MCP server handles execution. This keeps the model sandboxed while giving it access to real-world data.

Botoi runs an MCP server at api.botoi.com/mcp with 49 developer tools. Connect it to Claude, Cursor, or VS Code in one line:

# 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 in 60 seconds

A2A is an open protocol for agent-to-agent communication. Where MCP connects a model to tools, A2A connects an agent to other agents. Each agent publishes an "Agent Card" at a well-known URL describing its skills, capabilities, and authentication requirements. Other agents discover this card and send tasks.

Here's an Agent Card:

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

And here's how one agent sends a task to another:

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

The key difference from MCP: A2A tasks are opaque. The calling agent doesn't know or control how the receiving agent completes the work. It could use MCP tools, call other agents via A2A, or run proprietary logic. A2A defines the contract between agents, not between a model and a tool.

Comparison table

Dimension	MCP (Model Context Protocol)	A2A (Agent-to-Agent)
Created by	Anthropic (Nov 2024)	Google (Apr 2025)
Core purpose	Connect AI models to tools and data	Connect AI agents to each other
Communication pattern	Model calls tool, gets result	Agent delegates task to agent
Wire format	JSON-RPC 2.0	JSON-RPC 2.0
Transport	stdio (local), Streamable HTTP (remote)	HTTPS
Discovery	Server exposes tool list via tools/list	Agent publishes Agent Card at /.well-known/agent.json
Auth model	Server-defined (API key, OAuth, none)	Agent Card declares schemes (bearer, OAuth 2.0, API key)
Streaming	Server-Sent Events for tool results	Server-Sent Events for task updates
Statefulness	Stateless or session-based	Task lifecycle (submitted, working, completed, failed)
Multimodal	Text-based tool results	Text, files, images, structured data in message parts
Scope of execution	Single tool call with defined inputs/outputs	Open-ended task; agent decides how to complete it

Architecture: how they fit together

MCP operates at the tool layer. A2A operates at the orchestration layer. In a multi-agent system, the orchestrator uses A2A to delegate tasks to specialist agents. Each specialist uses MCP to access its tools.

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

The orchestrator agent receives a request like "audit the security posture of example.com." It breaks this into subtasks and delegates them via A2A: one agent researches DNS and SSL, another checks for PII exposure, a third compiles the report. Each agent uses MCP to call the specific tools it needs.

When to use MCP

• Your AI model needs to call APIs, query databases, or read files
• You want a single agent with access to many tools (like the 49 tools on the Botoi MCP server)
• You need deterministic tool calls with defined input/output schemas
• You're building within a single trust boundary; the model and tools belong to the same system
• You want broad client support: Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, and ChatGPT all support MCP

When to use A2A

• You have multiple agents that need to delegate work to each other
• Agents span organizational boundaries (your agent talks to a vendor's agent)
• Tasks are open-ended; the calling agent doesn't prescribe how the work gets done
• You need a task lifecycle with status tracking (submitted, working, completed, failed)
• Agents exchange rich content: files, images, and structured data, not tool parameters

Auth and trust models

MCP has a simple auth story. The MCP server decides its own authentication. Some servers need no auth (local file system access). Others require an API key or OAuth token. The client passes credentials in headers. There's no protocol-level auth negotiation.

A2A builds auth into the discovery layer. Each Agent Card declares its supported authentication schemes. The calling agent reads the card, picks a scheme, and authenticates before sending tasks. This works well for cross-organization scenarios where agents need to negotiate trust at runtime.

For the Botoi MCP server, anonymous access gives you 5 requests per minute and 100 per day. Add an API key in the Authorization header for higher limits:

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

Adoption in 2026

MCP has a head start. Anthropic shipped MCP in November 2024, and by early 2026 every major AI coding assistant supports it. Claude Desktop, Claude Code, Cursor, VS Code (GitHub Copilot), Windsurf, and ChatGPT all act as MCP clients. The ecosystem has thousands of MCP servers covering databases, APIs, file systems, browsers, and developer tools.

A2A is newer. Google released the spec in April 2025. Adoption is growing in enterprise environments where multi-agent orchestration matters: supply chain automation, document processing pipelines, and customer service systems with specialist agents. The Agent Card discovery mechanism makes it easier to build agent marketplaces and directories.

If you're building a single-agent tool-calling system today, MCP has the ecosystem. If you're building multi-agent orchestration, A2A provides the coordination layer you need.

A concrete MCP example: botoi's 49 tools

Botoi's MCP server at api.botoi.com/mcp shows what MCP looks like in production. It exposes 49 curated developer tools across five categories:

Category	Count	Example tools
Lookup	12	dns_lookup, whois_lookup, ssl_check, email_validate, tech_detect
Text and data	10	json_format, base64_encode, csv_to_json, markdown_to_html
Developer	12	jwt_sign, uuid_generate, hash, cron_describe, regex_test
Security	5	aes_encrypt, pii_detect, totp_generate, credit_card_validate
Transform	5	minify_js, sql_format, code_format, json_to_typescript

The server uses Streamable HTTP transport, runs on Cloudflare Workers at the edge, and requires zero configuration beyond the one-line setup. Each tool has a typed input schema and returns structured JSON. The full tool manifest is at api.botoi.com/v1/mcp/tools.json.

This is MCP at its core: one server, many tools, structured I/O, and a standard protocol any compatible client can connect to.

Decision framework

Ask these three questions:

1. Does your AI model need to call external tools? Use MCP. Connect to an MCP server (or build your own) and your model gets structured tool access.
2. Do you have multiple agents that need to collaborate? Use A2A. Publish Agent Cards, send tasks, and track their lifecycle.
3. Do you have both? Use both. A2A at the orchestration layer, MCP at the tool layer. They operate at different levels and don't conflict.

The choice isn't MCP or A2A. It's MCP, A2A, or MCP + A2A, depending on your system's complexity. Start with MCP if you need tool access. Add A2A when you need agent coordination.

Get started with MCP

Connect your AI assistant to 49 developer tools through the Botoi MCP server. Check the MCP setup docs for configs for Claude Desktop, Claude Code, Cursor, VS Code, and Windsurf. Browse the API docs for the full list of 150+ endpoints behind the MCP server.