A2A Joins MCP at the Agentic AI Foundation: The Complete Guide for Agentic AI Architects (2026)

On August 17, 2026, Google’s Agent2Agent (A2A) protocol formally became a hosted project of the Agentic AI Foundation (AAIF) — the Linux Foundation-directed body that already governs Anthropic’s Model Context Protocol (MCP), Block’s goose agent framework, and OpenAI’s AGENTS.md convention. With more than 250 member organizations including AWS, Microsoft, Anthropic, Google, and OpenAI signed on as governance participants, this move consolidates the two most critical protocol layers of the agentic AI stack under a single neutral roof (AAIF Official Announcement).

If you build multi-agent systems — or you will in the next 12 months — this is not a branding event. It is a structural shift in how your agents will discover, communicate with, and delegate work to agents built by other teams, other vendors, and other frameworks. This guide breaks down exactly what changed, why it matters for enterprise architectures, and what you should do about it now.

Table of Contents

• What Is the Agentic AI Foundation (AAIF)?
• What A2A Actually Does — And How It Differs from MCP
• The Full AAIF Protocol Stack: Five Layers, One Governance Model
• A2A v1.0 Technical Architecture: Agent Cards, Tasks, and Streaming
• Where A2A Is Already Running in Production
• What This Means for Enterprise Agentic Architectures
• Implications for RPA Teams Moving to Agentic Workflows
• Getting Started: How to Adopt A2A + MCP in Your Stack Today
• FAQs
• Key Takeaways
• References

What Is the Agentic AI Foundation (AAIF)?

The Agentic AI Foundation launched in December 2025 as a Linux Foundation initiative to provide neutral, vendor-independent governance for the infrastructure that powers AI agents in production. Its founding members — Anthropic, OpenAI, and Block — contributed three anchor projects: MCP (the protocol for connecting agents to tools and data), goose (an open-source agent runtime from Block), and AGENTS.md (a specification for communicating instructions and conventions to AI agents).

Within eight months, AAIF grew from fewer than 40 members to over 250. Platinum-tier signatories now include AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI (Linux Foundation Press Release). That breadth is deliberate. When foundational infrastructure protocols are owned by a single vendor, every downstream team absorbs that vendor’s roadmap constraints. When they are governed openly, the community shapes what gets built.

For context, MCP alone had crossed 97 million monthly SDK downloads (Python + TypeScript combined) by February 2026. The protocol that standardizes how your agents connect to databases, APIs, and enterprise services is no longer any single company’s project — it belongs to the ecosystem. And now A2A, the protocol that standardizes how your agents talk to each other, sits in the same governance structure.

What A2A Actually Does — And How It Differs from MCP

The simplest mental model: MCP is vertical, A2A is horizontal.

MCP standardizes the connection between an agent and its tools. When a Claude-based agent needs to query a PostgreSQL database, read a Google Drive file, or call a Salesforce API, MCP defines the protocol for that interaction — discovery, authentication, invocation, and response. It solves the “agent-to-tool” problem. If you’ve built MCP servers for your internal tools, you’ve already used this layer. (For a deeper dive, see our guide to what MCP servers are and how they work.)

A2A solves a different problem: the “agent-to-agent” problem. When a procurement agent built on LangGraph needs to delegate a compliance check to a legal-review agent built on Google ADK, or when a customer-service agent on Salesforce Agentforce needs to route an IT escalation to a ServiceNow agent, A2A defines how those agents discover each other, negotiate capabilities, delegate tasks, and exchange results — regardless of their underlying framework.

More Read

Robotics Process Automation in Finance and Accounting

🔒UiPath AI Trust Layer: A New Era of Responsible AI-Powered Automation

Telegram Bot Integration With UiPath (Remote Captcha solving)

AAIF CTO Manik Surtani put it directly: “Where A2A fits is at the collaborative edge; where MCP fits is at the tool integration edge.” Together they form the plumbing for what analysts increasingly call the agentic AI economy (AAIF Blog).

The critical point: these protocols are complementary, not competing. A well-architected multi-agent system uses MCP for each agent’s tool access and A2A for inter-agent coordination. The AAIF governance model does not merge them — each retains its own technical steering committee — but ensures their roadmaps stay aligned.

The Full AAIF Protocol Stack: Five Layers, One Governance Model

With A2A’s addition, the AAIF now governs a complete five-layer stack for agentic AI infrastructure. Understanding each layer is essential for architects designing production systems.

Layer 1: Instructions and Context — AGENTS.md

AGENTS.md standardizes how projects communicate expectations, conventions, and operating instructions to AI agents. Think of it as the “README for agents” — a structured document that tells an agent what it can and cannot do within a given project, what coding standards to follow, what tools are available, and what guardrails apply. Contributed by OpenAI.

Layer 2: Agent Runtime — goose

Block’s goose provides the environment in which an agent reasons, plans, invokes capabilities, and executes work. It is an open-source agent framework that handles the execution loop — the “engine” that an agent runs on top of.

Layer 3: Agent-to-Tool Connectivity — MCP

Anthropic’s Model Context Protocol standardizes how agents connect to tools, data sources, applications, and services. MCP servers expose capabilities through a uniform interface, and MCP clients (agents) discover and invoke them. The 2026-07-28 stateless spec update made MCP servers truly stateless, removing the requirement for persistent connections and making the protocol viable for serverless and edge deployments.

Layer 4: Traffic Mediation — agentgateway

agentgateway sits at the boundary between agent systems and infrastructure, handling routing, policy enforcement, and observability. It is the operations layer — where you apply rate limiting, access control, audit logging, and traffic shaping to agent communications.

Layer 5: Agent-to-Agent Interoperability — A2A

A2A standardizes how independent agents discover one another, communicate, delegate tasks, and exchange results across systems and organizational boundaries. This is the newest addition and the layer that makes true multi-vendor, multi-framework agent ecosystems possible.

Every major cloud provider and AI lab is a governance participant. This is not a Google stack or an Anthropic stack — it is the industry stack. For architects, this means you can design multi-agent systems against these protocols with reasonable confidence that they won’t be deprecated, forked, or locked behind a single vendor’s paywall.

A2A v1.0 Technical Architecture: Agent Cards, Tasks, and Streaming

A2A v1.0 shipped in March 2026 with several critical capabilities that make it production-ready. Here’s what you need to understand as an implementer.

Agent Cards: Discovery and Identity

Every A2A-capable agent publishes an Agent Card — a JSON metadata document describing its identity, capabilities, skills, service endpoint, and authentication requirements. Agent Cards are the discovery mechanism: other agents read your card to understand what you can do and how to reach you (A2A v1.0 Specification).

The v1.0 spec added signed Agent Cards with cryptographic identity verification. Clients verify the signatures field against the issuer’s public key (typically held in a curated registry or x5c chain) before trusting the card. This is not optional for enterprise deployments — unsigned agent cards in a multi-vendor system are the equivalent of unsigned API endpoints.

// Simplified Agent Card structure
{
  "@context": "https://a2a-protocol.org/v1.0",
  "name": "compliance-review-agent",
  "description": "Reviews procurement requests against regulatory requirements",
  "url": "https://agents.example.com/compliance",
  "version": "1.0.0",
  "skills": [
    {
      "id": "regulatory-check",
      "name": "Regulatory Compliance Check",
      "description": "Evaluates a procurement request against applicable regulations",
      "inputModes": ["text", "application/json"],
      "outputModes": ["application/json"]
    }
  ],
  "authentication": {
    "schemes": ["oauth2"],
    "credentials": "https://auth.example.com/.well-known/oauth-authorization-server"
  },
  "signatures": { }
}

Task Lifecycle: The State Machine

Every interaction in A2A revolves around a strict task state machine. When an agent receives a SendMessage call, it either returns a Message directly (for trivial responses) or instantiates a Task and transitions it through defined states:

submitted → working → input-required → completed | canceled | failed

This is fundamentally different from simple request/response patterns. The input-required state is particularly important — it allows agents to negotiate, ask clarifying questions, or request additional context mid-task. A compliance agent reviewing a procurement request can pause in input-required, ask the requesting agent for additional documentation, receive it, and then continue to completed. This models how humans actually collaborate — with back-and-forth — rather than the fire-and-forget pattern of most API integrations.

Streaming Architecture

For long-running tasks, A2A supports streaming via Server-Sent Events (SSE). Clients call SendStreamingMessage (to submit and stream in one step) or SubscribeToTask (to attach to an existing task). The server responds with Content-Type: text/event-stream and pushes TaskStatusUpdateEvent and TaskArtifactUpdateEvent objects until the task reaches a terminal state.

This means your orchestrating agent doesn’t need to poll. It opens a stream, processes status updates and partial results as they arrive, and can display progress to end users in real time.

Multi-Tenancy and Version Negotiation

The v1.0 spec added two enterprise-critical capabilities. Multi-tenancy allows a single A2A server to serve multiple tenants with isolated task namespaces. Version negotiation allows agents running different spec versions to discover the highest mutually supported version and communicate at that level — essential for organizations rolling out upgrades across a fleet of agents at different cadences.

Where A2A Is Already Running in Production

A2A is not a whitepaper protocol. As of mid-2026, it is running in production across mobile platforms, cloud infrastructure, financial services, and supply chain logistics. Here are the most significant deployments (Linux Foundation Press Release, April 2026).

Huawei HarmonyOS: Mobile-Scale Agent Orchestration

Huawei standardized A2A as the protocol between Celia (its OS-level AI assistant) and in-app agents across the HarmonyOS developer platform. Supported scenarios include Celia delegating long-running tasks to app agents, Celia controlling app UI through an agent, and Celia requesting contextual recommendations from application agents. This is agent-to-agent communication operating at mobile operating system scale — billions of potential interactions daily.

Tencent’s WeChat is among the first major apps integrating with Huawei and other Android OEM assistants over A2A, enabling messages, voice calls, and video calls initiated through an AI assistant. The flow runs with dual authorization through the A2A protocol.

PayPal: Agentic Commerce

PayPal deployed A2A in production for merchant-facing workflows. A sales agent receives a natural-language request, uses A2A to locate and authenticate a PayPal-provided payment agent via its Agent Card, and initiates a transaction. Google Cloud and PayPal are extending this into the Agent Payments Protocol (AP2), where shopping and merchant agents communicate over A2A throughout product discovery, pricing, and order fulfillment, with AP2 handling the payment authorization layer. Over 60 organizations across payments and financial services already support this initiative.

Cloud Platform Native Integration

Every major cloud platform now supports A2A natively:

• Google Cloud: Supports developing and deploying A2A agents through Agent Development Kit (ADK), Agent Engine, Cloud Run, and GKE. If you’ve been building multi-agent systems with Google ADK, A2A support is already built into the framework.
• Microsoft Azure: Azure AI Foundry lets agents expose A2A endpoints and discover external agents through standard discovery. This integrates directly with Copilot Studio’s multi-agent orchestration capabilities.
• AWS: Amazon Bedrock AgentCore can host and operate A2A servers, enabling cross-framework and cross-cloud agent communication.

Enterprise IT: Cross-Vendor Agent Collaboration

A Salesforce CRM agent can route a support escalation to a ServiceNow ITSM agent. A Google Workspace agent can delegate document summarization to a specialized LLM agent on Azure. These aren’t theoretical scenarios — they are the explicit design targets of the protocol and the reason companies like Salesforce, SAP, ServiceNow, and Workday are all supporters.

What This Means for Enterprise Agentic Architectures

The consolidation of A2A and MCP under one governance body has several concrete implications for architects designing production agent systems.

1. The End of Custom Integration Code Between Agents

Before A2A, connecting agents built on different frameworks required custom integration code for every pairing. A LangGraph agent talking to a Google ADK agent needed bespoke glue. A UiPath process invoking a Bedrock agent needed a custom connector. With A2A, any agent that publishes an Agent Card and implements the task lifecycle can communicate with any other A2A-compatible agent. The cost isn’t in the agents — it’s in eliminating the O(n²) integration matrix.

2. Protocol Vendor Lock-in Risk Drops Dramatically

When MCP was Anthropic’s project and A2A was Google’s project, architects legitimately worried about betting on one vendor’s protocol. With both under AAIF governance — and with every major cloud provider and AI lab signed on — the risk profile changes fundamentally. These are now industry standards with the same governance model that governs Linux, Kubernetes, and other foundational infrastructure. As our guide to enterprise agent governance explores, governance is the hardest problem in agent deployments — and having protocol governance settled at the industry level removes one category of that risk entirely.

3. The Agent Card Becomes Your Agent’s Resume

Agent Cards are not just a technical artifact. They are the mechanism by which your agents advertise their capabilities in a marketplace of agents. Organizations that invest in clear, well-structured Agent Cards — with precise skill descriptions, proper authentication, and cryptographic signatures — will find their agents get discovered and delegated to. Those that don’t will build agents that sit in isolation.

4. Multi-Cloud Agent Architectures Become First-Class

With AWS, Azure, and Google Cloud all supporting A2A natively, you can now design architectures where agents on different clouds collaborate seamlessly. A fraud-detection agent on AWS Bedrock can delegate to a customer-history agent on Azure AI Foundry, which can invoke a risk-scoring agent on Google Cloud’s Agent Engine — all through standardized A2A communication. This is a concrete answer to the multi-cloud agent challenge that enterprises have been asking about.

5. IBM’s ACP Merger Validates the Convergence

In August 2025, IBM’s Agent Communication Protocol (ACP) merged into A2A. This was an early signal that the industry was consolidating around A2A rather than sustaining competing protocols. IBM — the company behind watsonx Orchestrate’s agentic control plane — decided to contribute its protocol work into A2A rather than maintain a separate standard. When a company with IBM’s enterprise footprint makes that call, it tells you where the industry consensus landed.

Implications for RPA Teams Moving to Agentic Workflows

If your team currently runs UiPath, Automation Anywhere, Blue Prism, or Power Automate automations, the A2A + MCP stack has direct implications for your transition path to agentic workflows.

RPA Processes as A2A-Accessible Agents

The A2A protocol makes it possible to wrap existing RPA processes as agent-accessible services. An RPA bot that processes invoices in SAP can be exposed via an Agent Card, making it discoverable and callable by any A2A-compatible agent. The bot doesn’t need to be rebuilt — it needs a wrapper that publishes its capabilities and implements the task lifecycle.

This is significant because it provides a migration path that doesn’t require rip-and-replace. Your existing RPA investments become nodes in a broader agentic network. The latest comparison of UiPath, Automation Anywhere, and Blue Prism’s agentic capabilities shows that all three vendors are moving toward agent-oriented architectures — A2A gives them a standard protocol to target.

MCP for Tool Access, A2A for Process Orchestration

Here’s a practical architecture pattern for RPA-to-agentic migration:

• MCP servers wrap your existing integrations: SAP connections, database queries, file system operations, email interactions. Each becomes a standard MCP tool that any agent can discover and invoke.
• A2A handles the orchestration layer: a customer-onboarding agent delegates KYC checks to a compliance agent, which delegates document extraction to an IDP agent, which delegates data entry to an RPA-wrapped SAP agent.

This pattern preserves your existing automation logic (the RPA bots doing the actual work) while adding an intelligent orchestration layer on top. It is a practical answer to the question every RPA team is asking: “How do we get to agentic without throwing away what we’ve built?”

The Governance Question

Enterprise RPA programs already have governance frameworks — change management, access control, audit trails, error handling. The A2A protocol maps cleanly to these requirements. Agent Cards include authentication requirements. The task lifecycle provides auditable state transitions. The enterprise agent deployment considerations we’ve covered previously apply directly — A2A doesn’t replace your governance; it gives it a standard protocol to enforce against.

Getting Started: How to Adopt A2A + MCP in Your Stack Today

Here’s a practical roadmap for teams that want to start building with both protocols.

Step 1: Start with MCP (If You Haven’t Already)

MCP has a larger ecosystem and more immediate utility for most teams. Wrap your most-used internal tools as MCP servers. The Python and TypeScript SDKs are mature, and most agent frameworks (LangGraph, Google ADK, Claude, Bedrock Agents) support MCP natively. Start with your database, your CRM, and your document store.

Step 2: Design Your Agent Card

Before you implement A2A, design the Agent Card for your most valuable agent. What skills does it expose? What input/output modes does it support? What authentication is required? This exercise forces you to think about your agent’s external interface — which is often underdefined in internal agent projects.

Step 3: Choose Your A2A SDK

Google provides official SDKs for Python, TypeScript/JavaScript, Java, and Go. The SDKs handle the task lifecycle, streaming, and Agent Card serving. If you’re on Google ADK, A2A support is built in. If you’re on LangGraph or another framework, use the standalone SDK.

# Python: Minimal A2A server using the official SDK
from a2a.server import A2AServer, AgentCard, Skill

card = AgentCard(
    name="invoice-processor",
    description="Processes and validates supplier invoices",
    url="https://agents.internal.example.com/invoice",
    skills=[
        Skill(
            id="validate-invoice",
            name="Invoice Validation",
            description="Validates invoice against PO and contract terms",
            input_modes=["application/json"],
            output_modes=["application/json"]
        )
    ]
)

server = A2AServer(card=card)

@server.on_message
async def handle(message, context):
    # Your agent logic here
    invoice_data = message.content
    result = await validate_against_po(invoice_data)
    return context.complete(result)

server.run(port=8080)

Step 4: Test Cross-Framework Communication

The value of A2A appears when agents on different frameworks need to collaborate. Build a simple two-agent system where Agent A (on one framework) delegates a task to Agent B (on another) via A2A. Verify the full lifecycle: discovery via Agent Card, task submission, status updates, and result retrieval. This is your proof of concept for multi-vendor agent architectures.

Step 5: Layer in agentgateway for Operations

Once you have agents communicating via A2A, add AAIF’s agentgateway for routing, policy enforcement, and observability. This is where you apply rate limiting, access control, and audit logging — the operations layer that makes agent communication production-ready.

Frequently Asked Questions

Does A2A replace MCP?

No. They solve different problems and are designed to work together. MCP handles agent-to-tool connectivity (your agent querying a database or calling an API). A2A handles agent-to-agent communication (your agent delegating work to another agent). A production system typically uses both — MCP for each agent’s tool access and A2A for inter-agent orchestration.

Do I need to switch agent frameworks to use A2A?

No. A2A is framework-agnostic by design. An agent built on LangGraph can communicate with an agent built on Google ADK, Claude, or a custom framework. You add A2A support to your existing agent — you don’t rebuild the agent. The official SDKs (Python, TypeScript, Java, Go) handle the protocol layer.

Is A2A ready for production use?

Yes. A2A v1.0 shipped in March 2026 with signed Agent Cards, multi-tenancy, and version negotiation. It is running in production at Huawei (mobile OS scale), PayPal (agentic commerce), and across AWS, Azure, and Google Cloud. Over 150 organizations are active supporters.

How does A2A handle security and authentication?

Agent Cards include authentication requirements (OAuth 2.0, API keys, or custom schemes). The v1.0 spec added cryptographic signatures for Agent Cards, so clients can verify an agent’s identity before trusting its card. The task lifecycle is fully auditable, with each state transition logged.

Can existing RPA processes be exposed via A2A?

Yes. An RPA process can be wrapped with an A2A server that publishes an Agent Card describing the process’s capabilities and implements the task lifecycle. The RPA bot continues to execute the actual work — A2A provides the discovery and communication layer that makes it accessible to other agents.

Key Takeaways

• A2A + MCP under one roof is a structural shift. The two most critical agent protocol layers — tool connectivity (MCP) and inter-agent communication (A2A) — are now governed by the same Linux Foundation body with 250+ members including every major cloud provider and AI lab.
• MCP is vertical, A2A is horizontal. Use MCP to connect agents to tools and data. Use A2A to connect agents to other agents. Both are complementary and both are needed for production multi-agent systems.
• A2A is already in production. Huawei (mobile OS), PayPal (commerce), and all three major cloud platforms run A2A today. This is not vaporware.
• RPA teams have a migration path. Existing RPA processes can be wrapped as A2A-accessible agents without rebuilding them, preserving automation investments while adding intelligent orchestration.
• Agent Cards are your agent’s external interface. Invest in clear, well-structured Agent Cards with proper authentication and signatures. They determine whether your agents get discovered and trusted in multi-vendor ecosystems.
• Start with MCP, add A2A when you need multi-agent. For most teams, wrapping internal tools as MCP servers delivers immediate value. Layer A2A when you need agents to delegate work across framework or vendor boundaries.

References

1. Agentic AI Foundation. “A2A joins AAIF’s open agentic stack.” August 17, 2026. https://aaif.io/blog/a2a-joins-aaif
2. Forbes. “Agent2Agent Joins The Agentic AI Foundation Alongside MCP.” August 19, 2026. https://www.forbes.com/sites/janakirammsv/2026/08/19/
3. Axios. “AI agents inch toward interoperability.” August 17, 2026. https://www.axios.com/2026/08/17/
4. Linux Foundation. “A2A Protocol Surpasses 150 Organizations.” April 2026. https://www.linuxfoundation.org/press/
5. Linux Foundation. “Announces the Formation of the Agentic AI Foundation (AAIF).” December 2025. https://www.linuxfoundation.org/press/
6. A2A Protocol. “v1.0 Specification.” March 2026. https://a2a-protocol.org/latest/specification/
7. AI Magazine. “Why Did Google’s A2A Join the Agentic AI Foundation?” August 2026. https://aimagazine.com/news/
8. Tyk. “A2A protocol: Architecture and technical specification.” 2026. https://tyk.io/learning-center/
9. Pebblous. “A2A Joins MCP at the Agentic AI Foundation.” 2026. https://blog.pebblous.ai/blog/
10. Zylos Research. “Agent Interoperability Protocols 2026: MCP, A2A, ACP and the Path to Convergence.” March 2026. https://zylos.ai/research/