Start with the roles
Read the overview, then compare the four roles with one integration you are building.
Start with: A2A Protocol
RedLectern topic
Agent communication · editor-agent interfaces · portable skills · discovery and compatibility.
For: Developers · platform builders.
After this page you can: Distinguish A2A · ACP · Agent Skills · and MCP roles.
Page reviewed
Part of: Artificial Intelligence › AI integration standards
Agent interoperability means connecting independently built systems through shared interfaces and conventions. The integration question is which boundary needs to work: agents communicating and exchanging tasks, a coding agent connecting with an editor, reusable instructions moving between agent tools, or an application connecting to external data and tools. Those are related needs, but the official documentation gives them different roles: A2A addresses communication between agent systems, ACP connects editors and coding agents, Agent Skills packages instructions and resources, and MCP connects applications with external data sources and tools.
Use this page to map an integration need to its role, then check what the specific implementations advertise and support. The sources here were checked on 2026-10-09. A shared protocol or format name alone does not establish that two particular implementations support the same features; compare their declared interfaces and compatibility requirements before designing around them.
Read the overview, then compare the four roles with one integration you are building.
Start with: A2A Protocol
Read the format specification and identify the required file and optional resources.
Start with: Specification
Read the introduction and note which side of the interface is the editor and which is the agent.
Start with: Introduction
In A2A documentation checked 2026-10-09, A2A is an open standard for communication between independent agent systems, and its Agent Card describes an agent’s identity, capabilities, skills and interaction requirements. ACP documentation checked 2026-10-09 describes communication between code editors or IDEs and coding agents. The Agent Skills specification checked 2026-10-09 describes a directory format built around a required SKILL.md file, with optional supporting materials. MCP specification revision 2026-07-28 describes integration between applications and external data sources and tools. These roles can be combined in a system, but each describes a different integration boundary.
Read about the editor-to-agent interface.
Inspect the portable skill format.
Consult the dated specification revision for MCP.
Agent2Agent protocol
In the A2A documentation checked 2026-10-09, an open standard for communication and interoperability between independent agent systems.
Agent Card
In the A2A documentation checked 2026-10-09, metadata describing an agent’s identity, capabilities, skills and interaction requirements.
Agent Client Protocol
As documented on 2026-10-09, a protocol connecting code editors or IDEs with coding agents.
Agent Skills
As specified on 2026-10-09, an open format packaging instructions and resources around a required SKILL.md file.
A developer wants an agent to call a data tool, delegate research to another agent, and work in an editor. Match each connection to a role.
Use MCP for application-to-data or tool access, A2A for communication between agents, and ACP for the editor-to-coding-agent interface. Agent Skills package reusable instructions and resources.
Mcp Vs A2AWhat Are Agent SkillsWhat Is Agent Client Protocol
ACP documentation checked 2026-10-09 describes an interface for communication between code editors or IDEs and coding agents. A2A documentation checked 2026-10-09 describes communication between independent agent systems, with clients using agent metadata to discover suitable agents and configure interactions. Agent Skills, as specified on 2026-10-09, uses a directory containing a required SKILL.md file and optional supporting materials. The intended user and system boundary therefore help identify which role to inspect first: editor teams can examine ACP, agent systems can examine A2A, and teams sharing reusable instructions can examine Agent Skills. For any choice, compare the actual features supported by both implementations.
Compare the agent-to-agent communication role.
Compare a reusable skill package with a communication interface.
An editor team wants its product to work with multiple coding agents through a common interface. Which role should it examine first, and what does it connect?
Examine ACP. Its documented purpose is to standardize communication between code editors or IDEs and coding agents.
In A2A documentation checked 2026-10-09, an Agent Card describes an agent’s identity, capabilities, skills and interaction requirements. The specification lists discovery through a well-known URI, a registry or catalog, or direct configuration. It also says clients should validate declared capability support before attempting operations that require optional capabilities. For MCP, consult specification revision 2026-07-28 to check the protocol requirements for the application and external data or tool connection. For Agent Skills, inspect the skill directory and the receiving agent’s support for its contents. Advertised metadata helps guide selection, while implementation support determines whether the specific connection works.
Use the dated revision when checking MCP protocol details.
Review the format's compatibility metadata.
A discovered Agent Card lists two interfaces. What should a client check before selecting one?
Check which advertised interface and transport the client supports, then use that interface’s declared URL. Confirm the listed authentication and interaction requirements before sending a request.
No recent updates are available.
Gregor Hohpe and Bobby Woolf · 2004
Use its technology-independent messaging patterns to reason about integration choices. Its examples predate today’s agent protocols, so treat it as conceptual background rather than current protocol documentation.
J. J. Geewax · 2021
Learn patterns for designing internal and public-facing APIs, including resource layout, naming, and special interactions. These are useful interface-design foundations, not instructions for a particular editor-agent protocol.