KNOWLEDGE · AGENT ARCHITECTURE

AI Agent Protocols Explained: MCP, A2A, AG-UI & A2UI

Four open protocols, four distinct jobs: connect tools, delegate to other agents, stream agent activity to an application and render interactive interfaces.

Evergreen reference · Last technically reviewed: November 15, 2026 · Primary specifications

MCP, A2A, AG-UI and A2UI have similar-sounding names, but they do not solve the same problem. Building dependable agents requires a map of the boundaries between models, tools, other services and users. This guide explains each open standard, compares them with examples, and distinguishes interoperability from the security controls a production application still needs.

Original four-layer AI-agent protocols illustration: MCP, A2A, AG-UI and A2UI
Original AgentenCode cover design, not an official specification diagram.

What are AI agent protocols, and why are there several?

A protocol defines a shared language between software components. Modern agent systems can involve a reasoning model, orchestration, external APIs, separate agents, shared state, a user interface and security controls. Without standard interfaces, every integration tends to become custom glue that is hard to replace, test and secure. Protocols can reduce coupling and make capabilities easier to expose across languages and frameworks.

The four standards in this comparison sit at different boundaries. MCP primarily connects an application to tools and context. A2A connects otherwise independent agent services. AG-UI connects an ongoing agent run to an interactive frontend. A2UI describes a surface the frontend can render. None of them proves that the agent is accurate, secure or authorized; those assurances require separate implementation and measurement.

MCP vs A2A vs AG-UI vs A2UI: The essential comparison

The fastest way to distinguish the four is to identify the parties on either side of the wire. Rather than asking which protocol is best, ask which integration boundary has to be standardized.

ProtocolConnectsCore purposeTypical outputNot a substitute for
MCPAgent host ↔ tool serverExpose tools, resources and promptsTool result, resourceAccess policy and business logic
A2AAgent ↔ independent agentExchange capabilities, tasks and resultsTask status, artifactTrust and tenant isolation
AG-UIAgent runtime ↔ applicationStream state, messages and user interactionsEvents, interruptsBackend authorization
A2UIAgent ↔ UI rendererDescribe allowed interactive componentsCards, forms, listsRenderer security and data limits

These are typical roles, not rigid restrictions or competing product rankings. A simple document assistant might use MCP with a regular chat interface. A complex, multi-service platform may benefit from all four protocols, provided each boundary has a compelling purpose.

MCP: Connecting an agent to tools and context

The Model Context Protocol (MCP) specifies how an application host and its clients communicate with MCP servers. Servers may expose tools for performing actions, resources that provide context, and prompts that supply reusable instruction templates. Examples include searching an internal knowledge base, reading a file or using a controlled business API. Applications remain responsible for choosing which server and tool invocations they permit.

The official July 28, 2026 MCP specification added a stateless core, a formal extensions system and stronger authorization mechanisms. Implementations from earlier eras may still use a handshake or different session behavior. Consequently, compatibility testing must examine the wire protocol and actual SDK versions, not merely an MCP logo. MCP never automatically grants an AI model permission to access every system connected to the host.

A2A: Delegating work between independent agent services

The Agent2Agent protocol (A2A) began at Google and moved to the Linux Foundation. It allows independent agent systems to announce capabilities and exchange tasks without requiring a caller to know their internal prompts, models or tools. An Agent Card advertises a service's interfaces, supported skills and security requirements. A client can discover a suitable service and communicate over a declared endpoint.

A2A models tasks with state transitions, messages and output artifacts. Depending on the declared capabilities, clients can poll for results, subscribe to streamed updates or receive asynchronous push notifications. This is attractive across departmental, vendor or organizational boundaries. It is unnecessary overhead for two simple functions that already share one runtime. Agent Cards are descriptive metadata, not an independently verified certificate of trust or authorization.

AG-UI: Streaming agent activity into a user application

AG-UI (Agent–User Interaction) is an event-oriented protocol linking agent execution to user-facing software. Rather than showing nothing until a model finishes, an application can display message deltas, progress, shared state, subagent activity and opportunities for people to intervene. The stable 1.0 specification announced on September 30, 2026 defines a clearer event contract and schemas that can support interoperable frontend clients.

An agent may issue an interrupt when it needs approval before sending an email. The app shows the request, collects a response and passes the result back to the runtime. AG-UI can also transport tool-related events and metadata. It does not specify the entirety of the app's visual layout. Developers might render events with ordinary React or another UI framework, or combine the event stream with structured UI instructions such as A2UI. Real approval still needs server-side policy enforcement.

A2UI: Rendering interactive agent-generated experiences

A2UI provides structured, declarative descriptions of interfaces an AI agent wants a host application to display. Instead of sending executable HTML or arbitrary JavaScript, an agent can describe an approved component tree: a choice picker, table-like view, confirmation card or form. The host renderer turns that description into trusted native widgets that follow the application's own design and accessibility system.

Google announced A2UI 1.0 on November 11, 2026, including bidirectional function calls, accessibility metadata and renderers on multiple platforms. Component catalogs define what the agent may use. The application still controls data binding, action handlers and permissions. The stable spec does not imply every production renderer has migrated: Google documents some implementations still using version 0.9.1. Always verify an actual renderer's supported wire version.

AG-UI or A2UI? They are different layers

AG-UI answers: How does an agent run exchange ongoing events and interaction state with a frontend? A2UI answers: How can an agent describe a particular interactive view that a frontend may render? The former is about streaming execution, the latter about declarative UI content and allowed components. Their similar names reflect nearby concerns, not interchangeable behavior.

For example, an application might use AG-UI to stream a research agent's status updates and use A2UI to present a review form at the end. But that combination is optional. A2UI may also appear inside MCP Apps, while an AG-UI client might use conventional locally coded components. Supporting either standard does not guarantee plug-and-play interoperability with the other; the integration has to match component schemas, lifecycle semantics and versions.

Reference architecture: How all four protocols can work together

Consider a procurement assistant that helps an employee assess offers. A web application takes the request and displays progress using AG-UI. Its orchestrating agent accesses documents and approved catalog tools via MCP. When a specialist compliance review is needed, it delegates a bounded task through A2A to an independent agent service. The result can be presented as an A2UI-described comparison with a human approval card.

The standards are not four mandatory serial steps. They connect different pairs of components. A specialist A2A agent may use its own MCP tools; an MCP server need not know whether the client uses AG-UI or A2UI. The architecture diagram below illustrates one feasible arrangement, not an official reference deployment from any of the protocol organizations.

Connecting the user app, main agent, specialist agent and MCP servers
Original AgentenCode concept diagram. Click to enlarge.

Practical workflow: Reviewing an invoice with AI agents

An employee asks an assistant to match an invoice to an order. Step 1, input: The app records the request. Step 2, AG-UI: The agent streams progress and announces which stage it is performing. Step 3, MCP: An approved document server reads the invoice while another tool retrieves the purchase order. Step 4, A2A: An independent review service can check discrepancies against an explicit rule set. Step 5, A2UI: The app renders the amounts, evidence, discrepancies and an approval prompt.

Releasing payment is not itself a protocol feature. It is a privileged business action requiring an authenticated operator, server-enforced role checks, a genuine approval and a traceable record. The reviewing agent should receive only the minimum task data it needs, and generated UI controls must never bypass the backend. The example demonstrates how standardized interfaces can support a workflow while responsibility stays with the operating organization.

Invoice review using four complementary agent protocols
Original AgentenCode concept diagram. Click to enlarge.

How to choose the right protocol

Need access to tools or data? Evaluate MCP and the available tool servers. Need autonomous services to exchange tasks? Evaluate A2A, including Agent Cards and lifecycle behavior. Need live execution updates, shared state or pauses in the frontend? AG-UI addresses that interface. Need the agent to generate structured forms or cards? A2UI offers a declarative model, assuming a compatible renderer and a restricted component catalog.

Our dedicated MCP guide and A2A guide explore each protocol in depth. Small applications may be better served by a well-defined existing API rather than another networking layer. Start with real integration boundaries, business responsibilities and access rights; choose the protocol afterward. Standardization should demonstrably reduce coupling, not add complexity for its own sake.

Security: Standards do not replace identity, permissions or oversight

Standardized messages do not automatically prevent prompt injection, tool misuse, exfiltration, deceptive Agent Cards or untrusted output. The agent allowed to read an invoice should not receive the ability to transfer money. A remote A2A participant should not silently inherit access to internal secrets. An A2UI approval card must not execute a server operation just because the user interface displays a button.

Baseline safeguards include least privilege, service identities, narrow OAuth scopes, server-side authorization, per-action approval, egress restrictions, data minimization, rate limits and auditable logs. Use the OWASP agentic security guidance as a threat-modeling starting point. Our AI agent security and human oversight guides explain how these controls fit operational systems.

Trust boundaries from untrusted inputs through policy checks to actions
Original AgentenCode concept diagram. Click to enlarge.

Protocol versions: What 1.0 actually tells you

The reviewed documentation currently includes MCP 2026-07-28, A2A 1.0, AG-UI 1.0 and A2UI 1.0. These are review-date facts, not parts of this evergreen URL or title. Different SDKs and live products may use different revisions. A protocol being labeled stable tells you about a versioned specification, not about your entire deployment's reliability or security.

During migration, check the wire format, SDK, optional capabilities and actual interoperability test results. For example, MCP's 2026 revision changes its state and authorization model, while A2UI 1.0 evolves message field names compared with older versions. AG-UI 1.0 formalizes event schemas. A successful integration plan may need adapters, feature checks and incremental rollouts rather than assuming all vendors switched at once.

Latency, costs and operations: More protocols are not always better

Every boundary can improve modularity and monitoring while introducing more network hops, state transitions and failure modes. MCP calls take time and require permission checks. A2A delegation can involve another service and its queue. AG-UI streams events that an application must process and recover. A2UI renderers need component governance and protocol-version handling. The right outcome is not the greatest number of standards but a reliable, observable end-to-end task.

Measure end-to-end latency, completed tasks, retries, failed authorizations, disconnected clients, UI recovery, human interventions and cost per successful outcome. Teams also need to maintain SDKs, secrets, deployment pipelines and audit trails. Agent evaluations should test actual business tasks rather than only language-model benchmark scores. Protocols do not decide how departments share operational responsibility.

Seven common misconceptions to avoid

First: MCP is not the same thing as a generic REST API. Second: A2A is not necessary for every local helper function. Third: AG-UI is not a synonym for React UI components. Fourth: A2UI does not require executing arbitrary model-generated scripts. Fifth: an Agent Card is not a security certificate. Sixth: showing an approval card is not the same as enforcing authorization. Seventh: an open specification or 1.0 release does not guarantee that every provider supports it.

Most confusion comes from mixing up a protocol, a framework, a product and a security control. Google ADK or LangChain may orchestrate workflows. A product such as OpenBot packages runtime and user interfaces. The protocols describe inter-component messages. A policy engine determines who can do what and when. Evaluating each layer separately makes architecture and provider claims more meaningful.

Developer and enterprise implementation checklist

Draw the components and trust boundaries before writing adapters. Identify confidential data and any systems that an agent could affect. Check supported protocol versions and optional features on both sides. For every privileged tool, define the user, the service identity, the permitted object and the required approval. Plan bounded retries, unique task IDs, rate limits, reconnection and an emergency stop for long-running actions.

Build a small end-to-end test that deliberately triggers an unavailable tool, a denied approval, an unreachable agent and an invalid UI action. Verify that users are informed, unauthorized actions do not run, audit logs are sufficient and the system can recover safely. Compare the cost and reliability of the protocol-based approach with a small conventional API integration. Keep an explicit written rationale for every standard you introduce.

Conclusion: Four protocols, one accountable architecture

MCP, A2A, AG-UI and A2UI are not four competing answers to one question. They connect tools, independent agents, ongoing user interaction and generated UI, respectively. That separation can make complex applications easier to maintain and replace, provided implementations actually interoperate and the boundaries are clear to engineers and users.

For AgentenCode, the central principle is that protocol support is a technical capability, not a trust certification. Good agent architecture makes actions observable, limits access, keeps humans responsible for high-impact decisions and allows risky processes to be stopped. Open standards support these goals; the developer and operator must still implement and verify them.

Frequently asked questions

What is the difference between MCP and A2A?

MCP connects an agent host to tools, prompts and resources; A2A connects independent agent services so they can exchange tasks and results.

What does AG-UI stand for?

AG-UI means Agent–User Interaction, an event-based protocol between an agent runtime and a user-facing application.

What is A2UI used for?

It sends a declarative description of interactive UI components that a host application can render using an approved catalog.

How is AG-UI different from A2UI?

AG-UI concerns ongoing execution events and interactions; A2UI concerns the concrete structure of generated UI. They may be combined but are not substitutes.

Must an AI agent use all four protocols?

No. Select only the interfaces relevant to the architecture. Many agents need tool access without agent-to-agent delegation or generated UI.

What is an A2A Agent Card?

A structured capability and endpoint description of an agent service; it is not independent proof of the service's identity or trustworthiness.

Do these protocols make AI agents automatically secure?

No. Authentication, permissions, scope restrictions, policies, approval and monitoring remain separate operational controls.

Does A2UI let agents execute arbitrary scripts?

The intended design uses declarative component descriptions rendered through allowed host-side components, not arbitrary trusted model-generated JavaScript.

Which versions are current?

At the last review, MCP 2026-07-28, A2A 1.0, AG-UI 1.0 and A2UI 1.0 were documented. Individual implementations may use earlier versions.

Can A2A work without MCP?

Yes. Independent agents can exchange work over A2A even if neither runtime exposes MCP tools.

Official specifications and primary sources

Technically reviewed November 15, 2026. Version information refers to that review date; this article is not an independent security certification.

  1. Model Context Protocol – current official specification
  2. MCP maintainers – changes in the 2026-07-28 specification
  3. Agent2Agent – A2A v1.0 specification
  4. Agent2Agent – official documentation
  5. CopilotKit – AG-UI 1.0 release and event protocol
  6. AG-UI – official documentation
  7. Google Developers – A2UI 1.0 release
  8. A2UI – official component catalog and rendering model
  9. OWASP – agentic application risk guidance

NEWSLETTER · FREE · GERMAN EDITION

More signal. Less AI noise.

Our source-backed German-language digest of major AI developments, agent updates and knowledge articles. The weekly edition is being prepared.

Double opt-in: Subscription starts only after email confirmation. Your details are sent to Brevo when you submit.