---
title: "A2A protocol vs MCP: differences and when to use each"
description: "A2A protocol vs MCP: A2A connects AI agents to other agents, and MCP connects an agent to tools and data. Compare agent cards, tasks, transports, and security."
summary: "The A2A (Agent2Agent) protocol is an open standard for communication between independent AI agents, while MCP standardizes how one agent connects to tools and data. This comparison covers agent cards, tasks, wire formats, security, how the two protocols combine, and when to use each."
type: "comparison"
canonical_url: "https://theaiengineering.com/articles/a2a-vs-mcp"
markdown_url: "https://theaiengineering.com/articles/a2a-vs-mcp.md"
topic: "Model Context Protocol"
author: "The AI Engineering Editors"
publisher: "The AI Engineering"
published: "2026-09-08"
updated: "2026-11-11"
keywords: ["a2a protocol vs mcp","a2a protocol","a2a protocol agent card","a2a vs mcp","when to use a2a vs mcp"]
citation: "The AI Engineering Editors. \"A2A protocol vs MCP: differences and when to use each.\" The AI Engineering, updated Nov 11, 2026. https://theaiengineering.com/articles/a2a-vs-mcp"
---

# A2A protocol vs MCP: differences and when to use each

## TL;DR

- The A2A (Agent2Agent) protocol connects independent AI agents to each other, while the Model Context Protocol (MCP) connects a single AI application to tools, data, and prompts.
- Google launched A2A in April 2025 and contributed it to the Linux Foundation in June 2025; the first stable specification, v1.0, shipped in March 2026, and A2A joined the Agentic AI Foundation, which also hosts MCP, in August 2026.
- An A2A agent publishes an Agent Card, typically at /.well-known/agent-card.json, that lists its skills, endpoints, and security schemes, and work runs through stateful Tasks that produce Artifacts.
- A2A treats a remote agent as an opaque system that shares results but not its memory or tools; MCP exposes individual tools with JSON Schema inputs for a model to call.
- Most multi-agent systems that cross team or vendor boundaries use both protocols: A2A between agents, and MCP inside each agent for its own tools.

A2A and MCP are open protocols for agentic AI systems that cover different connections: the [Agent2Agent (A2A) protocol](https://theaiengineering.com/glossary/a2a-protocol) lets independent AI agents discover each other and delegate work, while the [Model Context Protocol (MCP)](https://theaiengineering.com/glossary/model-context-protocol) lets one AI application use tools and data. Comparing the A2A protocol vs MCP comes down to which boundary each one governs, because systems that adopt one often end up using both. This comparison covers concepts, wire formats, state, security, and governance, then shows how the protocols combine in a single architecture.

## A2A protocol vs MCP at a glance

A2A is a peer protocol: a client agent hands a task to a remote agent and tracks it until the remote agent returns results. MCP is a capability protocol: an AI application's MCP client lists and calls tools, resources, and prompts on an [MCP server](https://theaiengineering.com/glossary/mcp-server). Both use [JSON-RPC 2.0](https://theaiengineering.com/glossary/json-rpc) and HTTP, and both now live in the same foundation.

| Dimension | A2A | MCP |
|---|---|---|
| Connects | A client agent to a remote agent | An AI application to tools, data, and prompts |
| Unit of work | Task with a lifecycle and artifacts | One request, most often `tools/call` |
| State | Stateful tasks, grouped by `contextId` | Stateless since 2026-07-28; state via explicit handles |
| Discovery | Agent Card at a well-known URL | `server/discover` plus `*/list` methods |
| Interface exposed | Skills described in natural language | Tools with JSON Schema inputs and outputs |
| Bindings | JSON-RPC 2.0, gRPC, HTTP+JSON | stdio and Streamable HTTP, both JSON-RPC 2.0 |
| Async model | Polling, SSE streaming, push webhooks | Request-scoped SSE; optional Tasks extension |
| Authentication | Schemes declared in the Agent Card | OAuth 2.1 flow for HTTP; environment for stdio |
| Normative source | Protocol Buffers file (`a2a.proto`) | TypeScript schema |
| Origin | Google, April 2025 | Anthropic, November 2024 |
| Governance | Agentic AI Foundation (Linux Foundation) | Agentic AI Foundation (Linux Foundation) |

## What is the A2A protocol?

The Agent2Agent (A2A) protocol is an open standard that lets AI agents from different frameworks and vendors discover each other's capabilities and collaborate on tasks over HTTP.

Google announced A2A in April 2025 and contributed it to the Linux Foundation in June 2025, with AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow among the founding organizations. IBM's Agent Communication Protocol merged into A2A in August 2025. Version 1.0, the first stable specification, shipped in March 2026; the Linux Foundation highlighted its multi-protocol support, multi-tenancy, modernized security flows, and signed [Agent Cards](https://theaiengineering.com/glossary/agent-card). In April 2026 the Linux Foundation reported more than 150 supporting organizations, and in August 2026 A2A [joined the Agentic AI Foundation](https://aaif.io/blog/a2a-joins-aaif) as a hosted project, alongside MCP.

The [A2A specification](https://a2a-protocol.org/latest/specification/) states its design goals plainly: reuse HTTP, JSON-RPC 2.0, and server-sent events; design for long-running and human-in-the-loop work; stay agnostic about content types; and keep execution opaque. Opacity is the defining choice. Agents collaborate "without needing access to each other's internal state, memory, or tools," which means a remote [AI agent](https://theaiengineering.com/glossary/ai-agent) can be built on any [agent framework](https://theaiengineering.com/articles/ai-agent-frameworks), any model, and any toolset without the caller needing to know.

## How does the A2A protocol work?

An A2A interaction has a client agent and a remote agent. The client reads the remote agent's Agent Card, sends a Message made of one or more Parts, and receives either a direct Message or a Task. A Task moves through states until it finishes, and its results arrive as Artifacts.

The core objects are small in number:

- **Message:** one turn of communication, with a role (user or agent), a message ID, and one or more Parts.
- **Part:** the content container, holding exactly one of text, inline bytes, a URL to a file, or structured JSON data, plus an optional media type.
- **Task:** the stateful unit of work, with a server-generated ID, a status, a history, and artifacts.
- **Artifact:** a concrete output of a task, such as a document, an image, or structured data, built from Parts.
- **Context ID:** an optional identifier that groups related tasks and messages into one conversation.

Version 1.0 names its operations in PascalCase across bindings: `SendMessage`, `SendStreamingMessage`, `GetTask`, `ListTasks`, `CancelTask`, `SubscribeToTask`, `GetExtendedAgentCard`, and four methods for managing push notification configurations. Clients send an `A2A-Version` header on each request so agents can upgrade without breaking older callers.

**Figure 1: The A2A task lifecycle, including the two interrupted states.**

SendMessage creates a submitted task that moves to working. Working can pause in input-required or auth-required until the client replies, then ends in a terminal state.

Components:

- **SendMessage**
- **submitted**
- **working**
- **Interrupted**: input-required auth-required
- **Terminal state**: completed · failed · canceled · rejected

Connections:

- SendMessage → submitted
- submitted → working
- working → Interrupted: needs input
- Interrupted → working: client replies
- working → Terminal state

By default, `SendMessage` blocks until the task reaches a terminal state or an interrupted one. A client can instead ask for an immediate return and then poll `GetTask`, subscribe to a server-sent events stream, or register a webhook for push notifications, which suits tasks that run for hours. The `auth-required` state lets a remote agent request a secondary credential partway through a task, which the client obtains outside the protocol.

## What is an A2A agent card?

An Agent Card is a JSON document that describes an A2A agent: its name, description, provider, version, the interfaces and protocol bindings it supports, its capabilities, its skills, and the security schemes a client must use. The standard discovery location is `https://{domain}/.well-known/agent-card.json`, though clients can also find cards through registries or direct configuration.

A trimmed example, following the v1.0 field names:

```json
{
  "name": "Invoice Reconciliation Agent",
  "description": "Matches supplier invoices to purchase orders.",
  "version": "2.1.0",
  "provider": {
    "organization": "Example Finance Ops",
    "url": "https://finance.example.com"
  },
  "supportedInterfaces": [
    {
      "url": "https://agents.example.com/a2a/v1",
      "protocolBinding": "JSONRPC",
      "protocolVersion": "1.0"
    }
  ],
  "capabilities": { "streaming": true, "pushNotifications": true },
  "defaultInputModes": ["application/json", "text/plain"],
  "defaultOutputModes": ["application/json"],
  "skills": [
    {
      "id": "reconcile-invoices",
      "name": "Reconcile invoices",
      "description": "Compares invoices against open POs for a vendor.",
      "tags": ["finance", "accounts-payable"],
      "examples": ["Reconcile March invoices for vendor 4471"]
    }
  ]
}
```

Three details separate an Agent Card from an MCP tool list. Skills are described in natural language with tags and examples, not with a JSON Schema for arguments, because the remote agent interprets the request itself. Security requirements live in the card through `securitySchemes` and `securityRequirements`, covering API keys, HTTP authentication, OAuth 2.0, OpenID Connect, and mutual TLS. And in v1.0 a card can carry JWS signatures, so a client can verify who published it. Agents that set `extendedAgentCard` to true can return a richer card to authenticated callers.

## A2A vs MCP: the differences that matter

The differences between A2A and MCP follow from one design decision: A2A models the remote side as an autonomous agent, and MCP models it as a set of capabilities. That decision shapes how each protocol handles state, discovery, interfaces, and failure, and it determines which protocol fits a given boundary in a system.

### Peers vs tools

An MCP tool is a function with a typed contract, the same shape as [tool calling](https://theaiengineering.com/glossary/tool-calling) in a model API. The calling model sees its name, description, and input schema, and the host executes exactly the call the model emitted. An A2A skill is a capability of a system the caller cannot see into. The client sends a goal in a Message, and the remote agent plans, calls its own tools, and may ask clarifying questions. MCP gives the caller control and visibility; A2A gives the remote party autonomy and privacy.

### Stateful tasks vs stateless requests

A2A is stateful by design: a Task has an ID, a history, and a lifecycle, and related tasks share a context ID. The current MCP revision, 2026-07-28, went the other way and removed protocol-level sessions, so every MCP request stands alone and servers that need continuity mint explicit handles. MCP covers long-running work through an optional Tasks extension, whereas in A2A the task is the core abstraction.

### Wire format and bindings

Both protocols build on JSON-RPC 2.0, but A2A also defines gRPC and HTTP+JSON bindings with equivalent behavior and treats a Protocol Buffers file as its normative definition. MCP defines stdio for local subprocess servers and [Streamable HTTP](https://theaiengineering.com/glossary/mcp-transport) for remote ones. A2A defines no standard local subprocess binding, which reflects its focus on agents deployed as network services.

The following map shows the closest MCP equivalent for each A2A concept, and where the analogy breaks:

| A2A concept | Closest MCP equivalent | Where they differ |
|---|---|---|
| Agent Card | `server/discover` and `tools/list` | Card is a static document at a URL; MCP discovery is an RPC |
| Skill | Tool | Skill takes a goal in natural language; tool takes typed arguments |
| Task | Tasks extension handle | Core in A2A; opt-in extension in MCP |
| `input-required` state | `input_required` result with elicitation | A2A pauses a task; MCP has the client retry the request |
| Artifact | Tool result `content` or `structuredContent` | Artifacts can stream as appended chunks during a task |
| Push notification webhook | `subscriptions/listen` stream | A2A pushes task updates; MCP streams list and resource changes |

## How do A2A and MCP work together?

A2A and MCP stack rather than compete. A common pattern has an [orchestrator agent](https://theaiengineering.com/glossary/agent-orchestration) that acts as an A2A server to its caller, an A2A client to specialist agents, and an MCP host for its own tools. Each specialist runs its own MCP clients internally, and none of those tools are visible across the A2A boundary.

**Figure 2: A2A carries tasks between agents; MCP connects each agent to its tools.**

A caller sends an A2A task to an orchestrator, which uses a CRM server over MCP and delegates A2A tasks to billing and shipping agents with their own MCP servers.

Components:

- **Caller**: user or calling application
- **Orchestrator agent**: A2A server to its caller A2A client to specialists MCP host for its own tools
- **CRM server**: MCP server
- **Billing agent**
- **Shipping agent**
- **ERP and ledger**: MCP servers
- **Carrier API**: MCP server

Groups:

- Finance team: Billing agent, ERP and ledger
- Partner org: Shipping agent, Carrier API

Connections:

- Caller → Orchestrator agent: A2A task
- Orchestrator agent → CRM server: MCP
- Orchestrator agent → Billing agent: A2A task
- Orchestrator agent → Shipping agent: A2A task
- Billing agent → ERP and ledger: MCP
- Shipping agent → Carrier API: MCP

The [A2A and MCP guide](https://a2a-protocol.org/latest/topics/a2a-and-mcp/) on the A2A site uses an auto repair shop to make the same point. A customer talks to a shop manager agent over A2A, the manager delegates to a mechanic agent, the mechanic uses MCP to reach diagnostic scanners and repair manuals, and the mechanic contacts a parts supplier's agent over A2A again. The guide summarizes the split as MCP giving each agent depth and A2A giving the system reach.

A shortcut some teams take is wrapping a [sub-agent](https://theaiengineering.com/glossary/subagent) as an MCP tool. That works when the sub-agent behaves like a function: one request, one answer, seconds of latency. It breaks down when the work needs a task lifecycle, mid-task questions, progress streaming, or a boundary where the other party must not expose its prompts and tools. Those are the cases A2A was built for.

## When to use A2A vs MCP

Use MCP when an AI application needs to reach tools, data, or prompts, whether the server is local or remote. Use A2A when work crosses to another agent that should run on its own terms, especially across teams, vendors, or organizations. Inside one codebase, the multi-agent features of [agent frameworks](https://theaiengineering.com/platforms/agent-frameworks) are often simpler than either protocol.

| Scenario | Protocol | Reason |
|---|---|---|
| A coding agent needs GitHub, a database, and internal docs | MCP | Tool and data access for one application |
| A SaaS company wants its API usable from many AI clients | MCP server | One server works across MCP hosts |
| A support agent hands a refund case to finance's agent | A2A | Delegation to an autonomous peer with its own policies |
| A company calls a partner's agent without seeing its internals | A2A | Opaque execution across an organizational boundary |
| A job runs for hours and needs a human approval midway | A2A | Task lifecycle, `input-required`, push notifications |
| Several sub-agents run in one process on one framework | Often neither | Framework-native orchestration has less overhead |
| A sub-agent behaves like a fast, stateless function | MCP tool | A typed tool contract is simpler than a task |

The last two rows matter most for teams starting out. A [multi-agent system](https://theaiengineering.com/glossary/multi-agent-system) inside one service rarely needs a network protocol between its parts, and the [AI agents explainer](https://theaiengineering.com/articles/what-are-ai-agents) covers when multiple agents help at all. A2A earns its overhead at boundaries where agents are deployed, owned, or secured separately.

## Security and governance compared

Both protocols rely on standard web authentication, but they place trust differently. MCP specifies an OAuth 2.1 authorization flow in detail and expects the host to ask the user before tool calls. A2A declares security schemes in the Agent Card, carries credentials in HTTP headers, and makes each remote agent the gatekeeper for its own data.

On the A2A side, production traffic must use HTTPS, servers return 401 for missing credentials and 403 for insufficient permissions, and authorization can be scoped per skill. Credentials are obtained outside the protocol, and the A2A documentation recommends OpenTelemetry trace context propagation so a request can be followed across agent hops. On the MCP side, tokens must be bound to a single server through Resource Indicators, servers must not pass client tokens through to downstream APIs, and hosts should sandbox local servers. The [MCP explainer](https://theaiengineering.com/articles/what-is-model-context-protocol) covers those controls in detail.

One risk crosses both boundaries. Text that comes back from a remote agent or from a tool enters the calling model's context, so [prompt injection](https://theaiengineering.com/glossary/prompt-injection) can travel through A2A artifacts as easily as through MCP tool results. Treat both as untrusted input, log both for [LLM observability](https://theaiengineering.com/articles/llm-observability), and route both through policy enforcement points such as an AI gateway where the organization needs central control. [Bifrost](https://docs.getbifrost.ai/features/agent-gateway/overview), for example, proxies A2A agents through its Agent Gateway and MCP servers through its MCP gateway, and its agent logs follow one session across tasks, model calls, and MCP calls.

Governance has converged. Both protocols are hosted by the Agentic AI Foundation under the Linux Foundation, both publish open specifications with public change processes, and the A2A specification describes the two as complementary in an appendix devoted to MCP.

## Where to go next

For the full mechanics of the tool side, read [what is the Model Context Protocol](https://theaiengineering.com/articles/what-is-model-context-protocol), which covers transports, authorization, and gateways. To see how agents use tools in the first place, the [tool calling guide](https://theaiengineering.com/articles/tool-calling) explains the model-side loop. The [MCP topic hub](https://theaiengineering.com/topics/mcp) collects every related guide and glossary entry.

## Frequently asked questions

### Can A2A replace MCP?

No. A2A and MCP cover different boundaries, so neither replaces the other. A2A defines how one agent delegates a task to another agent and tracks it to completion. MCP defines how an agent discovers and calls tools, reads resources, and uses prompts. An agent that receives work over A2A usually still uses MCP to reach the systems it needs.

### Does A2A use MCP?

The A2A specification does not depend on MCP, but the two are designed to be used together. The A2A specification describes a remote agent that receives a task over A2A and then uses MCP to call the tools, APIs, and data sources it needs. Those MCP tools stay internal to that agent and are not exposed to the A2A client.

### Who created the A2A protocol?

Google created the Agent2Agent protocol and announced it in April 2025. Google contributed A2A to the Linux Foundation in June 2025, with AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow among the founding organizations, and IBM's Agent Communication Protocol merged into A2A in August 2025. A2A became a hosted project of the Agentic AI Foundation in August 2026.

### Is the A2A protocol open source?

Yes. The A2A specification, its Protocol Buffers definition, and official SDKs are developed in public under the a2aproject GitHub organization, and the project is governed under the Linux Foundation as a hosted project of the Agentic AI Foundation. The main A2A repository is licensed under Apache 2.0, so anyone can implement a client or server.

### Does A2A use gRPC?

A2A supports gRPC as one of three standard protocol bindings in version 1.0, alongside JSON-RPC 2.0 and HTTP+JSON (REST). All bindings must provide equivalent behavior, and an agent lists the bindings it supports, with a URL for each, in the supportedInterfaces field of its Agent Card. The normative data model is a Protocol Buffers file.

## Terms in this guide

- [A2A protocol](https://theaiengineering.com/glossary/a2a-protocol): The A2A (Agent2Agent) protocol is an open standard, introduced by Google in April 2025, that lets AI agents built on different frameworks discover each other, exchange messages, and delegate tasks.
- [Model Context Protocol (MCP)](https://theaiengineering.com/glossary/model-context-protocol): Model Context Protocol (MCP) is an open protocol, introduced by Anthropic in November 2024, that standardizes how AI applications connect to external tools, data sources, and prompts through MCP servers.
- [MCP server](https://theaiengineering.com/glossary/mcp-server): An MCP server is a program that exposes tools, resources, and prompts to AI applications through the Model Context Protocol, running locally over stdio or remotely over Streamable HTTP.
- [Multi-agent system](https://theaiengineering.com/glossary/multi-agent-system): A multi-agent system is an AI architecture in which several language-model agents, each with its own prompt, tools, and context, work on parts of a task and pass results to one another.
- [AI agent](https://theaiengineering.com/glossary/ai-agent): An AI agent is a software system in which a large language model runs in a loop, calling tools, reading their results, and repeating until the task is complete or a stop condition is reached.
- [Prompt injection](https://theaiengineering.com/glossary/prompt-injection): Prompt injection is an attack in which text supplied to a large language model, typed by a user or hidden in content the model reads, alters the application's intended behavior or output.
- [JSON-RPC](https://theaiengineering.com/glossary/json-rpc): JSON-RPC is a lightweight, transport-agnostic remote procedure call protocol that encodes method calls, results, and errors as JSON objects; version 2.0 is the message format of MCP and A2A.
- [Agent Card](https://theaiengineering.com/glossary/agent-card): An Agent Card is a JSON document that an A2A server publishes, usually at /.well-known/agent-card.json, describing the agent's identity, endpoints, capabilities, skills, and authentication requirements.
- [Human-in-the-loop](https://theaiengineering.com/glossary/human-in-the-loop): Human-in-the-loop (HITL) is an agent design in which the run pauses at defined checkpoints, such as before a sensitive tool call, so a person can approve, edit, or reject the action.
- [LLM streaming](https://theaiengineering.com/glossary/llm-streaming): LLM streaming is the delivery of a language model's output in small chunks as it is generated, usually as server-sent events over HTTP, so clients can show text before the response is complete.
- [JSON Schema](https://theaiengineering.com/glossary/json-schema): JSON Schema is a declarative vocabulary, itself written in JSON, for describing the structure of JSON data; LLM APIs and MCP use it to define tool arguments and constrain model output.
- [MCP transport](https://theaiengineering.com/glossary/mcp-transport): An MCP transport is the binding that carries Model Context Protocol messages between a client and a server; the specification defines stdio for local subprocesses and Streamable HTTP for remote servers.
- [Agent orchestration](https://theaiengineering.com/glossary/agent-orchestration): Agent orchestration is the control logic that decides which agent, model call, or tool runs next in an AI system and what each receives, whether written in code or chosen by a model.
- [Subagent](https://theaiengineering.com/glossary/subagent): A subagent is an AI agent that another agent starts for one subtask, running in a separate context window with its own instructions and tools, and returning only a condensed result.
- [OpenTelemetry](https://theaiengineering.com/glossary/opentelemetry): OpenTelemetry is an open source, vendor-neutral observability framework of APIs, SDKs, a wire protocol, and naming conventions for traces, metrics, and logs, including conventions for LLM calls and agent runs.
- [Agent sandbox](https://theaiengineering.com/glossary/agent-sandbox): An agent sandbox is an isolated execution environment in which an AI agent runs code, shell commands, or a browser, with enforced limits on the files, network hosts, and credentials it can reach.
- [Agentic AI](https://theaiengineering.com/glossary/agentic-ai): Agentic AI is the class of AI systems that pursue a goal through multiple steps, using a language model to plan, call tools, and act on the results with limited human input.
- [AI gateway](https://theaiengineering.com/glossary/ai-gateway): An AI gateway is a proxy layer between applications and model providers that exposes one API for many models and centralizes routing, failover, access control, cost tracking, caching, and logging.

## Related guides

- [What is the Model Context Protocol (MCP)? How it works](https://theaiengineering.com/articles/what-is-model-context-protocol): The Model Context Protocol (MCP) is an open standard for connecting AI apps to tools and data. Learn its architecture, transports, tool calls, and security.
- [How to build an MCP server: a Python and TypeScript tutorial](https://theaiengineering.com/articles/how-to-build-an-mcp-server): Learn how to build an MCP server with the official Python and TypeScript SDKs: tools, resources, transports, testing, client config, and production security.
- [What are AI agents? How agents work and when to use one](https://theaiengineering.com/articles/what-are-ai-agents): AI agents are LLM systems that call tools in a loop until a task is done. Learn how the loop works, agents vs agentic AI, examples, failure modes, and limits.
- [AI agent frameworks compared: LangGraph, CrewAI, ADK, and more](https://theaiengineering.com/articles/ai-agent-frameworks): An AI agent frameworks comparison of LangGraph, LangChain, CrewAI, the OpenAI, Claude, and Google SDKs, Pydantic AI, Mastra, and more, by language and license.

Part of the [Model Context Protocol](https://theaiengineering.com/topics/mcp) topic hub.

## Cite this guide

The AI Engineering Editors. "A2A protocol vs MCP: differences and when to use each." The AI Engineering, updated Nov 11, 2026. https://theaiengineering.com/articles/a2a-vs-mcp

- Title: A2A protocol vs MCP: differences and when to use each
- Author: The AI Engineering Editors
- Publisher: The AI Engineering
- Published: 2026-09-08
- Updated: 2026-11-11
- URL: https://theaiengineering.com/articles/a2a-vs-mcp
- Markdown: https://theaiengineering.com/articles/a2a-vs-mcp.md

To cite one section, link to its anchor:

- [A2A protocol vs MCP at a glance](https://theaiengineering.com/articles/a2a-vs-mcp#a2a-protocol-vs-mcp-at-a-glance)
- [What is the A2A protocol?](https://theaiengineering.com/articles/a2a-vs-mcp#what-is-the-a2a-protocol)
- [How does the A2A protocol work?](https://theaiengineering.com/articles/a2a-vs-mcp#how-does-the-a2a-protocol-work)
- [What is an A2A agent card?](https://theaiengineering.com/articles/a2a-vs-mcp#what-is-an-a2a-agent-card)
- [A2A vs MCP: the differences that matter](https://theaiengineering.com/articles/a2a-vs-mcp#a2a-vs-mcp-the-differences-that-matter)
- [How do A2A and MCP work together?](https://theaiengineering.com/articles/a2a-vs-mcp#how-do-a2a-and-mcp-work-together)
- [When to use A2A vs MCP](https://theaiengineering.com/articles/a2a-vs-mcp#when-to-use-a2a-vs-mcp)
- [Security and governance compared](https://theaiengineering.com/articles/a2a-vs-mcp#security-and-governance-compared)
- [Where to go next](https://theaiengineering.com/articles/a2a-vs-mcp#where-to-go-next)
- [Frequently asked questions](https://theaiengineering.com/articles/a2a-vs-mcp#faq)
