# Tour of Agent Protocols: MCP, A2A, AG-UI, A2UI - Mete Atamel - NDC Copenhagen 2026

## Executive summary

The talk provides a deep technical overview of four emerging protocols designed to standardize communication and interaction within complex AI agent systems: Model Context Protocol (MCP), Agent-to-Agent Protocol (A2A), Agent-User Interface Protocol (AG-UI), and Agent-to-UI Protocol (A2UI). These standards address the challenges of building interoperable agents that can access external tools, communicate with other agents across diverse frameworks, and generate rich user interfaces.

## Key takeaways

- MCP Standardizes Tool/Context Access: MCP standardizes how Large Language Models (LLMs) access external functions (tools) and data (resources). Instead of one-to-one integrations, tools are wrapped into MCP servers, which can be accessed by an AI application via an MCP client. This architecture supports local (Standard IO) or remote (streamable HTTP transport) deployments.
- A2A Enables Inter-Agent Communication: A2A is an open protocol defining how agents running on different frameworks communicate. Agents expose their capabilities via a JSON metadata file called the 'agent card,' which details skills (functions), contact methods, and authentication schemes.
- AG-UI Standardizes Agent State Streaming: AG-UI is an event-based protocol designed to standardize how agent backends stream state updates to frontends, connecting the AI logic layer to the user interface.
- A2UI Standardizes Generative UI Output: A2UI is a generative protocol that standardizes how agents generate functional User Interface (UI) components (using JSON structures), moving beyond simple text or data output. It defines core messages like `create surface`, `update components`, and `update data model`.

## Technical details

- Model Context Protocol (MCP): MCP defines three core parts of an MCP server: **Tools** (functions exposed to LLMs, model-controlled), **Resources** (read-only data/config, app-controlled), and **Prompts** (reusable templates guiding how tools and resources should be used). The architecture involves an AI application using one or more MCP clients to communicate with MCP servers.
- A2A Protocol Mechanics: An agent's capabilities are defined by the 'agent card,' which is a JSON metadata published at a well-known URL. The card includes sections for `capabilities` (protocol level contact methods), `skills` (functions/tools available on the remote agent), and authentication schemes.
- A2UI Message Flow: The A2UI protocol uses a sequence of JSON messages to generate UI: 1) `create surface` (initial message), 2) `update components` (defining the structure), 3) `update data model` (filling the data), and 4) `delete surface` (completion).

## Practical implications

- For build engineers managing microservices, MCP provides a standardized way to wrap and expose internal business logic (tools) as services that LLMs can consume, simplifying integration points.
- The ability to deploy both the AI application and the MCP server on Cloud Run allows for unified infrastructure management of agent components.
- A2A simplifies multi-agent system architecture by providing a universal contract (the 'agent card') for agents running across different technology stacks (e.g., ADK, LangChain).
- Understanding these protocols is crucial for designing the middleware layer that connects backend AI logic to frontend user experiences.

## Topics

Agent Protocols, Model Context Protocol (MCP), Agent-to-Agent Communication (A2A), Agent State Streaming (AG-UI), Generative UI (A2UI), Agent Development Kit (ADK), fast-mcp, MCP Inspector, A2A Inspector, Cloud Run

Source: https://www.youtube.com/watch?v=o9DIvmMitlk