# Agent2Agent Protocol > Source: https://aiwiki.ai/wiki/a2a_protocol > Updated: 2026-10-30 > Fact-checked: 2026-10-30 > Categories: AI Agents, Google, Open Source AI > License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/) - attribute to "AI Wiki (aiwiki.ai)" > Cite as: AI Wiki. "Agent2Agent Protocol." aiwiki.ai, 30 Oct 2026. https://aiwiki.ai/wiki/a2a_protocol > From AI Wiki (https://aiwiki.ai), the free encyclopedia of artificial intelligence. Reuse freely with attribution. The **Agent2Agent (A2A) Protocol** is an open standard for communication and interoperability between independent AI agents. Google announced it on April 9, 2025, at [Google Cloud](https://aiwiki.ai/wiki/google_cloud) Next with support from more than 50 technology partners.[1] On June 23, 2025, Google donated the specification, SDKs, and developer tooling to the [Linux Foundation](https://aiwiki.ai/wiki/linux_foundation), which launched the Agent2Agent project as a vendor-neutral home for the protocol.[2][3] Version 1.0, the first stable specification, was released on March 12, 2026.[8] At the protocol's first anniversary on April 9, 2026, the Linux Foundation reported more than 150 supporting organizations and production use in supply chain, financial services, insurance, and IT operations.[10] On August 17, 2026, A2A joined the Linux Foundation's [Agentic AI Foundation](https://aiwiki.ai/wiki/agentic_ai_foundation) (AAIF) as a hosted project, alongside [Anthropic](https://aiwiki.ai/wiki/anthropic)'s [Model Context Protocol](https://aiwiki.ai/wiki/model_context_protocol) (MCP), which had been a founding AAIF project since December 2025.[26][27]
Agent2Agent (A2A) Protocol logo
Agent2Agent (A2A) Protocol logo, from the official website a2a-protocol.org. Trademark of its owner.
The protocol sits at the agent coordination layer of the AI stack, enabling [AI agents](https://aiwiki.ai/wiki/ai_agents) built on different frameworks and by different vendors to discover each other, delegate tasks, and exchange results without exposing internal logic, memory, or tooling.[4] It is explicitly complementary to the Model Context Protocol, which handles the connection between an agent and its tools; A2A handles the connection between agents themselves.[6] ## What problem does A2A solve? The rise of autonomous [agentic AI](https://aiwiki.ai/wiki/agentic_ai) exposed a structural problem in enterprise software. Organizations began deploying multiple specialized agents: one handling customer service, another managing inventory, a third analyzing financial risk, and so on. Each agent might be built on a different framework ([LangGraph](https://aiwiki.ai/wiki/langgraph), [CrewAI](https://aiwiki.ai/wiki/crewai), [Semantic Kernel](https://aiwiki.ai/wiki/semantic_kernel), [AutoGen](https://aiwiki.ai/wiki/autogen)), hosted by a different vendor, and designed to operate independently. When business processes required these agents to hand off tasks, share context, or coordinate on multi-step workflows, there was no standard way to do it.[1] The resulting approach was ad hoc. Engineering teams wrote custom integration code to bridge agents from different vendors. These bridges were brittle, expensive to maintain, and did not scale. Each new agent added to a system potentially required new integration work with every other existing agent. The communication patterns were also opaque: there was no common vocabulary for one agent to tell another what it was capable of, what format it expected inputs in, or how to authenticate requests. The AAIF later summed up the problem this way: "The cost wasn't in the agents themselves but in the integrations between them."[26] This problem grew more acute as agentic AI moved from research into production. In August 2025, Gartner predicted that 40% of enterprise applications would feature task-specific AI agents by the end of 2026, up from less than 5% in 2025.[36] Without a common protocol, enterprises faced a fragmented landscape where agents from different vendors could not easily talk to each other, limiting the practical value of [multi-agent system](https://aiwiki.ai/wiki/multi_agent_system)s and reinforcing vendor lock-in. A2A's designers built it on existing web standards (HTTP, server-sent events, and JSON-RPC) so that it would fit into the IT stacks businesses already used.[1] The goal was a shared vocabulary and set of transport conventions so that any compliant agent could communicate with any other compliant agent, regardless of the underlying framework or vendor.[1]
"Introduction to Agent2Agent (A2A) Protocol", official video from Google Cloud Tech, published February 6, 2026. Watch on YouTube.
## History ### Google Cloud Next announcement Google introduced the Agent2Agent Protocol on April 9, 2025, during the Google Cloud Next conference.[1] The announcement came alongside Google's own expanding ecosystem of agent tooling, including the [Agent Development Kit](https://aiwiki.ai/wiki/google_adk) (ADK). From the outset, Google framed A2A as an open protocol built with partners and the community, and it set up pathways for outside contributions.[1] The initial launch included support and contributions from more than 50 technology partners. Technology companies in the first cohort included Atlassian, Box, [Cohere](https://aiwiki.ai/wiki/cohere), Intuit, [LangChain](https://aiwiki.ai/wiki/langchain), MongoDB, PayPal, [Salesforce](https://aiwiki.ai/wiki/salesforce), SAP, [ServiceNow](https://aiwiki.ai/wiki/servicenow), UKG, and Workday. Service providers also joined as launch partners, including Accenture, BCG, Capgemini, Cognizant, Deloitte, HCLTech, Infosys, KPMG, McKinsey, PwC, TCS, and Wipro.[1] Tapasvi Moturu, Intuit's vice president of software engineering for agentic frameworks, said an open-source protocol such as A2A "will enable complex agent workflows, accelerate our partner integrations, and move the industry forward with cross-platform agents that collaborate effectively."[1] Google released the protocol as open source on [GitHub](https://aiwiki.ai/wiki/github) as a draft specification with code samples, and said it was working with partners on a production-ready version later in 2025.[1] The repository is licensed under Apache 2.0.[17] The official SDKs came afterward: the Python, Java, Go, JavaScript, and .NET SDK repositories were created in May 2025, and the Linux Foundation later described the SDK ecosystem as having grown "from a single Python implementation" to five production-ready languages.[10][29] The draft specification described the protocol's core data model (tasks, messages, artifacts, agent cards), its use of HTTP with JSON-RPC 2.0 and server-sent events, and its authentication approach.[1][4] ### Linux Foundation donation On June 23, 2025, at Open Source Summit North America in Denver, the Linux Foundation announced the launch of the Agent2Agent project, seeded with Google's transfer of the A2A specification, accompanying SDKs, and developer tooling.[2][3][22] Google's announcement named seven organizations forming the project: [Amazon Web Services](https://aiwiki.ai/wiki/amazon_web_services), Cisco, [Google](https://aiwiki.ai/wiki/google), [Microsoft](https://aiwiki.ai/wiki/microsoft), Salesforce, SAP, and ServiceNow.[3] More than 100 companies supported the protocol by that point, with AWS and Cisco named as its newest validators.[2][3] The donation was framed as a way to keep the protocol vendor-neutral. Mike Smith, a Google staff software engineer who had driven the project internally, told the Open Source Summit audience that the protocol "needed to be independent and vendor-agnostic."[21] Jim Zemlin, executive director of the Linux Foundation, said: "By joining the Linux Foundation, A2A is ensuring the long-term neutrality, collaboration and governance that will unlock the next era of agent-to-agent powered productivity."[2] Google's announcement listed four key objectives for the project: establish an open standard for agent interoperability, foster a diverse global ecosystem of developers and companies, ensure neutral governance under the Linux Foundation, and accelerate secure innovation.[3] ### Version 0.3 On July 30, 2025, the project released version 0.3.0 of the specification.[29] It added a `signatures` field to the Agent Card for JSON Web Signature (JWS) signing, mutual TLS as a security scheme, and a method for fetching an authenticated extended Agent Card. It also moved the well-known Agent Card path from `agent.json` to `agent-card.json`.[29] Google Cloud described v0.3 as "a more stable interface to build against," highlighting gRPC support and the ability to sign Agent Cards, although gRPC and REST definitions had first been added to the specification in v0.2.2 in June 2025.[9][39] In the same announcement, Google said partners could sell A2A agents in its AI Agent Marketplace.[9] ### ACP merger In August 2025, IBM's Agent Communication Protocol (ACP) merged into A2A.[23] IBM Research had launched ACP in March 2025 to power its open-source BeeAI platform, and the BeeAI project, including ACP, was donated to the Linux Foundation later that month.[23] The merger was announced in an LF AI & Data community blog post on August 29, 2025, written by Kate Blair of IBM Research and Todd Segal of Google. The ACP team said it would wind down active development, contribute its technology and expertise directly to A2A, and provide migration paths for ACP users.[23] Blair, IBM Research's director of incubation, who had overseen ACP's development, joined the A2A Technical Steering Committee on IBM's behalf, alongside representatives from Google, Microsoft, AWS, Cisco, Salesforce, ServiceNow, and SAP.[23] The BeeAI platform switched from ACP to A2A.[23] ### Version 1.0 and one-year milestone The project released A2A Protocol version 1.0 (tag v1.0.0) on March 12, 2026, as its first stable, production-ready version.[8][29] At release, the Technical Steering Committee included representatives from eight companies: AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP, and ServiceNow.[8] Version 1.0 made the protocol buffer definition (`a2a.proto`) the normative source of truth. It also formally specified all three protocol bindings (JSON-RPC 2.0, gRPC, and HTTP+JSON/REST) with equivalence guarantees, and it required Agent Cards to be canonicalized with the JSON Canonicalization Scheme (RFC 8785) before JWS signing.[8] The release added native multi-tenancy through a `tenant` field on requests, formalized per-interface protocol versioning, tightened timestamps to ISO 8601 with millisecond precision, and modernized OAuth 2.0 support. That meant adding the Device Code flow (RFC 8628), adding a PKCE requirement flag (`pkceRequired`) to the Authorization Code flow, and deprecating the implicit and password flows. The release notes describe those two flows as removed, but the normative `a2a.proto` still defines them, marked deprecated.[8][29] The release announcement framed v1.0 as emphasizing "maturity rather than reinvention." The core concepts stayed intact, but the interaction protocol had breaking changes, including renamed operations, a unified Part structure, and new enum values. The announcement described the Agent Card as having evolved in a backward-compatible way, although the migration guide lists field changes such as the new `supportedInterfaces` list. An Agent Card can advertise support for both v0.3 and v1.0 so that clients can migrate gradually.[8] A maintenance release, v1.0.1, followed on May 28, 2026.[29] At the project's first anniversary on April 9, 2026, the Linux Foundation reported that more than 150 organizations supported the standard, up from more than 50 at launch.[10] It said Microsoft had integrated A2A into Azure AI Foundry and Copilot Studio, and that AWS had added support through Amazon Bedrock AgentCore Runtime.[10] AWS had described AgentCore support as planned work in August 2025.[16] The core GitHub repository had passed 22,000 stars, and the SDK ecosystem had grown to five production-ready languages: Python, [JavaScript](https://aiwiki.ai/wiki/javascript), Java, Go, and .NET.[10] (By late October 2026 the repository had more than 26,000 stars, and the project listed official SDKs in six languages, including Rust.[17][7]) Rao Surapaneni of Google Cloud said: "AI agents are only as useful as their ability to collaborate, and the adoption of A2A by more than 150 organizations underscores the widespread enthusiasm for an open, interoperable protocol."[10] Google also grouped A2A with related protocols it called the "A2Family": the [Agent Payments Protocol (AP2)](https://aiwiki.ai/wiki/agent_payments_protocol), A2UI (Agent to User Interface), and the Universal Commerce Protocol (UCP). It described them as "examples of new protocols created using A2A's open extensibility model for agent communication."[12][32] ### Joining the Agentic AI Foundation The Linux Foundation announced the Agentic AI Foundation on December 9, 2025. Anthropic described it as "a directed fund under the Linux Foundation, co-founded by Anthropic, Block and OpenAI, with support from Google, Microsoft, Amazon Web Services (AWS), Cloudflare, and Bloomberg."[27] The AAIF launched with three founding project contributions: Anthropic's Model Context Protocol, Block's goose agent framework, and [OpenAI](https://aiwiki.ai/wiki/openai)'s AGENTS.md. Its platinum members were AWS, Anthropic, Block, Bloomberg, [Cloudflare](https://aiwiki.ai/wiki/cloudflare), Google, Microsoft, and OpenAI.[11] A2A was not part of that launch. It remained a separate Linux Foundation project.[11][10] On August 17, 2026, the AAIF announced that A2A was "joining the Agentic AI Foundation (AAIF) as a hosted project."[26] The A2A project's own announcement said it had been "accepted as a Growth Stage project" at the AAIF.[28] The AAIF placed A2A in its "open agentic stack" as the agent-to-agent interoperability layer, alongside AGENTS.md (instructions and context), goose (agent runtime), MCP (agent-to-tool connectivity), and agentgateway (traffic mediation and control).[26] AAIF chief technology officer Manik Surtani said the move created "a neutral home where the community can collaborate on the standards that will enable agents from different vendors, frameworks, and organizations to work together."[26] The AAIF post also named new deployments. [Huawei](https://aiwiki.ai/wiki/huawei) has standardized on A2A as the protocol between Celia, its OS-level assistant, and in-app agents on the HarmonyOS developer platform. Tencent's WeChat was integrating with Huawei and other Android OEM assistants over A2A.[26] ## Technical architecture A2A is built on existing web standards rather than inventing new transport mechanisms. The original design used HTTP as its transport layer, JSON-RPC 2.0 as the request-response format, and server-sent events (SSE) for streaming.[1][4] The v1.0 announcement describes the design as aligned with "core architectural principles of the web," so that organizations can scale agent traffic with the load balancing, gateway, security, and observability patterns they already use. In its simplest form, an A2A interaction can begin with a single HTTP request.[8] ### Transport bindings The specification defines three protocol bindings that all map to the same semantic operations and data structures:[4] | Binding | Transport | Serialization | Use case | |---------|-----------|---------------|----------| | JSON-RPC 2.0 | HTTP POST | JSON | The original binding; widely compatible | | gRPC | HTTP/2 | Protocol Buffers | Typed services; defined from v0.2.2, promoted with v0.3 | | HTTP+JSON/REST | HTTP verbs | JSON | RESTful integrations | All client requests in the JSON-RPC binding are encapsulated in a standard JSON-RPC 2.0 Request object. In version 1.0 the method field carries the operation name, for example `SendMessage` or `GetTask` (in v0.3 these were `message/send` and `tasks/get`). Responses follow JSON-RPC 2.0 conventions for both success and error cases.[4][8] Clients indicate the protocol version they expect using the `A2A-Version` header. Servers must process requests per the indicated version semantics or return a `VersionNotSupportedError`, and an empty value is interpreted as version 0.3.[4] In version 1.0, an agent declares its bindings in the Agent Card's `supportedInterfaces` list, where each entry gives a URL, a protocol binding, and a protocol version. This replaced the v0.3 fields `preferredTransport` and `additionalInterfaces`. Because each interface carries its own version, an agent can expose old and new protocol versions side by side during a migration.[8] ### Streaming via server-sent events Many agentic tasks take longer than a simple HTTP request-response cycle can accommodate. A2A supports real-time incremental result delivery through server-sent events over a persistent HTTP connection. The `SendStreamingMessage` operation opens such a connection. The server then emits `TaskStatusUpdateEvent` objects as the task state changes and `TaskArtifactUpdateEvent` objects as partial outputs become available.[4] For tasks that exceed connection timeframes or where clients are disconnected, A2A also supports push notifications: the agent POSTs status updates to a webhook URL previously registered by the client. This three-tier update model (polling via `GetTask`, streaming via SSE, and asynchronous push via webhooks) gives implementers flexibility to match the delivery mechanism to the latency and reliability requirements of each use case.[4][8] ### Core operations The A2A version 1.0 specification defines the following operations:[4] | Operation | Purpose | |-----------|--------| | `SendMessage` | Initiate a task or continue a multi-turn interaction; returns a Task or direct Message | | `SendStreamingMessage` | Same as SendMessage but opens a stream for incremental updates | | `GetTask` | Retrieve current task state, optionally including history | | `ListTasks` | Query tasks with filtering and cursor-based pagination (new in v1.0) | | `CancelTask` | Request cancellation of an in-progress task | | `SubscribeToTask` | Open a stream for updates on an existing task | | `CreateTaskPushNotificationConfig` | Register a webhook configuration for async updates | | `GetTaskPushNotificationConfig` / `ListTaskPushNotificationConfigs` / `DeleteTaskPushNotificationConfig` | Retrieve, list, or remove webhook configurations | | `GetExtendedAgentCard` | Retrieve an authenticated, more detailed version of the Agent Card | ### Multi-tenancy Version 1.0 added native support for serving multiple agents or tenants from a single endpoint.[8] Every request message carries an optional `tenant` field, an opaque string whose meaning the server operator defines. The value a client should use is advertised in the `AgentInterface` entry of the Agent Card, and the client must echo it back on every request.[31] The protocol does not prescribe a routing implementation. The documentation describes three approaches that can be combined: giving each agent its own URL path, routing on the credentials already present in the request (for example, a bearer token whose audience identifies the agent), and routing on the `tenant` field.[31] ## What is an Agent Card? The Agent Card is central to how A2A enables decentralized discovery. It is a JSON document that an A2A server publishes, typically at the well-known path `/.well-known/agent-card.json` (the path was `agent.json` before v0.3). Any client agent can fetch this document to learn what a remote agent can do before initiating any task.[4][5] Clients can also find Agent Cards through curated registries or catalogs, or through direct configuration.[4] In version 1.0, the Agent Card contains the following information:[5][8] - **Identity fields**: name, description, version, and optional icon URL - **Supported interfaces**: one or more endpoints, each with a URL, a protocol binding (JSON-RPC, gRPC, or HTTP+JSON), a protocol version, and an optional tenant value - **Capabilities**: declared support for optional protocol features such as streaming, push notifications, and an extended Agent Card - **Default input and output modes**: the media types the agent accepts and produces by default - **Skills**: a list of specific tasks the agent can perform, each with an identifier, name, description, supported input/output modes, tags, and usage examples - **Authentication requirements**: which authentication schemes the agent supports, expressed as security scheme objects modeled on OpenAPI - **Signatures**: optional JWS signatures over the card's contents The skills array is particularly important for multi-agent orchestration. When a client agent needs to delegate a subtask, it can query the skill descriptions to determine whether a remote agent is capable of handling the work. Skills include human-readable descriptions that allow [language model](https://aiwiki.ai/wiki/language_model)s to reason about whether a given remote agent is appropriate for a given task.[5] Agent Cards may be signed with JSON Web Signature (RFC 7515). The `signatures` field arrived in version 0.3.0. Version 1.0 requires the card to be canonicalized with the JSON Canonicalization Scheme (RFC 8785) before signing, so that differences in JSON serialization do not break verification.[4][8][29] Signing is optional: the specification says Agent Cards "MAY be digitally signed."[4] Signatures address attacks in which an adversary replaces a legitimate Agent Card with one that advertises false capabilities or points to a malicious endpoint.[14] For extended capabilities, agents can offer a `GetExtendedAgentCard` operation that requires authentication before returning a more detailed version of the card. This allows agents to expose sensitive capability information only to verified clients.[4][5] ## Core concepts The main building blocks of an A2A interaction are the client agent, the remote agent (A2A server), the Agent Card, the task, the message, the artifact, and the part.[5][19] ### Tasks The Task is the fundamental unit of work in A2A. A task represents a discrete piece of work that a client agent delegates to a remote agent. Each task has a unique server-generated identifier. Tasks are stateful: they progress through a defined lifecycle of states.[5] Task lifecycle states (in v1.0 the wire values carry a `TASK_STATE_` prefix, for example `TASK_STATE_COMPLETED`):[4][8] | State | Type | Meaning | |-------|------|--------| | `SUBMITTED` | Active | Task acknowledged by server | | `WORKING` | Active | Server is actively processing | | `INPUT_REQUIRED` | Interrupted | Agent is waiting for additional client input | | `AUTH_REQUIRED` | Interrupted | Authentication or authorization needed before continuing | | `COMPLETED` | Terminal | Task finished successfully | | `FAILED` | Terminal | Task ended in error | | `CANCELED` | Terminal | Task was canceled | | `REJECTED` | Terminal | Agent declined to perform the task | The interrupted states support multi-turn interactions and human-in-the-loop workflows. An agent can pause a task and request additional information from the client before continuing. The `AUTH_REQUIRED` state lets an agent hand an authorization request (for example, an OAuth token it needs, or a human's approval before a destructive action) back to the client.[4] ### Messages Messages are the communication units exchanged within a task. Each message has a role designation (user or agent) and contains one or more Parts. Messages can reference a task and a context to maintain conversational continuity across multi-turn interactions.[5] ### Parts A Part is the smallest content unit within a message or artifact. In version 1.0 the separate TextPart, FilePart, and DataPart types were replaced by a single Part that contains one of the following:[8] - **Text**: plain text content - **Raw bytes**: inline binary data (base64 in JSON) - **URL reference**: a pointer to content hosted elsewhere - **Data**: structured JSON of any schema Every Part can also carry a media type and a filename.[8] This flexible model lets A2A carry text, images, audio, video, structured data, and other content types within a single protocol. ### Artifacts Artifacts are the tangible outputs of a task. Where messages carry communication between agents, artifacts carry deliverables: a generated document, a processed dataset, an audio file, a structured report. Each artifact has a unique identifier, a human-readable name, and is composed of one or more Parts.[5] Artifacts support streaming delivery. When a task produces a large output incrementally (for example, a long document being generated token by token), the server can emit `TaskArtifactUpdateEvent` messages that append chunks to the artifact rather than waiting until the full output is ready.[4] ### Context The `contextId` field groups logically related tasks and messages across a series of interactions, allowing an orchestrating agent to maintain continuity in a multi-step workflow. Agents may generate a new context identifier and may accept client-provided ones. If an agent cannot accept a client-provided identifier, it must reject the request rather than substitute its own.[4] ### Extensions The protocol includes a formal extension mechanism. Agents declare supported extensions via URI identifiers in their Agent Card. Extensions can be marked as optional or required; if a required extension is not declared by the client, the agent must return an `ExtensionSupportRequiredError`. Messages and artifacts include extension URIs indicating which extensions influenced their content. This allows the core protocol to remain lean while supporting domain-specific additions.[4][8] ## How does A2A differ from MCP? A2A and the Model Context Protocol (MCP) are often discussed together because both address agent communication, but they operate at different layers of the stack and solve different problems.[6] MCP, developed by Anthropic and open-sourced in November 2024, standardizes the connection between an AI model or agent and the external tools and data sources it uses (databases, APIs, file systems, code interpreters).[6][11] MCP uses a client-server model where the agent is the client and a tool or resource is exposed by an [MCP server](https://aiwiki.ai/wiki/mcp_server). The A2A documentation describes tools as typically "primitives with well-defined, structured inputs and outputs" that perform specific, often stateless functions.[6] A2A, by contrast, addresses the connection between two agents. Rather than an agent calling a tool, A2A describes how Agent A delegates a complex task to Agent B. The interaction is stateful and potentially long-running. Agent B may itself use MCP internally to access its own tools while processing the task.[6] The A2A documentation calls MCP "vertical" (it deepens a single agent) and A2A "horizontal" (it connects agents across team or organizational boundaries).[6] | Dimension | MCP | A2A | |-----------|-----|-----| | Layer | Agent-to-tool | Agent-to-agent | | Relationship | Client calls server (tool) | Peer-to-peer delegation | | State | Often stateless per call | Stateful, task-scoped | | Duration | Sub-second to seconds | Seconds to hours | | Visibility | Agent knows tool schema | Agents stay opaque to each other | | Primary use | Access databases, APIs, files | Delegate subtasks, coordinate workflows | | Originator | [Anthropic](https://aiwiki.ai/wiki/anthropic) | [Google](https://aiwiki.ai/wiki/google) (donated to [Linux Foundation](https://aiwiki.ai/wiki/linux_foundation)) | | Governance | AAIF since December 2025 | Linux Foundation project from June 2025; AAIF since August 2026 | The official A2A documentation illustrates the relationship with an auto repair shop: a customer talks to a shop-manager agent over A2A, a mechanic agent uses MCP to call diagnostic scanners, repair manuals, and platform lifts (tools), and the mechanic uses A2A to order parts from a supplier's agent.[6] The v1.0 announcement says: "In practice, many systems will use both: MCP inside agents, A2A between agents."[8] The two projects now sit in the same foundation. The AAIF's August 2026 announcement lists MCP and A2A as separate layers of its open agentic stack.[26] The Linux Foundation's April 2026 release said the A2A roadmap included "an interoperability specification," without giving details.[10] As of October 30, 2026, no joint MCP and A2A interoperability specification has been published, and the A2A project's public roadmap does not list one.[30] ## Extension family A2A's extension mechanism has supported a small family of related protocols that Google calls the "A2Family".[12][32] | Protocol | Domain | Status (October 2026) | |-----------|--------|-----------------------| | AP2 (Agent Payments Protocol) | Agent-led payments | Announced September 2025; v0.2 released and donated to the FIDO Alliance in April 2026 | | A2UI (Agent to User Interface) | Agent-generated user interfaces | v0.9.1 current; v1.0 release candidate | | UCP (Universal Commerce Protocol) | Agentic commerce (discovery, checkout, post-purchase) | Published shopping specification; lodging draft available | ### Agent Payments Protocol Google announced the Agent Payments Protocol (AP2) on September 16, 2025, as an open protocol developed with more than 60 payments and technology organizations. It can be used as an extension of A2A and of MCP.[24] AP2 addresses a problem that A2A alone did not: how to verify that a user actually authorized an agent to make a particular purchase. It does this with "Mandates": tamper-proof, cryptographically signed digital contracts, backed by verifiable credentials, that record the user's instructions. An Intent Mandate captures the user's request or pre-authorized rules, and a Cart Mandate records approval of a specific cart, giving an auditable chain from intent to payment.[24] Google also launched an A2A x402 extension for agent-based crypto payments, built with Coinbase, the Ethereum Foundation, MetaMask, and others.[24] AP2's documentation describes it as available as an extension for A2A and for UCP.[25] On April 28, 2026, Google released AP2 v0.2, which added "Human Not Present" payments, and announced that it was donating AP2 to the FIDO Alliance.[35] ### A2UI and UCP A2UI lets agents generate interactive user interfaces that render natively on web, mobile, and desktop clients without executing arbitrary code. Instead of sending code, an agent sends declarative component descriptions. The client renders them with its own widgets and allows only components from a pre-approved catalog.[33][32] A2UI was created by Google with contributions from CopilotKit, is licensed under Apache 2.0, and can use A2A as a transport between agents and clients.[33] Google contrasts it with MCP Apps, which ships an agent-driven widget inside an iframe.[32] The Universal Commerce Protocol covers the wider shopping journey, from discovery and checkout to post-purchase experiences.[32] UCP uses REST and JSON-RPC transports and has built-in support for AP2, A2A, and MCP.[34] Its site lists co-developers for shopping (including Google, Shopify, Walmart, Target, and Stripe), lodging (including Hilton, Marriott, and Expedia Group), and food (including DoorDash, Toast, and Uber Eats). A lodging draft specification is available, and food support is listed as coming soon.[34] ## Founding partners and adoption ### Original partners When Google launched A2A in April 2025, the initial coalition included more than 50 technology partners plus a group of service providers.[1] The technology partners spanned [AI infrastructure](https://aiwiki.ai/wiki/ai_infrastructure) (Cohere, MongoDB), business applications (Atlassian, Box, Intuit, UKG, Workday), fintech (PayPal), and enterprise software (Salesforce, SAP, ServiceNow).[1] The service-provider partners (Accenture, Deloitte, McKinsey, PwC, and others) signaled that consulting firms were prepared to build A2A-based solutions for enterprise clients from the protocol's earliest days.[1] ### Linux Foundation founders When the project moved to the Linux Foundation in June 2025, seven organizations formed the Agent2Agent project:[3] | Organization | Role in A2A ecosystem | |---|---| | [Amazon Web Services](https://aiwiki.ai/wiki/amazon_web_services) | Cloud platform; later added A2A support in Bedrock AgentCore Runtime | | Cisco (Outshift) | Integrating A2A into its AGNTCY open-source components | | [Google](https://aiwiki.ai/wiki/google) | Protocol creator | | [Microsoft](https://aiwiki.ai/wiki/microsoft) | Cloud platform; integrated A2A into Azure AI Foundry and Copilot Studio | | [Salesforce](https://aiwiki.ai/wiki/salesforce) | CRM; A2A support in Agentforce | | SAP | Enterprise resource planning | | [ServiceNow](https://aiwiki.ai/wiki/servicenow) | IT service management; A2A in its AI Agent Fabric | Sources for the table: the June 2025 announcements[2][3], Google Cloud's July 2025 update[9], and the April 2026 Linux Foundation release.[10] ### Adoption trajectory The project grew from more than 50 partners at launch to more than 100 by June 2025 and more than 150 by April 2026.[1][3][10] Google Cloud's July 2025 update named [Adobe](https://aiwiki.ai/wiki/adobe) and S&P Global Market Intelligence among partners adopting A2A for inter-agent communication.[9] IBM joined the Technical Steering Committee when ACP merged into A2A in August 2025.[23] Named deployments and pilots include: - **ServiceNow** built A2A into its AI Agent Fabric, a multi-agent communication layer connecting ServiceNow, customer, and partner-built agents.[9] - **Twilio** used A2A for what it calls Latency Aware Agent Selection: by extending the protocol, individual agents broadcast their latency, so the system can route tasks to the most responsive agent available.[9] - **Gordon Food Service and Tyson Foods** worked with Google engineers to pilot a cross-organization agent system, built with ADK and A2A, for product searching and sales tracking. Gordon Food Service said it was planning to bring the system to production in [Gemini Enterprise](https://aiwiki.ai/wiki/gemini_enterprise).[20] - **Huawei** standardized on A2A between its Celia assistant and in-app agents on the HarmonyOS developer platform, and **Tencent's WeChat** was integrating with Huawei and other Android OEM assistants over A2A.[26] - **[Cloud computing](https://aiwiki.ai/wiki/cloud_computing) platforms**: Google Cloud supports A2A agents through ADK, Agent Engine, Cloud Run, and GKE. Microsoft Azure AI Foundry lets agents expose A2A endpoints, and AWS Bedrock AgentCore can host A2A servers.[26] The Linux Foundation's April 2026 release said vertical adoption spanned supply chain, financial services, insurance, and IT operations, but it did not name the insurance users.[10] ## Implementation SDKs The A2A project maintains official SDKs under the `a2aproject` GitHub organization. All are released under the Apache 2.0 license and implement the same specification, enabling cross-language agent interoperability.[7][29] | Language | Repository | Notes | |----------|-----------|-------| | Python | `a2a-python` | Created May 2025; the project's tutorials use Python | | [JavaScript](https://aiwiki.ai/wiki/javascript) | `a2a-js` | Created May 2025 | | Java | `a2a-java` | Created May 2025 | | Go | `a2a-go` | Created May 2025; the A2A CLI is built on it | | C#/.NET | `a2a-dotnet` | Created May 2025 | | Rust | `a2a-rs` | Created April 2026 | The SDKs handle the low-level mechanics of the protocol, including building requests for each binding, managing streams, parsing Agent Cards, and tracking task state, so developers can focus on their agent's own logic.[7] After the v1.0 release, the community said its focus was on "delivering multi-language v1.0 SDK support."[8] The project also maintains a samples repository with worked examples across the supported languages.[7] Validation tooling includes the A2A Inspector, a debugging utility for inspecting agents and their messages, and the Technology Compatibility Kit (TCK), a test suite for checking that an implementation conforms to the specification.[9][30] On October 1, 2026, the project introduced the A2A CLI, an official command-line client that can fetch an Agent Card, send messages, and stream task updates. It is built on the CLI from the Go SDK, speaks protocol v1.0, and is aimed partly at letting [coding agents](https://aiwiki.ai/wiki/coding_agent) hand off work to remote A2A agents.[38] A2A is supported by agent frameworks including [LangGraph](https://aiwiki.ai/wiki/langgraph), [CrewAI](https://aiwiki.ai/wiki/crewai), [Pydantic AI](https://aiwiki.ai/wiki/pydantic_ai), [AG2](https://aiwiki.ai/wiki/ag2), and IBM's BeeAI, as well as Google's ADK.[28][12] These integrations let developers expose existing agents built in those frameworks as A2A servers. ## What is A2A used for? ### Enterprise workflow automation Large organizations with multiple specialized AI agents across business functions use A2A to connect those agents into end-to-end workflows. A procurement agent can delegate spending-category analysis to a finance agent, which returns structured results that the procurement agent incorporates into a purchase recommendation. Each agent retains its specialized tooling and knowledge while participating in the broader workflow through a common protocol. The SaaS platforms using A2A to connect workflows include ServiceNow, Salesforce, Atlassian, and SAP.[28] ### Supply chain coordination Supply chain processes involve multiple parties (manufacturers, distributors, retailers, logistics providers) each operating their own systems and agents. A2A enables agents at different organizations to coordinate on order processing, inventory queries, and fulfillment status without requiring direct system integrations. Agents at different companies can discover each other via Agent Cards and communicate through standardized task delegation. The Gordon Food Service and Tyson Foods pilot is an example of this cross-company pattern.[20] ### Financial services Financial institutions can use A2A to coordinate specialized agents across risk assessment, compliance checking, fraud detection, and customer service. A loan origination workflow, for example, might involve a customer-facing agent delegating identity verification to a compliance agent, credit analysis to a risk agent, and document processing to a back-office agent, with results flowing back through A2A task responses. The protocol's support for long-running tasks and human-in-the-loop pauses fits processes that require human review at certain decision points. Where a workflow ends in a payment, the AP2 extension carries the authorization.[24] ### IT service management In IT operations, A2A enables agents specialized in monitoring, diagnostics, remediation, and change management to coordinate on incident response. An alert from a monitoring agent can be routed via A2A to a diagnostic agent that determines root cause, which then delegates remediation to an execution agent that implements the fix, while an audit agent logs each step. ServiceNow's AI Agent Fabric uses A2A to connect ServiceNow, customer, and partner-built agents.[9] ### Cross-platform agent marketplaces Google said in July 2025 that partners would be able to make A2A agents available in Agentspace, its platform for bringing agents to enterprise employees, and that partners could sell A2A agents directly to Google Cloud customers through the AI Agent Marketplace.[9] ## Security model A2A is designed with enterprise security requirements in mind, though the specification leaves many security decisions, especially authorization, to implementers.[13] ### Transport security Production deployments must use encrypted communication: HTTPS for the HTTP-based bindings and TLS for gRPC. The specification recommends modern TLS configurations (TLS 1.3 or later) with strong cipher suites, and says clients should verify the server's identity by validating its TLS certificate.[13] ### Authentication Agents declare their supported authentication schemes in the Agent Card using security scheme objects.[13] Supported schemes include:[4][8] - API keys (passed in a query parameter, header, or cookie) - HTTP authentication such as Basic and Bearer - OAuth 2.0 (Authorization Code with an optional PKCE requirement, Client Credentials, and, since v1.0, Device Code; the implicit and password flows were deprecated in v1.0) - OpenID Connect - Mutual TLS (mTLS), added as a scheme in v0.3 Credential acquisition happens out of band. A client discovers the required schemes from the Agent Card, obtains credentials through a process specific to that scheme (for example, an OAuth flow), and includes them in protocol-appropriate headers or metadata on every request. The server must authenticate every incoming request.[13] ### Authorization Once a client is authenticated, the server authorizes requests based on the authenticated identity and its own policies. The specification says authorization logic "is implementation-specific" and may consider the specific skills requested, the actions attempted within tasks, data access policies, and OAuth scopes.[13] Since v0.3, individual skills can also specify their own security requirements.[29] ### Agent Card verification Agent Card signatures, added in v0.3.0 and tightened in v1.0 with mandatory canonicalization before signing, let clients check that a card has not been tampered with and comes from the claimed provider.[4][29] The specification supports detached signatures with public key retrieval via a `jku` URL or a trusted keystore.[8] Signing remains optional, and a signature is only as trustworthy as the key infrastructure behind it. The Cloud Security Alliance's threat model of A2A proposed further measures against impersonation, such as decentralized identifiers and a transparency log for Agent Cards.[14] ## Roadmap The A2A project publishes a roadmap on its documentation site. The version last updated on September 15, 2026 lists these near-term initiatives:[30] - **Version 1.1 protocol enhancements**: refining task timeline specifications, standardizing event filtering for backward compatibility, and setting guidelines for messages received while an agent is working - **Bidirectional (BiDi) streaming**: real-time artifact updates, role management, and continuous multi-turn messaging while tasks are executing - **A2A CLI and coding harness integration**: the command-line client released in October 2026 - **Elicitation and multi-turn workflows**: exploring structured human-in-the-loop interaction and multi-round negotiation patterns informed by telecom use cases For the longer term (three to six months), the roadmap covers governance (streamlining contributions through extensions and samples), validation tooling (the A2A Inspector and TCK), SDKs in six languages, and collecting community best practices.[30] The Linux Foundation's April 2026 release summarized the roadmap as including an interoperability specification, consolidation of registry efforts, expanded testing and tooling, and security and deployment best practices.[10] Earlier versions of the roadmap show how priorities moved. The July 2025 roadmap planned the v0.3 release, extension support in the SDKs (starting with Python), signed Agent Cards, and an agent registry for discovery.[30] The March 2026 roadmap centered on the v1.0 release and SDK support for additional extensions.[30] ## Reception Industry reception to A2A was broadly positive at launch, though accompanied by practical questions about adoption pace and the relationship to existing integration patterns. The breadth of the initial partner list was widely cited as evidence of cross-industry demand for agent interoperability.[1] Google moved the protocol to the Linux Foundation about two and a half months after announcing it; Google engineer Mike Smith said the team "knew it needed to be independent and vendor-agnostic."[21] The A2A versus MCP framing was covered extensively in technical media.[18] Commentators such as Auth0 described the two as "not competing standards" but "complementary building blocks."[18] The A2A project itself repeated that framing in its documentation and in the v1.0 announcement, which acknowledged that the relationship "has generated confusion in early ecosystem discussions."[6][8] By September 2025, some observers questioned whether A2A adoption was keeping pace with its launch. In a September 11, 2025 post titled "What happened to Google's A2A?", developer Fatih Kadir Akın of fka.dev argued that A2A "seems to have quietly faded into the background" while MCP became the de facto standard.[37] The Linux Foundation's April 2026 one-year release answered with named cloud integrations and adoption figures, and the AAIF's August 2026 announcement cited production use at Huawei and WeChat.[10][26] Academic and security research took a more critical look at the protocol. In a 2025 [arXiv](https://aiwiki.ai/wiki/arxiv) paper, "Improving Google A2A Protocol: Protecting Sensitive Data and Mitigating Unintended Harms in Multi-Agent Systems," Yedidel Louck, Ariel Stulman, and Amit Dvir identified "insufficient token lifetime control, lack of strong customer authentication, overbroad access scopes, and missing consent flows" as key weaknesses. They proposed explicit consent orchestration, ephemeral scoped tokens, and direct user-to-service data channels, and reported that their enhancements substantially reduced sensitive data leakage in adversarial [prompt injection](https://aiwiki.ai/wiki/prompt_injection) tests.[15] The Cloud Security Alliance published a threat model of A2A using its MAESTRO framework on April 30, 2025, covering threats such as agent impersonation, replay attacks, and malicious servers posing as trusted companies.[14] ## Limitations Several limitations of A2A have been noted by researchers and practitioners: **No standardized authorization framework**: A2A specifies authentication but leaves authorization logic to each implementation.[13] Researchers have pointed to overbroad access scopes as a weakness.[15] The specification also has no standard mechanism for tracking authorization across multi-hop delegation chains, where Agent A delegates to Agent B, which further delegates to Agent C. **Agent Card trust depends on infrastructure security**: Agent Card signing is optional in every version of the specification, including 1.0. Where cards are signed, the security of the scheme depends on how the deploying organization manages and distributes its keys.[4][14] **No mandatory machine-readable skill schema**: Agent Card skills include human-readable descriptions, tags, examples, and input and output media types that language models can use to reason about agent capabilities. They do not include a required schema for skill inputs and outputs comparable to OpenAPI schemas for REST APIs, so agents cannot automatically generate type-safe client code for skill invocation without additional conventions.[5] **Sensitive data handling**: The protocol does not provide built-in mechanisms to prevent agents from unnecessarily passing sensitive data through intermediary agents in a delegation chain. Louck, Stulman, and Dvir argued for explicit user consent and direct user-to-service data channels for highly sensitive information such as payment credentials and identity documents.[15] **Long-lived token vulnerabilities**: The same paper identified insufficient token lifetime control as a weakness, since long-lived credentials widen the window of exposure if they are compromised.[15] **Discovery at scale**: The `.well-known/agent-card.json` convention works for discovering a known agent at a known domain but does not address the broader problem of finding agents that can handle a specific task across the entire ecosystem. The specification mentions registries and catalogs as a discovery mechanism, but registry work has appeared on the project's roadmap since 2025 without a standardized registry.[4][10][30] ## See also - [AI co-scientist (Google)](https://aiwiki.ai/wiki/ai_co_scientist) - [Model Context Protocol](https://aiwiki.ai/wiki/model_context_protocol) - [Agentic AI Foundation](https://aiwiki.ai/wiki/agentic_ai_foundation) - [Agent Payments Protocol](https://aiwiki.ai/wiki/agent_payments_protocol) - [Linux Foundation](https://aiwiki.ai/wiki/linux_foundation) - [Google](https://aiwiki.ai/wiki/google) - [AI agents](https://aiwiki.ai/wiki/ai_agents) - [Agentic AI](https://aiwiki.ai/wiki/agentic_ai) - [LangChain](https://aiwiki.ai/wiki/langchain) - [Multi-agent systems](https://aiwiki.ai/wiki/multi_agent_system) - JSON-RPC - OpenAPI Specification ## References 1. Google Developers Blog. "Announcing the Agent2Agent Protocol (A2A)." April 9, 2025. https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/ 2. Linux Foundation. "Linux Foundation Launches the Agent2Agent Protocol Project to Enable Secure, Intelligent Communication Between AI Agents." June 23, 2025. https://www.linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project-to-enable-secure-intelligent-communication-between-ai-agents 3. Google Developers Blog. "Google Cloud donates A2A to Linux Foundation." June 23, 2025. https://developers.googleblog.com/en/google-cloud-donates-a2a-to-linux-foundation/ 4. A2A Protocol. "Agent2Agent (A2A) Protocol Specification" (latest released version 1.0.0). https://a2a-protocol.org/latest/specification/ 5. A2A Protocol. "Core Concepts and Components in A2A." https://a2a-protocol.org/latest/topics/key-concepts/ 6. A2A Protocol. "A2A and MCP: Detailed Comparison." https://a2a-protocol.org/latest/topics/a2a-and-mcp/ 7. A2A Protocol. "A2A SDK." https://a2a-protocol.org/latest/sdk/ 8. A2A Protocol. "A2A Protocol Ships v1.0: Production-Ready Standard for Agent-to-Agent Communication." March 12, 2026. https://a2a-protocol.org/latest/blog/2026/03/12/a2a-protocol-ships-v10-production-ready-standard-for-agent-to-agent-communication/ ; and "What's New in A2A Protocol v1.0." https://a2a-protocol.org/latest/whats-new-v1/ 9. Google Cloud Blog. "Agent2Agent protocol (A2A) is getting an upgrade." July 31, 2025. https://cloud.google.com/blog/products/ai-machine-learning/agent2agent-protocol-is-getting-an-upgrade 10. Linux Foundation. "A2A Protocol Surpasses 150 Organizations, Lands in Major Cloud Platforms, and Sees Enterprise Production Use in First Year." April 9, 2026. https://www.linuxfoundation.org/press/a2a-protocol-surpasses-150-organizations-lands-in-major-cloud-platforms-and-sees-enterprise-production-use-in-first-year 11. Linux Foundation. "Linux Foundation Announces the Formation of the Agentic AI Foundation (AAIF), Anchored by New Project Contributions Including Model Context Protocol (MCP), goose and AGENTS.md." December 9, 2025. https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation 12. Google Open Source Blog. "A year of open collaboration: Celebrating the anniversary of A2A." April 16, 2026. https://opensource.googleblog.com/2026/04/a-year-of-open-collaboration-celebrating-the-anniversary-of-a2a.html 13. A2A Protocol. "Agent2Agent (A2A) Protocol Specification," Section 7: Authentication and Authorization, and Section 13: Security Considerations. https://a2a-protocol.org/latest/specification/#7-authentication-and-authorization 14. Cloud Security Alliance. "Threat Modeling Google's A2A Protocol with the MAESTRO Framework." April 30, 2025. https://cloudsecurityalliance.org/blog/2025/04/30/threat-modeling-google-s-a2a-protocol-with-the-maestro-framework 15. Louck, Yedidel; Stulman, Ariel; Dvir, Amit. "Improving Google A2A Protocol: Protecting Sensitive Data and Mitigating Unintended Harms in Multi-Agent Systems." arXiv:2505.12490 (v3, August 28, 2025). https://arxiv.org/abs/2505.12490 16. AWS Open Source Blog. "Open Protocols for Agent Interoperability Part 4: Inter-Agent Communication on A2A." August 21, 2025. https://aws.amazon.com/blogs/opensource/open-protocols-for-agent-interoperability-part-4-inter-agent-communication-on-a2a/ 17. a2aproject/A2A GitHub Repository. https://github.com/a2aproject/A2A 18. Auth0. "MCP vs A2A: A Guide to AI Agent Communication Protocols." https://auth0.com/blog/mcp-vs-a2a/ 19. IBM. "What Is Agent2Agent (A2A) Protocol?" https://www.ibm.com/think/topics/agent2agent-protocol 20. Google Cloud. "Gordon Food Service case study." https://cloud.google.com/customers/gordonfoodservice 21. The New Stack. "Google Donates the Agent2Agent Protocol to the Linux Foundation." June 2025. https://thenewstack.io/google-donates-the-agent2agent-protocol-to-the-linux-foundation/ 22. SiliconANGLE. "Google donates Agent2Agent Protocol to the Linux Foundation." June 24, 2025. https://siliconangle.com/2025/06/24/google-donates-agent2agent-protocol-linux-foundation/ 23. LF AI & Data Foundation. "ACP Joins Forces with A2A." August 29, 2025. https://lfaidata.foundation/communityblog/2025/08/29/acp-joins-forces-with-a2a-under-the-linux-foundations-lf-ai-data/ 24. Google Cloud Blog. "Announcing Agent Payments Protocol (AP2)." September 16, 2025. https://cloud.google.com/blog/products/ai-machine-learning/announcing-agents-to-payments-ap2-protocol 25. AP2 Protocol. "Agent Payments Protocol Documentation." https://ap2-protocol.org/ 26. Agentic AI Foundation. "A2A joins AAIF's open agentic stack." August 17, 2026. https://aaif.io/blog/a2a-joins-aaif 27. Anthropic. "Donating the Model Context Protocol and establishing the Agentic AI Foundation." December 9, 2025. https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation 28. A2A Protocol. "A New Chapter for A2A: Joining the Agentic AI Foundation." August 27, 2026. https://a2a-protocol.org/latest/blog/2026/08/27/a-new-chapter-for-a2a-joining-the-agentic-ai-foundation/ 29. a2aproject/A2A. "Releases" (v0.3.0, July 30, 2025; v1.0.0, March 12, 2026; v1.0.1, May 28, 2026) and the a2aproject GitHub organization. https://github.com/a2aproject/A2A/releases ; https://github.com/a2aproject 30. A2A Protocol. "A2A protocol roadmap." Last updated September 15, 2026; earlier versions archived July 2025 and March 2026. https://a2a-protocol.org/latest/roadmap/ ; https://web.archive.org/web/20251112183158/https://a2a-protocol.org/latest/roadmap/ ; https://web.archive.org/web/20260710022822/https://a2a-protocol.org/latest/roadmap/ 31. A2A Protocol. "Multi-Tenancy and Multi-Agent Routing." https://a2a-protocol.org/latest/topics/multi-tenancy/ 32. Google Open Source Blog. "Meet the A2Family." April 23, 2026. https://opensource.googleblog.com/2026/04/meet-the-a2family.html 33. A2UI. "A2UI: A generative UI protocol and framework for cross-platform agentic experiences." https://a2ui.org/ 34. Universal Commerce Protocol. "Universal Commerce Protocol (UCP)." https://ucp.dev/ 35. Google. "We're donating Agent Payments Protocol to the FIDO Alliance to support the future of secure, agentic payments." April 28, 2026. https://blog.google/products-and-platforms/platforms/google-pay/agent-payments-protocol-fido-alliance/ 36. Gartner. "Gartner Predicts 40% of Enterprise Apps Will Feature Task-Specific AI Agents by 2026, Up from Less Than 5% in 2025." August 26, 2025. https://www.gartner.com/en/newsroom/press-releases/2025-08-26-gartner-predicts-40-percent-of-enterprise-apps-will-feature-task-specific-ai-agents-by-2026-up-from-less-than-5-percent-in-2025 37. Akın, Fatih Kadir. "What happened to Google's A2A?" fka.dev, September 11, 2025. https://blog.fka.dev/blog/2025-09-11-what-happened-to-googles-a2a/ 38. A2A Protocol. "Meet the A2A CLI: discover, message, and manage agents from your terminal." October 1, 2026. https://a2a-protocol.org/latest/blog/2026/10/01/introducing-a2a-cli/ 39. A2A Project. "Release v0.2.2" (GitHub release notes: "Add gRPC and REST definitions to A2A protocol specifications"). June 9, 2025. https://github.com/a2aproject/A2A/releases/tag/v0.2.2