The AI agent ecosystem in 2026 faces a critical infrastructure problem: how do agents communicate with each other, how do they access tools, and how are they packaged for portability? The answer lies in a layered protocol stack built on three pillars: the Agent-to-Agent (A2A) protocol for agent communication, the Model Context Protocol (MCP) for tool access, and Agent Plugins 1.0 for portable packaging. Understanding how these three standards work together is essential for any organization building multi-agent systems that need to be interoperable across different frameworks and vendors. This article breaks down each protocol, explains how they fit into the modern agent stack, and clarifies the critical role each plays in the emerging Agent Internet.
The Agent Stack in 2026: How AI Agents Communicate
The term "Agent Internet" is starting to appear in industry discussions, but few have clearly defined the underlying infrastructure that makes it possible. While multi-agent systems were a buzzword in 2025, the real problem in 2026 is standardization. Without common protocols, every agent framework becomes a silo, requiring custom integration code to connect agents across different vendors. The emerging solution is a three-layer stack:
- Packaging Layer (Agent Plugins): Defines how agent skills and MCP server configurations are bundled into a portable directory that any compatible client can load.
- Tool Access Layer (MCP): Connects agents to external data sources, APIs, and services. This is the protocol that lets an agent call a database, read a file, or invoke an API.
- Communication Layer (A2A): Enables agent-to-agent delegation, discovery, and task lifecycle management. This is how one agent hands off a complex subtask to a specialist agent it did not build.
Together, these three layers create a system where an agent built in LangGraph can delegate to an agent built in AutoGen, both accessing shared tools through MCP, packaged in a format any client can load. The stack is designed so developers can swap any layer without rewriting the others.
Agent Plugins 1.0: The Packaging Standard
Agent Plugins 1.0 reached general availability on August 12, 2026, marking a significant milestone in agent portability. Initiated by Vercel and refined collaboratively by Amazon Web Services (AWS), Anysphere (Cursor), GitHub, Microsoft, OpenAI, and Vercel itself, Agent Plugins 1.0 is an open, vendor-neutral packaging standard that bundles Agent Skills and MCP server configurations into a portable directory structure.
The standard defines a fixed directory layout. A plugin is a folder containing a required plugin.json manifest, an optional skills/ folder for Agent Skills, and an optional mcp.json file declaring MCP servers. Client-specific extensions can live in reverse-domain namespace folders (like com.example.client/). This structure is the minimum viable interoperability floor: it defines where components live, but not how they are installed or registered.
What makes Agent Plugins 1.0 significant is what it does not touch. The spec deliberately excludes installation, registries, and distribution mechanisms. It focuses purely on the portable package format. This means an agent built with one framework can use a plugin built for another, as long as both adhere to the directory layout.
At launch, Agent Plugins 1.0 supports ChatGPT, Codex, Cursor, GitHub Copilot, Kiro, and VS Code. Google announced on launch day that it is joining as a core maintainer and shipping plugin support in its own products. The practical impact is immediate: a developer can build a plugin once and use it across all compatible agent clients, eliminating the need to maintain separate packaging for each platform.
MCP (Model Context Protocol): The Tool Access Layer
The Model Context Protocol (MCP) is the protocol that connects agents to external data and services. Originally developed by Anthropic and now governed by the Linux Foundation's Agentic AI Foundation, MCP defines how agents discover and invoke tools at runtime. It is the protocol layer that sits between an agent and a database, file system, API, or any other external resource.
MCP works by exposing tools as schemas that agents can reason about. When an agent connects to an MCP server, it receives a list of available tools with their names, descriptions, and parameter schemas. The agent can then invoke these tools as part of its reasoning process. MCP also supports resources (data sources), prompts (pre-built instructions), and sampling (letting the tool call the agent).
In the three-layer stack, MCP handles tool-to-agent integration. An agent might use MCP to query a PostgreSQL database, read files from a shared drive, or call an external API. The protocol is request-response oriented, designed for atomic actions rather than long-running tasks. For complex, multi-step delegations, the stack uses A2A instead.
MCP has seen rapid adoption across the industry. According to the Linux Foundation, more than 150 organizations support the protocol. It has become the de facto standard for connecting AI agents to enterprise tools and data.
A2A (Agent-to-Agent Protocol): The Communication Layer
The Agent-to-Agent (A2A) protocol is the layer that enables agent-to-agent communication, delegation, and task lifecycle management. Released by Google in April 2025 and donated to the Linux Foundation in June 2025, A2A reached v1.0 in March 2026. In August 2025, IBM's Agent Communication Protocol (ACP) merged into A2A under the Linux Foundation, consolidating the two agent-to-agent efforts into one standard.
A2A defines four core primitives that make agent interoperability possible:
-
Agent Card: A structured JSON document that advertises an agent's capabilities, authentication requirements, and supported skills. Served at a well-known URL (
/.well-known/agent-card.json), the Agent Card is how agents discover each other. Cards can be cryptographically signed for verification. -
Task Lifecycle: A2A defines a standardized lifecycle with states: submitted, working, completed, failed, input-required, and canceled. This allows both synchronous and long-running asynchronous delegation, with support for streaming progress via SSE and push notifications via authenticated webhooks.
-
Messages and Parts: A2A messages carry a role and an array of parts (text, structured data, or files), enabling a single message to mix instructions, JSON parameters, and binary attachments.
-
Transport: A2A runs over HTTP(S) with JSON-RPC 2.0 as the core binding, with optional gRPC and REST bindings. It supports synchronous request/response, SSE streaming, and push notifications.
A2A is the protocol that allows a LangGraph orchestrator to delegate to a Pydantic AI specialist, or a Google ADK agent to delegate to an AutoGen agent, without custom integration code. It solves the interoperability problem at the communication layer, where agents from different frameworks need to work together.
How They Work Together: A Real-World Example
Consider a multi-agent financial analysis workflow. A user agent packaged as an Agent Plugin loads skills for parsing financial statements and an MCP server for querying market data. When the user asks to analyze a company's Q2 earnings report, the user agent recognizes this requires a specialist.
Using A2A, the user agent queries a registry of Agent Cards to find a financial analysis specialist. It submits a task with the earnings PDF as an attachment. The specialist agent processes the document using its own MCP servers, generates a structured analysis, and returns the result via the A2A task lifecycle.
Throughout this flow, all three layers work in concert. Agent Plugins ensure both agents are packaged in a format their respective clients can load. MCP connects each agent to the tools and data it needs. A2A handles the delegation, discovery, and result exchange between the two agents.
This is the practical reality of the Agent Internet: not a single monolithic system, but a layered stack of protocols that enable agents to collaborate across organizational and framework boundaries.
The State of Play: Governance, Adoption, and What Comes Next
The consolidation of agent protocols under the Linux Foundation signals a maturing ecosystem. A2A and MCP are both governed by vendor-neutral bodies, with Technical Steering Committees that include AWS, Google, IBM, Microsoft, Salesforce, SAP, ServiceNow, and others. Agent Plugins, while initiated by Vercel, is governed by a Technical Steering Committee of Core Maintainers from AWS, Cursor, Microsoft, OpenAI, and Vercel.
The industry adoption is substantial. A2A has more than 150 supporting organizations. MCP has become the standard for tool integration. Agent Plugins launched with support from six major client platforms on day one. The infrastructure layer is no longer theoretical; it is shipping in production.
The real test will be whether portability delivers on its promise. Agent Plugins 1.0 defines a portable package format, but installation and registration remain client-specific. A2A defines how agents communicate, but discovery and authentication require ecosystem-wide adoption of Agent Card registries. MCP defines how agents access tools, but governance of tool schemas and permissions is still evolving.
The next 12 months will determine whether these standards create a truly interoperable Agent Internet or fragment into competing implementations. The protocols are in place. The governance is neutral. The adoption is real. The question now is whether the industry can maintain discipline around a shared infrastructure layer while competing at the application layer above it.
The Agent Internet is not a single technology. It is a stack of protocols, each solving a specific problem in the multi-agent lifecycle. Understanding how A2A, MCP, and Agent Plugins fit together is essential for anyone building the next generation of AI systems.