{"id":286,"date":"2026-08-27T05:00:54","date_gmt":"2026-08-27T05:00:54","guid":{"rendered":"https:\/\/www.akarnik.com\/blog\/what-is-a2a-protocol"},"modified":"2026-08-27T05:00:54","modified_gmt":"2026-08-27T05:00:54","slug":"what-is-a2a-protocol","status":"publish","type":"post","link":"https:\/\/www.akarnik.com\/blog\/what-is-a2a-protocol","title":{"rendered":"What Is the Agent-to-Agent (A2A) Protocol?"},"content":{"rendered":"<p><em>Written by: Arjun Karnik, Growth Marketing Specialist<\/em><\/p>\n<h2 id=\"key-takeaways\">Key Takeaways for A2A<\/h2>\n<ul>\n<li>The A2A protocol is an open standard that enables secure collaboration between AI agents built on different frameworks and by different vendors.<\/li>\n<li>Agents discover each other through Agent Cards published at a well-known URL, which removes the need for custom point-to-point integrations.<\/li>\n<li>A2A complements MCP: MCP connects agents to tools and data, while A2A manages cross-agent task delegation and stateful coordination.<\/li>\n<li>By April 2026, A2A reached production-ready v1.0 status under Linux Foundation governance with 150+ organizations and active deployments across multiple industries.<\/li>\n<li><a href=\"https:\/\/www.akarnik.com\/demo\" target=\"_blank\"><strong>See how these adoption signals translate to citation opportunities in your stack<\/strong><\/a> using Arjun Karnik\u2019s test lab.<\/li>\n<\/ul>\n<h2>How A2A Coordinates Agents in Practice<\/h2>\n<p><a href=\"https:\/\/tyk.io\/learning-center\/a2a-protocol-architecture-and-technical-specification\" target=\"_blank\" rel=\"noindex nofollow\">The A2A protocol distinguishes between A2A clients and A2A servers with fluid roles: any agent can act as the client or the server depending on the interaction direction<\/a>. Clients initiate tasks and act on behalf of a user or upstream system. Servers expose the A2A API and execute tasks for remote agents.<\/p>\n<p><a href=\"https:\/\/a2a-protocol.org\/latest\/topics\/what-is-a2a\/\" target=\"_blank\">A2A uses existing standards like HTTP, JSON-RPC, and Server-Sent Events (SSE) to speed up developer adoption<\/a>. <a href=\"https:\/\/a2a-protocol.org\/latest\/topics\/what-is-a2a\/\" target=\"_blank\">It relies on HTTPS for secure communication and keeps operations opaque so collaborating agents cannot inspect each other\u2019s internal logic<\/a>.<\/p>\n<p><a href=\"https:\/\/tyk.io\/learning-center\/a2a-protocol-architecture-and-technical-specification\" target=\"_blank\" rel=\"noindex nofollow\">The A2A architecture follows a three-layer specification model<\/a>. Layer 1 defines the canonical data model, including AgentCard, AgentSkill, Task, Message, Part, Artifact, and Extension. Layer 2 defines abstract operations such as SendMessage, SendStreamingMessage, GetTask, ListTasks, CancelTask, and SubscribeToTask. Layer 3 specifies the concrete protocol bindings.<\/p>\n<p><a href=\"https:\/\/tyk.io\/learning-center\/a2a-protocol-architecture-and-technical-specification\" target=\"_blank\" rel=\"noindex nofollow\">Tasks move through a defined state machine that includes TASK_STATE_SUBMITTED, TASK_STATE_WORKING, TASK_STATE_INPUT_REQUIRED, TASK_STATE_COMPLETED, TASK_STATE_FAILED, and other states<\/a>. <a href=\"https:\/\/a2a-protocol.org\/latest\/topics\/what-is-a2a\/\" target=\"_blank\">A2A supports long-running tasks with streaming, push notifications, and asynchronous execution for agents or users that are not continuously connected<\/a>.<\/p>\n<p>This state machine is what separates A2A from simple API calls. For technical founders and architects, the task lifecycle forms the operational core that keeps cross-platform delegation traceable and recoverable instead of fire-and-forget.<\/p>\n<p><a href=\"https:\/\/www.akarnik.com\/demo\" target=\"_blank\"><strong>Map your own A2A implementation to citation triggers<\/strong><\/a> by requesting a focused test lab walkthrough.<\/p>\n<h2>Agent Cards as the Discovery Layer<\/h2>\n<p><a href=\"https:\/\/aigrowthagent.co\/articles\/how-agent-cards-work\/\" target=\"_blank\">Agent Cards are JSON discovery files that let AI agents locate, evaluate, and delegate tasks to each other without hard-coded integrations<\/a>. <a href=\"https:\/\/aigrowthagent.co\/articles\/how-agent-cards-work\/\" target=\"_blank\">Every A2A-compliant agent publishes its Agent Card at a well-known URL following RFC 8615 so client agents can discover it via unauthenticated HTTP GET requests<\/a>.<\/p>\n<p>The canonical discovery path is <code>https:\/\/{server_domain}\/.well-known\/agent-card.json<\/code>.<\/p>\n<p><a href=\"https:\/\/www.agentcard.net\/agent-card-schema\" target=\"_blank\" rel=\"noindex nofollow\">The top-level fields of an A2A v1.0 Agent Card are name, description, supportedInterfaces, provider, version, documentationUrl, capabilities, securitySchemes, security, defaultInputModes, defaultOutputModes, skills, signatures, and iconUrl<\/a>. Of these, the A2A specification mandates eight as required: name, description, version, supportedInterfaces, capabilities, defaultInputModes, defaultOutputModes, and skills. The remaining fields are optional but recommended for production deployments.<\/p>\n<p>The following example shows a minimal, verifiable Agent Card JSON that conforms to the A2A v1.0 schema (as documented by the Linux Foundation project, current as of August 2026):<\/p>\n<pre><code>{ \"name\": \"Invoice Processor Agent\", \"description\": \"Extracts line items and totals from PDF invoices and returns structured JSON.\", \"version\": \"1.0.0\", \"provider\": { \"organization\": \"Acme Corp\", \"url\": \"https:\/\/acme.example.com\" }, \"supportedInterfaces\": [ { \"url\": \"https:\/\/agents.acme.example.com\/invoice\", \"protocolBinding\": \"JSONRPC\", \"protocolVersion\": \"1.0\" } ], \"capabilities\": { \"streaming\": true, \"pushNotifications\": false, \"extendedAgentCard\": false }, \"defaultInputModes\": [\"application\/pdf\", \"text\/plain\"], \"defaultOutputModes\": [\"application\/json\"], \"skills\": [ { \"id\": \"extract-invoice\", \"name\": \"Extract Invoice Data\", \"description\": \"Parses a PDF invoice and returns line items, subtotal, tax, and total as JSON.\", \"tags\": [\"invoice\", \"extraction\", \"finance\"], \"examples\": [\"Extract all line items from this invoice PDF.\"] } ] }<\/code><\/pre>\n<p><a href=\"https:\/\/agentica.wiki\/articles\/agent-cards\" target=\"_blank\" rel=\"noindex nofollow\">Agent Cards function as cacheable HTTP resources, so servers should supply standard caching headers (Cache-Control, ETag, Last-Modified) and clients should honor conditional requests<\/a>. <a href=\"https:\/\/agentica.wiki\/articles\/agent-cards\" target=\"_blank\" rel=\"noindex nofollow\">A2A distinguishes a public Agent Card for initial discovery from an extended Agent Card that may be returned only after client authentication and that can contain additional privileged skills or configuration details<\/a>.<\/p>\n<p>Signed Agent Cards, introduced in A2A v1.0, attach a cryptographic signature using JWS to the card payload.<\/p>\n<h2>A2A Compared With MCP<\/h2>\n<p><a href=\"https:\/\/a2a-protocol.org\/latest\/topics\/what-is-a2a\/\" target=\"_blank\">The Model Context Protocol (MCP) connects LLMs with data and external resources, while A2A enables agents to collaborate as autonomous entities in multi-turn interactions such as negotiation<\/a>. The two protocols are designed to work together rather than compete.<\/p>\n<table>\n<thead>\n<tr>\n<th>Dimension<\/th>\n<th>A2A<\/th>\n<th>MCP<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Primary role<\/td>\n<td><a href=\"https:\/\/tyk.io\/learning-center\/a2a-security-the-developers-complete-guide\" target=\"_blank\" rel=\"noindex nofollow\">Horizontal agent-to-agent collaboration<\/a><\/td>\n<td><a href=\"https:\/\/tyk.io\/learning-center\/a2a-security-the-developers-complete-guide\" target=\"_blank\" rel=\"noindex nofollow\">Vertical tool and data access for a single agent<\/a><\/td>\n<\/tr>\n<tr>\n<td>Transport<\/td>\n<td><a href=\"https:\/\/www.jahanzaib.ai\/glossary\/a2a\" target=\"_blank\" rel=\"noindex nofollow\">Three transport bindings (JSON-RPC 2.0, gRPC, HTTP+JSON) all over HTTP<\/a><\/td>\n<td><a href=\"https:\/\/tyk.io\/learning-center\/agent-protocols-a-complete-guide-to-mcp-a2a-and-acp\" target=\"_blank\" rel=\"noindex nofollow\">stdio (local subprocess) or Streamable HTTP<\/a><\/td>\n<\/tr>\n<tr>\n<td>Discovery<\/td>\n<td><a href=\"https:\/\/aigrowthagent.co\/articles\/how-agent-cards-work\/\" target=\"_blank\">Agent Card at \/.well-known\/agent-card.json (RFC 8615)<\/a><\/td>\n<td><a href=\"https:\/\/tyk.io\/learning-center\/agent-protocols-a-complete-guide-to-mcp-a2a-and-acp\" target=\"_blank\" rel=\"noindex nofollow\">Tool list negotiated from MCP server at session start<\/a><\/td>\n<\/tr>\n<tr>\n<td>State model<\/td>\n<td><a href=\"https:\/\/tyk.io\/learning-center\/agent-protocols-a-complete-guide-to-mcp-a2a-and-acp\" target=\"_blank\" rel=\"noindex nofollow\">Task-stateful with server-stored Task history and artifacts<\/a><\/td>\n<td><a href=\"https:\/\/tyk.io\/learning-center\/agent-protocols-a-complete-guide-to-mcp-a2a-and-acp\" target=\"_blank\" rel=\"noindex nofollow\">Session-stateful with initialize\/initialized handshake and MCP-Session-Id<\/a><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><a href=\"https:\/\/zenity.io\/academy\/agent-to-agent-protocol\" target=\"_blank\" rel=\"noindex nofollow\">MCP acts as an agent\u2019s hands for tool invocation and data access, while A2A acts as an agent\u2019s phone line for cross-agent collaboration and task delegation<\/a>. <a href=\"https:\/\/alicelabs.ai\/en\/insights\/a2a-protocol-guide-2026\" target=\"_blank\" rel=\"noindex nofollow\">Alice Labs\u2019 rule of thumb from 100+ implementations: use A2A when agents cross service, team, cloud, or organizational boundaries, and use in-process agents-as-tools when all agents live in the same process and team<\/a>.<\/p>\n<h2>Real Multi-Agent Workflow Example<\/h2>\n<p><a href=\"https:\/\/developers.googleblog.com\/developers-guide-to-ai-agent-protocols\" target=\"_blank\" rel=\"noindex nofollow\">In Google\u2019s restaurant supply chain example, the kitchen manager agent uses A2A to query remote pricing and quality agents for wholesale prices, supplier quality grades, and delivery windows after first checking inventory via MCP<\/a>.<\/p>\n<p>The sequence shows how A2A and MCP complement each other:<\/p>\n<ol>\n<li>The kitchen manager agent calls its local inventory database via MCP to determine what stock is low.<\/li>\n<li>It then reads the Agent Cards of a pricing agent and a quality agent at their respective <code>\/.well-known\/agent-card.json<\/code> endpoints.<\/li>\n<li>It delegates two parallel tasks via A2A: one for current wholesale pricing, one for supplier quality grades and delivery windows.<\/li>\n<li>Each specialist agent returns an Artifact that contains structured JSON results.<\/li>\n<li>The kitchen manager assembles the artifacts into a purchase recommendation.<\/li>\n<\/ol>\n<p><a href=\"https:\/\/developers.googleblog.com\/build-cross-language-multi-agent-team-with-google-agent-development-kit-and-a2a\" target=\"_blank\" rel=\"noindex nofollow\">A2A lets teams build agents in the best language for each job, such as Python for cognitive extraction and Go for high-performance deterministic validation, without rewriting code<\/a>. This approach fits heterogeneous production systems where different teams maintain separate language stacks.<\/p>\n<p><a href=\"https:\/\/www.akarnik.com\/demo\" target=\"_blank\"><strong>Apply this workflow pattern to your own technical documentation<\/strong><\/a> by scheduling a test lab consultation.<\/p>\n<h2>Production Status After Linux Foundation Move<\/h2>\n<p><a href=\"https:\/\/linuxfoundation.org\/press\/a2a-protocol-surpasses-150-organizations-lands-in-major-cloud-platforms-and-sees-enterprise-production-use-in-first-year\" target=\"_blank\" rel=\"noindex nofollow\">The A2A Protocol reached production-ready status as an open standard for agent-to-agent communication by April 9, 2026, one year after its initial release<\/a>. By that milestone, more than 150 organizations supported the protocol, including AWS, Google, IBM, and Microsoft. <a href=\"https:\/\/www.arunbaby.com\/ai-agents\/0096-a2a-protocol-standard-150-orgs\/\" target=\"_blank\" rel=\"noindex nofollow\">A2A also had deep integrations with Google Cloud, Microsoft Azure AI Foundry, and AWS Amazon Bedrock AgentCore<\/a>. These integrations enabled active production deployments across supply chain, financial services, insurance, and IT operations industries.<\/p>\n<p><a href=\"https:\/\/forbes.com\/sites\/janakirammsv\/2026\/08\/19\/agent2agent-joins-the-agentic-ai-foundation-alongside-mcp\" target=\"_blank\" rel=\"noindex nofollow\">On August 17, 2026, the Agent2Agent (A2A) protocol officially joined the Agentic AI Foundation (AAIF), a Linux Foundation body that already hosts the Model Context Protocol (MCP), Block\u2019s goose runtime, OpenAI\u2019s AGENTS.md convention, and the agentgateway proxy<\/a>.<\/p>\n<p><a href=\"https:\/\/linuxfoundation.org\/press\/a2a-protocol-surpasses-150-organizations-lands-in-major-cloud-platforms-and-sees-enterprise-production-use-in-first-year\" target=\"_blank\" rel=\"noindex nofollow\">The A2A Protocol\u2019s core GitHub repository surpassed 22,000 stars by April 2026, and its SDK ecosystem expanded to five production-ready languages: Python, JavaScript, Java, Go, and .NET<\/a>.<\/p>\n<p>Arjun Karnik\u2019s test lab tracks A2A protocol documentation as a live citation surface. In his observations, pages structured around A2A\u2019s canonical terminology such as Agent Card, Task lifecycle, and opaque operations earn citations in AI Overviews. Pages that rely on generic \u201cmulti-agent\u201d language do not. This pattern matches his broader finding that fan-out queries triggered by a single buyer prompt retrieve against specific technical vocabulary rather than category-level prose.<\/p>\n<h2>Operational Considerations for A2A Deployments<\/h2>\n<p><a href=\"https:\/\/aigrowthagent.co\/articles\/how-agent-cards-work\/\" target=\"_blank\">OAuth 2.0 with client credentials flow is the most common choice for enterprise deployments because it integrates with existing identity infrastructure, supports narrow scoping at the skill level, and is natively supported by the A2A v1.0 security model<\/a>.<\/p>\n<p><a href=\"https:\/\/tyk.io\/learning-center\/a2a-protocol-architecture-and-technical-specification\" target=\"_blank\" rel=\"noindex nofollow\">Enterprise A2A deployments typically combine mTLS with OAuth 2.0, including RFC 8705 mTLS-bound tokens or RFC 9449 DPoP, plus OpenTelemetry trace context propagation for zero-trust security and observability across agent chains<\/a>.<\/p>\n<p><a href=\"https:\/\/tyk.io\/learning-center\/a2a-protocol-architecture-and-technical-specification\" target=\"_blank\" rel=\"noindex nofollow\">Production A2A implementations must handle three gaps at the application layer<\/a>. There is no per-skill JSON Schema in AgentSkill definitions, token downscoping for delegation chains depends on OAuth 2.0 Token Exchange (RFC 8693), and no standardized registry API exists beyond well-known URIs.<\/p>\n<p>On caching, <a href=\"https:\/\/agentica.wiki\/articles\/agent-cards\" target=\"_blank\" rel=\"noindex nofollow\">servers should supply standard caching headers (Cache-Control, ETag, Last-Modified) and clients should honor conditional requests<\/a>. Agent Cards that change <code>skills[]<\/code>, <code>supportedInterfaces[].url<\/code>, or capabilities require a version bump so client agents do not rely on stale discovery data.<\/p>\n<p>Schema requirements are strict for machine retrieval. Every Agent Card field must conform to the JSON Schema 2020-12 specification auto-generated from the A2A Protocol Buffers. <a href=\"https:\/\/aigrowthagent.co\/articles\/how-agent-cards-work\/\" target=\"_blank\">The core nouns in the A2A protocol, including AgentCard, AgentSkill, Task, Message, Part, Artifact, and Extension, are defined in Protocol Buffers and published as JSON Schema 2020-12, auto-generated from the protos<\/a>. Vague skill descriptions cause discovery failures in production registries.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>What problem does the A2A protocol solve that existing APIs do not?<\/h3>\n<p>Existing REST or GraphQL APIs require the calling system to know the target system\u2019s schema in advance. A2A removes that requirement. An A2A client reads an Agent Card at a well-known URI, learns what the remote agent can do, how to authenticate, and which transport to use at runtime. Adding a new agent to a multi-agent system then requires only adding its URL, not writing new integration code. The protocol also manages long-running tasks with state tracking, streaming, and push notifications, which standard request-response APIs do not handle natively.<\/p>\n<h3>Is A2A ready for production use in 2026?<\/h3>\n<p>A2A v1.0 is production-ready in 2026, with practical caveats. It reached this status in March 2026 under Linux Foundation governance. Native support exists in Google Vertex AI Agent Builder, Microsoft Azure AI Foundry, Microsoft Copilot Studio, and Amazon Bedrock AgentCore Runtime. Active production deployments are documented in supply chain, financial services, insurance, and IT operations. The caveats involve gaps: per-skill JSON Schema validation is not yet standardized, token downscoping for delegation chains relies on OAuth 2.0 Token Exchange (RFC 8693), and no standardized registry API exists beyond well-known URIs. Teams building on A2A v1.0 should budget for these application-layer tasks.<\/p>\n<h3>Can A2A and MCP be used in the same agent system?<\/h3>\n<p>The two protocols are designed to work together in the same system. MCP manages an individual agent\u2019s access to tools, databases, APIs, and file systems. A2A manages delegation of complete tasks between autonomous agents across organizational or platform boundaries. A common production pattern uses an orchestrator agent that relies on A2A to delegate work to specialist agents, each of which uses MCP internally to invoke its own tools. The protocols operate at different layers of the stack and do not conflict.<\/p>\n<h3>What makes an Agent Card high-quality for production discovery?<\/h3>\n<p>A high-quality Agent Card is specific, accurate, versioned, and honest about limitations. Required fields, including name, description, version, supportedInterfaces, capabilities, defaultInputModes, defaultOutputModes, and skills, must be present and correctly typed. Skill descriptions need enough precision for a client agent to judge relevance without calling the endpoint. Vague descriptions such as \u201chandles business tasks\u201d cause discovery failures in automated registries. Signed Agent Cards that use JWS over a JCS-canonicalized payload are required in any deployment where tamper-evidence matters. As noted in the operational considerations, proper caching prevents clients from re-fetching unchanged cards on every request.<\/p>\n<h3>How does A2A authentication work across organizational boundaries?<\/h3>\n<p>A2A v1.0 supports OAuth 2.0, mutual TLS (mTLS), JWT bearer tokens, and API keys, all declared in the Agent Card\u2019s <code>securitySchemes<\/code> field following OpenAPI 3.0 conventions. For cross-organizational deployments, the recommended pattern combines mTLS with OAuth 2.0 mTLS-bound tokens (RFC 8705) or Demonstrating Proof of Possession (DPoP, RFC 9449), plus OpenTelemetry trace context propagation for observability across agent chains. The Agent Card\u2019s <code>security<\/code> field declares which schemes are required so client agents can determine authentication requirements before starting a task.<\/p>\n<h2>Conclusion: Using A2A as a Citable Standard<\/h2>\n<p>The Agent-to-Agent (A2A) protocol is an open standard, now governed by the Agentic AI Foundation under the Linux Foundation, that lets autonomous AI agents discover each other via Agent Cards, authenticate securely, delegate stateful tasks, and exchange results across any platform or vendor boundary. It reached v1.0 in March 2026 with more than 150 supporting organizations and active production deployments in supply chain, financial services, insurance, and IT operations. It complements MCP rather than replacing it: MCP manages tool access, and A2A manages agent-to-agent coordination.<\/p>\n<p>This article supplies a citable 50-word definition, a minimal dated Agent Card JSON example, an explicit A2A vs MCP comparison table, and post-2025 Linux Foundation production signals. These elements match the citation triggers that Arjun Karnik\u2019s test lab tracks in AI Overviews. Structured, specific, technically accurate content on A2A earns citations, while generic multi-agent prose does not.<\/p>\n<p><a href=\"https:\/\/www.akarnik.com\/demo\" target=\"_blank\"><strong>Document what earns citations for your A2A content<\/strong><\/a> and explore the test lab methodology in a live session.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Learn how the A2A protocol enables multi-agent coordination in 2026. Arjun Karnik breaks down Agent Cards, MCP comparisons &amp; production readiness.<\/p>\n","protected":false},"author":118,"featured_media":285,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-286","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/www.akarnik.com\/blog\/wp-json\/wp\/v2\/posts\/286","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.akarnik.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.akarnik.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/www.akarnik.com\/blog\/wp-json\/wp\/v2\/comments?post=286"}],"version-history":[{"count":0,"href":"https:\/\/www.akarnik.com\/blog\/wp-json\/wp\/v2\/posts\/286\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.akarnik.com\/blog\/wp-json\/wp\/v2\/media\/285"}],"wp:attachment":[{"href":"https:\/\/www.akarnik.com\/blog\/wp-json\/wp\/v2\/media?parent=286"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.akarnik.com\/blog\/wp-json\/wp\/v2\/categories?post=286"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.akarnik.com\/blog\/wp-json\/wp\/v2\/tags?post=286"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}