The short answer
Different protocols standardize different boundaries
The agent ecosystem in 2026 has several standards, and the confusion is almost always a boundary confusion: people compare protocols that never touch the same edge.
The useful mental model is a map of boundaries, not a ranking. MCP standardizes runtime access to tools, resources, and prompts. A2A standardizes communication between independent agents. AG-UI standardizes the event stream between an agent backend and a user-facing application. UHP is a younger open standard for the configured-harness boundary: how a product configures a harness with its model, skills, MCP servers, and tool restrictions, and how it drives that harness through tasks, sessions, streaming, files, and cancellation. MHS standardizes drivers and shared device access for programmable physical hardware. These technologies can be composed, but their boundaries are not all the same kind of layer.
This guide maps each boundary, notes governance and maturity honestly, and ends with a selection checklist. Verified against public materials on September 5, 2026; versions and governance move quickly, so treat the specifics as a dated snapshot.
The map
The 2026 agent protocol boundary map
Read this table by boundary. The question each standard answers is different, which is why most of them compose rather than compete:
| Standard | Boundary it governs | Unit of exchange | Governance |
|---|---|---|---|
| MCP | AI application to tools, resources, and prompts | JSON-RPC requests and results for tools, resources, and prompts | Agentic AI Foundation (Linux Foundation) |
| A2A | Independent agent to independent agent | Messages and tasks; context identifiers; artifacts as outputs | Agentic AI Foundation (Linux Foundation) |
| AG-UI | Agent backend to user-facing application | Typed events for messages, state, tool calls, and run lifecycle | Open project, CopilotKit-led |
| MHS | Software to programmable physical devices through MHS drivers | Device metadata, shared state, and read/write commands | Anthropic-led research preview; not yet open source |
| UHP | Product to a configured agent harness, covering configuration and driving | Harness objects and lifecycle operations; tasks, responses, streamed events, sessions, and files | Open standard, initiated by HarnessRouter |
For focused boundary comparisons, see UHP vs MCP, UHP vs A2A, and UHP vs ACP. The last page concerns Zed's editor-to-agent Agent Client Protocol, not IBM's former Agent Communication Protocol.
Tools
MCP: tools and data
The Model Context Protocol connects AI applications to tools, resources, and prompts through a host-client-server contract. It has broad implementation support and was donated to the Agentic AI Foundation under the Linux Foundation. The 2026-07-28 release made the protocol core stateless, introduced per-request capability negotiation, and formalized optional extensions including MCP Apps and Tasks. Full detail is in what is MCP.
Agents
A2A: communication between independent agents
The Agent2Agent protocol connects independent agents so they can discover each other through Agent Cards, delegate tasks, and exchange artifacts. It reached v1.0 in 2026 and joined the Agentic AI Foundation with broad multi-vendor support. IBM's earlier Agent Communication Protocol, an agent-to-agent effort also abbreviated ACP, merged into A2A in 2025. Full detail is in what is the A2A protocol.
Frontends
AG-UI, A2UI, and MCP Apps: three approaches to agent UI
Agent-facing UI has several related mechanisms, which are easy to conflate. AG-UI is an open, bidirectional event protocol between agent backends and user-facing applications. A2UI is a declarative protocol for client-rendered generative UI. MCP Apps is a stable MCP extension through which an MCP server can offer interactive UI resources to a host. They can overlap in a product, but they are not the same contract.
Devices
MHS: programmable physical devices
The Model Hardware Standard defines a standardized hardware driver, shared device state, discovery, read and write primitives, and device safety metadata. Agents can access MHS through MCP, a command-line interface, or APIs. As of September 2026, it is a limited Anthropic research preview, has not yet been open-sourced, and should not be presented as broadly adopted. We cover it separately in what is the Model Hardware Standard.
Harnesses
UHP: configuring and running complete agent harnesses
The Unified Harness Protocol addresses the configured-harness boundary: how a product discovers, configures, selects, and drives the complete harness that runs an agent. It covers what a harness is made of (its model, skills, MCP servers, and which tools are available) and how a product drives it (tasks, sessions, streaming, files, and cancellation). It is an open, versioned standard with a public specification, a local conformance suite, and an Apache-2.0 reference implementation. You can read the contract in the UHP architecture, and check implementations against the conformance suite.
UHP is younger than MCP and A2A and is still building its ecosystem. It currently has a reference implementation, a local conformance suite, and one independent client implementation. It should be evaluated as a complementary layer: a product uses UHP to set up, select, and drive a harness, while MCP remains the runtime wire for tools exposed by configured MCP servers.
Not protocols
What is not a protocol: AgentKit, Apps SDK, and AGENTS.md
Some widely searched names are not interoperability protocols and do not belong on this map, even though they appear near it:
- OpenAI AgentKit is a product suite, not a protocol. OpenAI announced in June 2026 that Agent Builder and Evals are being wound down; the Agents SDK remains an SDK for orchestrating agent workflows, not a cross-vendor wire protocol.
- OpenAI Apps SDK, now documented under Plugins: development tooling that uses MCP servers, not a separate protocol.
- AGENTS.md: an open repository format for giving agents project instructions, not a wire protocol.
Together
How these standards compose in one product
In a realistic stack, several of these can operate at once. A product backend may discover, configure, select, and invoke a harness through UHP. MCP server attachments configured through UHP are then used over MCP at runtime, while harness-native tools may use the runtime's own mechanism. The agent may coordinate with independent agents through A2A, and its output may reach a user-facing application through AG-UI. In a physical setting, MHS can provide the underlying device abstraction, reached through MCP, a CLI, or APIs.
Seen this way, the frequent question of which protocol wins is the wrong question. They are layers of one system, and the practical skill is choosing the right one for the edge in front of you.
Choose
Protocol selection checklist
- Connecting an agent to tools and data: use MCP.
- Letting independent agents discover and delegate to each other: use A2A.
- Rendering an agent's work in a user-facing frontend: look at AG-UI and the related UI standards.
- Operating physical devices from an agent: watch MHS, still a research preview.
- Configuring, selecting, invoking, and controlling the harness that runs an agent from a product backend: evaluate UHP and its conformance tooling while accounting for its still-developing ecosystem.
Maturity
Governance and maturity in 2026
Maturity varies widely and should inform how much you build on each. MCP and A2A are established and foundation-governed. AG-UI, A2UI, and MCP Apps are active but cover different UI concerns. MHS is an early, not-yet-open-source research preview. UHP is an open, versioned standard that is still building its ecosystem, with a reference implementation, a local conformance suite, and at least one independent client implementation. Match your commitment to each project's maturity, and revisit the landscape as it changes.
One layer up
Where HarnessRouter sits on this map
HarnessRouter is the world's first unified interface for agent harnesses. A unified interface means one API contract for configuring and running complete agent harnesses: model selection, skills, MCP server attachments, tool restrictions, task execution, streaming, session continuation, and artifact retrieval follow the same contract across every harness on the platform.
That contract is UHP, the configured-harness boundary on this map. HarnessRouter implements and complies with it, and open-sourced a Community Edition server that runs the same harnesses behind the same contract on infrastructure you operate. At Full conformance, a product configures which MCP servers are attached through UHP's harness endpoints; MCP remains the runtime wire when the harness calls tools exposed by those servers, and harness-native tools may use the runtime's own mechanism.
FAQ
AI agent protocols FAQ
What are the main AI agent protocols in 2026?
The most discussed are MCP (runtime capability access), A2A (agent to agent), AG-UI and related UI standards (agent backend to frontend), MHS (software to programmable physical devices), and UHP (product to a configured harness, covering configuration and driving). Their responsibilities commonly compose.
Is MCP an agent-to-agent protocol?
No. MCP connects a single agent to tools, resources, and prompts inside its own loop. Agent-to-agent communication is A2A's boundary. The two are complementary and often used together.
Do MCP and A2A compete?
No. They govern different edges: MCP is agent-to-tools, A2A is agent-to-agent. A system can use both at once, with an agent reaching tools over MCP while delegating to other agents over A2A.
What is the difference between AG-UI and A2UI?
Both touch the frontend, but differently. AG-UI standardizes bidirectional events and state between an agent backend and a user-facing frontend, while A2UI addresses declarative, client-rendered generative UI. They target different slices of the frontend problem.
Did A2A absorb ACP?
IBM's Agent Communication Protocol, an agent-to-agent effort abbreviated ACP, merged into A2A under the Linux Foundation in 2025. A separate, still-active protocol also abbreviated ACP, Zed's Agent Client Protocol for the editor-to-agent edge, is unrelated.
Where does UHP fit in the agent protocol stack?
UHP governs the configured-harness boundary: how a product discovers, configures, selects, and drives a harness, including its model, skills, MCP server attachments, tool restrictions, tasks, sessions, streaming, and files. It composes with MCP, which remains the runtime wire for tools exposed by configured MCP servers, rather than replacing it.
Is OpenAI AgentKit a protocol?
No. AgentKit is product tooling, and the Agents SDK is an SDK, not a cross-vendor wire protocol. The former Apps SDK is now documented under OpenAI Plugins and uses MCP servers. AGENTS.md is an open repository instruction format, not a wire protocol.
Run agents behind one harness contract
Start a task through one API and run complete agent harnesses with sessions, streaming, and artifacts handled the same way across every harness.
Run your first agent free