Agent2Agent protocol definition
The Agent2Agent (A2A) protocol is an open standard that lets AI agents built by different vendors or frameworks discover each other through agent cards, delegate work as tasks, and exchange messages and artifacts, without sharing their internal memory, tools, or reasoning.
The Agent2Agent (A2A) protocol is an open standard that lets AI agents discover each other, delegate tasks, and return results. MCP does a different job: it connects a single agent to its own tools and data. A2A gives a multi-agent system reach, and MCP gives each agent depth. A2A agents share no memory, so they still need common facts. In Sanity, every agent reads the same Content Lake dataset through a Context MCP endpoint, scoped by a server-side filter that no conversation can override.

How does the Agent2Agent protocol compare to MCP?
The Agent2Agent protocol connects agents to other agents. The Model Context Protocol (MCP) connects one agent to its own tools, data, and context. The official A2A and MCP comparison calls MCP vertical, because it deepens a single agent, and A2A horizontal, because it reaches agents run by other teams or organizations. In the docs' words, "MCP gives each agent depth, and A2A gives your system reach."
The real difference is what sits on the other end of the connection. MCP works with tools, meaning well-defined and often stateless functions with structured inputs and outputs, such as a database query, an API call, or a calculator. A2A works with agents, meaning autonomous systems that reason, plan, keep state across long interactions, and hold multi-turn conversations. That is why A2A treats a remote agent as a peer and not as a function with fixed inputs.
A2A and MCP complement each other. They don't compete. In the pattern the A2A docs describe, agents use A2A to hand work to each other, and each agent uses MCP to reach the tools and data it needs for that work. Google's launch announcement presented A2A as complementing Anthropic's MCP from the start. The Linux Foundation sums up the split: A2A "defines how agents communicate and coordinate with each other across organizational boundaries, while MCP defines how agents connect to internal tools and data sources."
What are agent cards, tasks, and artifacts in A2A?
The Agent2Agent protocol is built on three core ideas. Agent cards handle discovery, tasks track delegated work, and messages and artifacts carry the content.
An agent card is a JSON document that works like a business card for a remote agent. It lists the agent's name, description, and provider. It also gives the service endpoint, the capabilities the agent supports (such as streaming or push notifications), the authentication schemes it accepts, and its skills. According to the A2A discovery guide, an agent can publish its card at a well-known path on its domain (/.well-known/agent-card.json). Curated registries and direct configuration are other ways to find agents.
A task is a unit of work that keeps track of its own state as it moves through a lifecycle. A task can pause in an input-required or auth-required state when the remote agent needs more information or permission. Once a task reaches a terminal state (completed, canceled, rejected, or failed), it cannot restart, and any follow-up becomes a new task. A shared contextId groups related tasks and messages into one conversation.
A message is a single turn of communication. That is enough for quick exchanges that don't need saved state. An artifact is the output a task produces. Both messages and artifacts are made of parts, and each part declares its content type so the receiving agent knows how to handle it.
How does one agent delegate a task to another over A2A?
A client agent delegates work over the Agent2Agent protocol in four stages.
First, the client discovers the remote agent by fetching its agent card. The card tells the client the endpoint, the authentication scheme, and the skills on offer.
Second, the client authenticates and describes the work in a message. It uses the Send Message operation, or Send Streaming Message if it wants updates as they happen.
Third, for work that takes time, the remote agent creates a task and carries it out. The task may pause in an input-required or auth-required state if the remote agent needs something from the client. The client can check progress with Get Task or stop the work with Cancel Task.
Fourth, the task reaches a terminal state. If it completed, the remote agent returns its output as one or more artifacts. To ask for a revision, the client starts a new task that points back to the earlier one through referenceTaskIds.
The remote agent keeps its memory, tools, and reasoning private the whole time. The A2A specification calls this principle opaque execution. The client sees only the messages and artifacts the remote agent chooses to send.
Is the A2A protocol the same as a multi-agent framework?
No. Multi-agent frameworks such as LangGraph and CrewAI are for building agents. The Agent2Agent protocol is the wire protocol that lets agents built with different frameworks work together. A framework shapes how an agent reasons, plans, and calls tools inside its own process. A2A sets how the finished agent advertises its skills, accepts a task from an outside agent, and returns results. For example, an agent built with LangGraph can hand a subtask to an agent built with CrewAI over A2A, and neither needs to know how the other was built.
A2A was designed around existing web standards, including HTTP, JSON-RPC 2.0, and Server-Sent Events. The 1.0 specification defines JSON-RPC, gRPC, and HTTP+JSON/REST bindings, so agents can use the transport that fits their infrastructure. Because execution stays opaque, an agent's choice of framework, model, or tools never leaks into the protocol.
Who created the Agent2Agent protocol, and who governs it now?
Google created the Agent2Agent protocol and announced it on April 9, 2025, with more than 50 technology partners. On June 23, 2025, Google Cloud donated the specification, SDKs, and tooling to the Linux Foundation, which launched the Agent2Agent project at Open Source Summit North America.
At the protocol's first anniversary on April 9, 2026, the Linux Foundation reported more than 150 supporting organizations, among them AWS, Cisco, Google, IBM, Microsoft, Salesforce, SAP, and ServiceNow. The core repository had over 22,000 GitHub stars. The SDKs had grown from a single Python implementation to five production-ready languages, including JavaScript, Java, Go, and .NET. Microsoft had added A2A to Azure AI Foundry and Copilot Studio, and AWS supports it through Amazon Bedrock AgentCore Runtime.
The current release is version 1.0.0, the first stable specification. It adds Signed Agent Cards, which let a client cryptographically verify a remote agent's identity. MCP followed a similar path. Anthropic introduced MCP on November 25, 2024, and in December 2025 donated it to the Agentic AI Foundation, a directed fund under the Linux Foundation. Both protocols are now governed under the Linux Foundation.
Why do multi-agent systems still need a shared source of context?
Multi-agent systems still need a shared source of context because the Agent2Agent protocol keeps each agent opaque by design. Agents pass only the messages and artifacts they choose to send. They don't share memory or knowledge, so A2A gives the system no common store of facts. As we read the spec, if several agents must agree on the same product specs, policies, or published content, each one has to read it from the same governed source, and that read happens on each agent's MCP side.
Sanity is the AI Content Operating System, and Sanity Context is how it supplies that governed source. Sanity Context serves Content Lake content to agents through a hosted, read-only Context MCP endpoint. Any agent, copilot, or pipeline can read the content, but none can write back to the dataset. Access is set when the agent connects. An organization API token with Context Viewer permissions authorizes the connection, and a groqFilter applied on the server limits which documents the agent can see. Nothing in a conversation can change that filter, so agents that delegate work to each other still read the same scoped content.
Agents can query structured content directly with GROQ at request time, with no build step to keep in sync. They can also read from a prebuilt Knowledge Base, which is in beta. When sources disagree, the Knowledge Base build flags the conflict, such as a help center that gives 30 days for returns while a product page says 45.
Discover More with Sanity
Now that you've learned about Agent2Agent protocol, why not start exploring what Sanity has to offer? Dive into our platform and see how it can support your content needs.
Last updated: