Google Combines A2UI and MCP to Unify Agent Interfaces

On June 17, Google published a technical post on its official blog that deserves attention for what it signals: the company is building on MCP—Anthropic's Model Context Protocol—to define how user interfaces should look and behave in agentic applications. The post, titled "A2UI + MCP Apps: Combining the best of declarative and custom agentic UIs", proposes a hybrid approach that brings together the best of two worlds: declarative and custom interfaces.

This is significant. Google's adoption of MCP as an interoperability layer—rather than building its own proprietary protocol—strengthens MCP's position as the de facto standard for communication between models and external tools.

What A2UI Is and What Google Proposes

A2UI (Agent-to-UI) is the concept Google introduces to describe how an AI agent can generate or adapt user interfaces dynamically. The core idea is that an agent does not just execute tasks in the background: it can also decide what to show the user and how to show it, based on the conversation context or the current task.

The proposal combines two approaches that have traditionally been separate:

• Declarative interfaces: the agent describes the UI through a structured specification (which components to display, in what order, with what data). The client renders that description. It is predictable, easy to audit, and portable.
• Custom interfaces: the agent calls components already built by the developer, with their own logic and richer visuals. They require more implementation work, but enable more sophisticated experiences.

A2UI + MCP connects both approaches: the agent uses MCP to invoke tools or servers that return both data and rendering instructions. The client can process declarative responses when no custom component exists, and delegate to rich components when they do. The result is a more resilient architecture: agentic applications do not break if a specific component is missing.

Why It Matters for the MCP Ecosystem

Since Anthropic opened MCP as an open standard, the protocol has grown rapidly. Today it is the central mechanism for Claude Code to connect with external servers and forms part of the standard setup in `claude_desktop_config.json`. But until now, MCP was conceived primarily as a tools and data layer, not an interface layer.

Google's entry expands that scope. If MCP can also transport UI instructions, MCP servers become more expressive: they do not just respond with data JSON, but can instruct the client on how to present that information to the user. This opens the door to MCP servers that are, in practice, micro-applications with their own presentation layer.

For teams already working with MCP servers—whether in integrations with Claude or with other compatible models—this means the same infrastructure could support richer interfaces without changing the underlying protocol.

Who This Matters to Right Now

In its current state, the proposal is primarily relevant to three profiles:

1. Developers of MCP servers who want to go beyond returning raw data and start thinking about how their tools are presented to the end user.
2. Teams building agentic clients (interfaces on Claude Code, on Gemini, or on any model compatible with MCP) and need a standardized way to manage the variability of agent responses.
3. Product architects at companies evaluating how to integrate agents into existing workflows without having to redesign the entire UI layer each time the model or tool changes.

What Google describes is not yet a closed specification or mature SDK. It is a technical direction with concrete examples, published openly. We will have to see whether it leads to a formal proposal for extending MCP or remains as a convention specific to their products.

Editorial View

That two of the sector's largest players—Anthropic with MCP and Google with A2UI—are converging rather than fragmenting the ecosystem is a positive signal. That said, the history of standards in AI is short and uneven: it is worth closely monitoring how the implementation evolves before making major bets on this architecture.