Google Cloud Tech
Traditional website navigation is collapsing as users migrate to reasoning engines, forcing enterprises to replace static pages with declarative component catalogs assembled dynamically around explicit visitor intent.
AI-assisted summary of Generative UI for any agent, anywhere: A2UI, AG-UI, MCP Apps, and more — original source. Check the original for full context.
Source published:
Key ideas
- The agentic web is shifting from text chat to generative UI through emerging open standards, including MCP Apps for cross-platform app rendering, AG-UI for frontend-to-agent streaming protocols, and Google's A2UI for declarative UI payloads. (0:13)
- Google's A2UI treats dynamic UI as declarative structured JSON-LD data mapped to client-side component catalogs, enforcing defense-in-depth security against clickjacking and rogue script execution. (12:06)
- Generative user interfaces operate along a three-tier spectrum: controlled UI for pixel-perfect deterministic flows, declarative UI for composable component catalogs, and open-ended sandboxed execution for dynamic generation and MCP tools. (24:16)
- Enterprise case studies show that intent-driven dynamic page generation can replace static website navigation hierarchies, cutting tailored pitch production from six hours of manual PDF authoring down to seconds. (36:03)
Detailed notes
## Background Published on YouTube by Google Cloud Tech on June 25, 2026, this Google Cloud Next 2026 session covers strategies for breaking the "chat wall" through adaptive, generative user interfaces. Featuring presenters Alan Blount, Ido Salomon, Atai Barkai, and Nicolas Le Pallec, the presentation details how protocols such as A2UI, AG-UI, and MCP Apps establish declarative, secure standards for agent-driven design across modern applications.
## TL;DR The speakers demonstrate how interactive generative UI is superseding text-only chat by deconstructing monolithic websites into dynamic, agent-driven components. Ido Salomon explains how MCP Apps standardizes graphical UI extensions across major AI hosts, while Alan Blount introduces Google's A2UI framework, which treats UI as declarative data using client-controlled catalogs to ensure defense-in-depth security. Atai Barkai maps out the AG-UI protocol and CopilotKit's three-part generative spectrum—controlled, declarative, and open-ended sandboxed interfaces—to connect agent backends to any frontend. Finally, Nicolas Le Pallec shows how enterprise architectures can parse multidimensional human intent to assemble tailored, high-converting web layouts in real time.
## Atmosphere & style The session has the energetic, collaborative feel of an industry milestone, flowing seamlessly across platform leads from Google, open-source protocol maintainers, and enterprise agency strategists. The tone balances visionary enthusiasm about dismantling traditional page navigation with rigorous technical precision, anchoring abstract paradigms in code hooks, schema diagrams, and live workflow demonstrations. It feels like an open invitation into an active working group, marked by warm peer rapport and a shared, earnest drive to define foundational web standards for the agentic era.
## Bulletin - [00:13](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=13s) The agentic web is shifting from text chat to generative UI through emerging open standards, including MCP Apps for cross-platform app rendering, AG-UI for frontend-to-agent streaming protocols, and Google's A2UI for declarative UI payloads. - [12:06](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=726s) Google's A2UI treats dynamic UI as declarative structured JSON-LD data mapped to client-side component catalogs, enforcing defense-in-depth security against clickjacking and rogue script execution. - [24:16](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1456s) Generative user interfaces operate along a three-tier spectrum: controlled UI for pixel-perfect deterministic flows, declarative UI for composable component catalogs, and open-ended sandboxed execution for dynamic generation and MCP tools. - [36:03](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=2163s) Enterprise case studies show that intent-driven dynamic page generation can replace static website navigation hierarchies, cutting tailored pitch production from six hours of manual PDF authoring down to seconds.
## Key takeaways - [00:13](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=13s) Text-only chat interfaces are an interim step; future software requires dynamic graphical affordances powered by background agents. - [00:54](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=54s) MCP Apps standardizes rich interactive UI delivery over the Model Context Protocol, enabling host platforms like ChatGPT, Claude, and Gemini to render live client canvases. - [04:13](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=253s) Traditional monolithic websites pack redundant menus for human browsing, whereas agents decompose sites into exact contextual slices based on user intent. - [09:14](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=554s) A2UI separates presentation from agent logic by formatting interface layouts as declarative JSON-LD data payloads transmitted over any transport layer. - [14:55](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=895s) By keeping the client frontend strictly in control of available component catalogs, A2UI defends against data exfiltration, rogue markup, and clickjacking. - [17:15](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1035s) A2UI supports cross-surface rendering across laptops, smartphones, tablets, smart TVs, and wearables, targeting a stable 1.0 LTS release in Q3. - [20:09](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1209s) Agents break the web's 30-year request-response architecture due to long-running streams, mid-run human steering, tool calling, and multimodal voice interactions. - [22:52](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1372s) AG-UI forms the user-facing third leg of the agent connectivity triangle, complementing tool protocols like MCP and agent-to-agent communication networks. - [24:16](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1456s) Controlled generative UI pre-registers concrete components in frameworks like React, delivering deterministic, brand-consistent experiences for core high-traffic flows. - [26:02](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1562s) Declarative generative UI employs modular component catalogs that agents assemble dynamically at runtime, addressing diverse long-tail business queries. - [28:00](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1680s) Open-ended generative UI runs raw generated code or third-party MCP utilities inside sandboxed iframes to display arbitrary tools safely. - [30:40](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1840s) Upstream conversational reasoning engines are replacing traditional website navigation, requiring corporate sites to parse explicit user intent upon arrival. - [33:48](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=2028s) Enterprise systems must deconstruct messy user requests into structured intent objects spanning functional, emotional, and social dimensions. - [33:48](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=2028s) Decoupling intent interpretation, enterprise brain governance, and design system layout assembly prevents unconstrained black-box code generation in corporate environments. - [36:03](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=2163s) Replacing static sales pages with intent-driven dynamic composition eliminated hours of manual PDF collateral prep, serving customized web views instantly.
## Detailed walkthrough ### [00:13](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=13s) Introduction and Moving Beyond Text-Only Interfaces
Alan Blount kicks off the session by welcoming the audience to a collaborative talk focused on generative UI, brought together by partners across several organizations. He acknowledges the shared, growing frustration with text-only chat interfaces and emphasizes the industry's direction: every user interface will soon have AI running behind it, unlocking far more interactive capabilities than walls of text allow. Rather than diving into Google's initiatives right away, Alan immediately passes the stage to Ido Salomon to introduce MCP Apps and lay the groundwork for how agent-driven interfaces are evolving.
[00:54](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=54s) MCP Apps: Bringing Interactive Graphical Interfaces to Agents
Ido Salomon, creator of AgentCraft and co-creator and maintainer of MCP Apps, steps up (after briefly being introduced and joking through a slight name slip). Before jumping into the technical details, he gives a shout-out to the co-creators and contributors who made MCP Apps possible, including Liad, Olivier, Anton, and Nick.
```mermaid flowchart LR accTitle: MCP Apps Request and Response Flow accDescr: An agent queries an MCP server and returns interactive, branded UI components to the client. User["User ('Show me')"] --> Agent["AI Host / Agent"] Agent --> Server["MCP Server / Provider"] Server --> Component["Interactive UI Component"] Component --> Client["Client UI Canvas"] ```
Addressing the core theme, Ido asks what comes next when text falls short. MCP Apps was built as the official UI extension to the Model Context Protocol (MCP). It standardizes both the transmission of rich graphical user interfaces to clients and the underlying communication protocol between clients and their UIs. To illustrate the shift: * In the traditional approach, querying an agent about a sales or marketing funnel prompts the agent to call an analytics provider like PostHog, resulting in a dense, factual wall of text that fails to provide clear insights at a glance. * With MCP Apps support enabled on both the client (such as Claude) and the backend (such as PostHog), a simple prompt like "show me" renders an interactive, branded graphical UI component right inside the chat canvas.
[03:02](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=182s) Bespoke Generative UI and Built-In Interactivity
Beyond rendering predefined dashboards from existing analytics tools, agents must have the creative freedom to construct bespoke UIs on the fly. When a user asks an agent to explain what a funnel is, rather than drafting an essay, the model can dynamically assemble an explanatory diagram and visual workflow.
Crucially, this is not just passive visual presentation. Ido highlights that interactive behavior is deeply embedded directly into the generated component. If a user wants to inspect a specific phase within the generated funnel, they do not need to construct a new prompt or guess what instructions to type next. The model pre-programs interactive actions into the element: clicking "show me" on a particular stage automatically triggers a prompt back to the agent, driving the conversational flow forward and generating the next contextual explanation without friction.
[04:13](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=253s) Deconstructing the Monolithic Web for Agentic Workflows
Zooming out from the immediate technical plumbing, Ido argues that generative UI and MCP Apps represent a fundamental reimagining of how humans interact with the web, rather than just an aesthetic upgrade to chat. On the traditional web, planning an event or a special occasion forces a user to navigate across ten separate, highly complex websites—booking travel, selecting hotels, and ordering flowers individually. These websites are deliberately dense and convoluted because they are designed for human browsing; unable to know a specific user's exact intent, site designers pack every conceivable action and button onto a single screen.
Agents, by contrast, operate with precise knowledge of user intent. They can decompose those monolithic destinations, extract only the required slice of functionality—a single map view, a specific date picker, or a targeted checkout button—and assemble an ad-hoc, end-to-end flow directly within the conversation.
[06:14](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=374s) The UI Spectrum and the Agent Distribution Surface
Ido outlines a three-part spectrum of agent interfaces: 1. **Predefined UI**: Traditional standalone app views and components served directly from platforms (e.g., PostHog). 2. **Declarative UI**: Experiences where the agent describes the semantic components it needs, leaving layout and design rendering to the host system. 3. **Generative UI**: Bespoke interfaces generated from scratch, where the model streams raw HTML and markup directly into the canvas.
MCP Apps is entirely agnostic to what is being rendered, making it uniquely interoperable. Frameworks like A2UI and AG-UI can run inside an MCP App container, or an MCP App can serve as a component rendered by those protocols.
Major host environments—including OpenAI's ChatGPT, Anthropic's Claude, and Google's Gemini—have adopted MCP Apps. ChatGPT alone hosts over 500 apps from enterprise brands like Walmart and Salesforce. Highlighting the scale of this paradigm shift, Ido notes that ChatGPT commands one billion weekly active users—roughly 12% of the world's population—representing over 160 times the audience the Apple App Store had at its launch. He challenges developers to rethink their core product architecture:
> “The question that you need to ask yourself now isn't why you need to develop an app. Why do you need to get your product ready for the gigantic web. It's what happens when users stop being the people that see my website. It suddenly becomes agents.” — Ido Salomon
Rather than building monolithic web destinations, teams must decompose their products into interconnected, agent-ready endpoints that can be authored once and deployed anywhere.
[09:14](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=554s) Introducing A2UI: Architecture, Message Passing, and Remote Agents
Alan Blount returns to introduce A2UI (Agent-to-User Interface). Alan shares his background—20 years as a full-stack web application developer, followed by machine learning work in Google Cloud, and now building Google's agent platforms. The A2UI project represents a hybrid effort incorporating contributions developed over more than two years.
```mermaid flowchart TD accTitle: A2UI Communication Across Frontends and Remote Agents accDescr: Shows how A2UI messages pass from remote or local backend agents through an orchestrator to the frontend design system. subgraph Client["Frontend Client"] DS["Design System / UI"] end subgraph Orchestration["Application Backend"] BE["Backend Server / Orchestrator"] LA["Local Sub-Agents"] end subgraph External["Remote Mesh"] RA["Remote Agents"] end
DS <-->|"Any Transport (REST, WS, AG-UI, MCP)"| BE BE <--> LA BE <-->|"Secure A2UI Message Payload"| RA ```
A2UI targets three fundamental challenges in agent ecosystems: * Enabling clean communication when remote agents or meshes of distributed agents interact with an application. * Achieving true, dynamic generative UI. * Delivering these generative interfaces safely to end users across diverse platforms.
Alan maps out the architecture using a frontend design system connected to a standard backend. While local subagents attached directly to an application's server represent a straightforward path, remote agents introduce major security and identity hurdles, including complex access control lists (ACLs) and cross-boundary permissions.
To overcome this, A2UI treats user interfaces strictly as structured, declarative data. By turning UI into data payloads, message passing across remote orchestrators becomes simple and safe. Furthermore, the transport layer remains completely agnostic: A2UI payloads can travel over standard REST APIs, WebSockets, AG-UI, or MCP. Remote agents simply emit standard A2UI messages, and the central orchestrator passes those payloads straight through to the frontend design system for secure rendering.
[12:06](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=726s) Declarative UI via Structured Output and Catalogs
Alan Blount describes alternative agent topologies, pointing out that an orchestrator can intercept, manipulate, or mutate an outgoing message if a remote agent does not natively generate an A2UI payload. Rather than relying on tool calling, A2UI operates on direct structured output using JSON-LD. Blount emphasizes that JSON-LD was chosen pragmatically because virtually all contemporary large language models handle JSON proficiently. While other declarative UI formats exist and the architecture could evolve in the future, JSON-LD solved the immediate requirement for constructing component layouts.
```mermaid flowchart LR accTitle: A2UI Pipeline Flow accDescr: LLM outputs JSON-LD into surfaces which hydrate frontend catalogs and render via streaming. subgraph Agent ["Agent Core"] A["LLM Output<br/>(JSON-LD)"] end subgraph Layout ["UI Layout"] B["Widget / Surface<br/>Assembly"] C["State & Variable<br/>Hydration"] end subgraph Client ["Client Device"] D["Custom Component<br/>Catalog"] E["Streaming UI<br/>Render"] end
A --> B B --> C C --> D D --> E ```
Within this pipeline, the model aggregates one or more existing components into what the team terms a "surface" or "widget layout," then populates and hydrates the designated variables. Transmitted as streaming message chunks, this architecture enables an exceptionally responsive user experience. Blount highlights a favorite design pattern: cacheable, configurable interfaces where the entire application UI is pre-configured, yet remains fully mutable on the fly through natural language agent interactions—such as having the agent adjust a button or eliminate interface elements the user never employs.
- **Component Catalog Contracts:** Teams define custom component catalogs that establish a strict contract between the client frontend and back-end agents; the back end is only permitted to invoke the components explicitly advertised by the client. - **Preserving Existing Design Systems:** Organizations are not required to adopt brand-new UI stacks: “You already have a design system. You already have a front end. You don't need to change that,” Blount reiterates, noting support for existing libraries such as Material Design. - **Terminology Evolution:** The team formally renamed their baseline component offering from "standard" to "basic" to eliminate confusion for developers bringing their own design systems.
---
[14:55](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=895s) Cross-Surface Ambitions and Defense-in-Depth Security
While most enterprise users interact via web browsers on laptops, Blount stresses that modern workflows constantly transition between laptops, mobile phones during meetings, tablets, smart TVs, and smartwatches. A2UI is engineered from the ground up to support this device heterogeneity without locking rendering into the web DOM. Several enterprise customers with proprietary rendering pipelines and custom hardware interfaces are actively collaborating on using A2UI as a general declarative UI standard.
Blount outlines how this decoupled architecture inherently enforces UI security through defense in depth:
```mermaid flowchart TD accTitle: A2UI Defense-in-Depth UI Security Architecture accDescr: Client catalog boundaries isolate and secure components from agent execution. subgraph AgentBoundary ["Agent / Back-End Execution"] A["Agent Data Payload"] end
subgraph ClientBoundary ["Client Runtime Boundary"] B["Client Catalog Filter"] C["Decoupled Data Hydration"] D["Strict Native Component Rendering"] end
A --> B B --> C C --> D ```
Because the frontend client exercises strict ownership over the component catalog, teams eliminate classic generative vulnerabilities such as data exfiltration via rogue image tags, hidden form fields embedded within malicious click targets, and third-party UI supply-chain attacks. Blount emphasizes that agent constraints must start at the boundary: “The client is in charge of what components are available.”
- **Cross-Platform Target Devices:** Laptops, phones, tablets, television interfaces, and wearable watches. - **Security Defenses:** Controlled component rendering prevents malicious data exfiltration, mitigates clickjacking via hidden forms, and insulates applications from supply-chain compromises. - **Main Architectural Principle:** Defense in depth achieved by decoupling raw data values from native, client-controlled presentation components.
---
[17:15](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1035s) Current Ecosystem, Production Launches, and the 1.0 Roadmap
A2UI provides core plumbing libraries, message-passing protocols, real-time repair tooling for malformed generations, and specialized client renderers. Supported rendering libraries include Web Components (Lit), Angular, React, and Flutter, with direct contributions from their respective core maintainers alongside community implementations.
In production, A2UI is already deployed across Gemini Enterprise, Opal, and numerous internal Google tools, with experimental initiatives mixing Model Context Protocol (MCP) apps with dynamically generated A2UI widgets. Blount acknowledges that while current demos may look simple, the production utility of streaming actionable interactive affordances is monumental.
Regarding the future roadmap, the team is prioritizing stability and enterprise readiness over adding endless prototypes. A major milestone is bringing the core infrastructure into a formal 1.0 Long Term Support (LTS) release targeted for Q3, following developer experience refinements introduced in the 0.9 release:
> “I really want this to get to a 1.0 release this year so that we can have long term support and feel very consistent and stable on it.” — Alan Blount
---
[20:09](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1209s) CopilotKit, AG-UI, and Breaking the Request-Response Paradigm
Alan Blount introduces Atai Barkai, co-founder and CEO of CopilotKit, to introduce the AG-UI protocol. Barkai explains that CopilotKit focuses on building developer infrastructure specifically for "copilots"—human-in-the-loop, user-interactive agents—distinguishing them from entirely autonomous background agents. CopilotKit connects agentic backends directly to user-facing applications, powering tens of millions of user-agent interactions weekly across organizations including Cisco, DocuSign, Function Health, Deutsche Telekom, and the majority of both the Global 50 and Fortune 500.
CopilotKit also spearheaded the open AG-UI protocol, originating from collaborations with LangChain and CrewAI, which has seen adoption across Google, Amazon, Microsoft, Oracle, Mastra, Pydantic, and AG2. Barkai outlines the guiding thesis for this architecture: “We believe over the next few years all UI will be AI, which means that over the next few years, all interactions between people and technology are going to become increasingly mediated by agentic systems.”
Barkai illustrates this shift with both enterprise and everyday examples, from complex productivity tools like HubSpot, Figma, Cursor, and Cloud Code, to smart appliances: an electronics manufacturer approached them about embedding conversational agency into refrigerators so users can effortlessly say, "order the ingredients that are missing to make lasagna tonight."
```mermaid flowchart TD accTitle: The Agentic Protocol Paradigm Shift accDescr: Contrasting traditional request-response web requests with multi-modal streaming agent flows. subgraph Traditional ["Traditional 30-Year Web Paradigm"] Req["Client Request"] --> Res["Server Response"] end
subgraph Agentic ["User-Interactive Agentic Paradigm"] Stream["Long-Running Bi-directional Streams"] MidRun["Mid-Run Steering & Reconnections"] Hybrid["Structured Tool Calls + Unstructured State Updates"] Modal["Concurrent Text & Voice Modalities"] end ```
The friction in building user-interactive agents stems from a deep architectural incompatibility: “Many of you audience probably know that building great user interactive agents is very difficult. And the core reason is that agents break the request-response paradigm that's been powering the internet for the last 30 years.” Because software agents are long-running, maintain continuous streaming, require mid-run steering, handle sudden network reconnections, and simultaneously process unstructured text, structured tool calls, state synchronizations, and multimodal voice streams, existing RESTful web foundations prove wholly inadequate without a unified protocol layer.
[22:52](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1372s) CopilotKit, AG-UI, and Connecting Agents to Frontends
Atai Barkai introduces the mission behind CopilotKit and AG-UI, addressing the persistent hurdles developers face when building generative user interfaces. Traditional software paradigms retrofit interfaces from familiar request-response mechanics, but generative applications demand an entirely different approach optimized for agentic workflows. CopilotKit addresses this by offering open-source developer SDKs paired with a self-hostable cloud backend. Alongside it, the AG-UI (Agent User Interaction) protocol serves as a standard enabling agentic frameworks and harnesses to bridge their backends to arbitrary custom frontends without rewriting integration logic.
Barkai visualizes the emerging agentic ecosystem as an interconnected triangle. Model Context Protocol (MCP) occupies one edge, linking agents out to tools and external context. Agent-to-agent protocols handle communication between distinct autonomous systems. AG-UI represents the crucial third leg of this triangle, anchoring agents directly to user-facing applications. While AG-UI started with a primary focus on the web, its coverage has broadened rapidly to encompass platforms such as Slack, WhatsApp, mobile applications, and other interactive client endpoints. Atai pauses briefly on an architectural overview slide, inviting attendees to snap a picture and ask follow-up questions afterward.
```mermaid flowchart TD accTitle: The Agent Connectivity Triangle accDescr: Diagram showing how MCP, A2A, and AG-UI form a three-legged ecosystem linking tools, agents, and user frontends.
Agent["Agentic Core System"]
subgraph Triangle["Ecosystem Protocols"] direction TB MCP["MCP<br/>(Tools & Context)"] A2A["Agent-to-Agent<br/>(System Interop)"] AGUI["AG-UI Protocol<br/>(User Interfaces)"] end
subgraph Frontends["User Surfaces"] Web["Web Apps"] Mobile["Mobile Apps"] Chat["Slack / WhatsApp"] end
Agent --> MCP Agent --> A2A Agent --> AGUI AGUI --> Web AGUI --> Mobile AGUI --> Chat ```
- CopilotKit delivers open-source SDKs and self-hostable infrastructure built natively for agentic loops rather than legacy request-response patterns. - “AG-UI is the third leg of this triangle connects your agents to user facing services,” Atai Barkai points out when mapping out how MCP, agent-to-agent architectures, and AG-UI complement one another.
---
[24:16](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1456s) Pillar 1: Controlled Generative UI and Pixel-Perfect Surfaces
Reflecting on collaborations with industry leaders over the past several years, Barkai emphasizes that no single generative UI paradigm fits all enterprise requirements. Generative user interfaces exist along a broad continuum ranging from tightly controlled, deterministic designs to completely open-ended rendering. AG-UI intentionally spans this complete range, allowing developers to pick the appropriate mechanism for any given scenario. Barkai breaks down this continuum into three core pillars: controlled, declarative, and open-ended generative UI.
The first pillar is controlled generative UI. Under this model, engineers pre-build and register concrete components that an agent invokes on demand. In a code demonstration, Barkai shows a React hook (`useComponent`) defining explicit input parameters, a component purpose description, and a dedicated renderer—such as a pie chart. When a user asks for revenue split by category, the interface bypasses dense textual responses to instantly render the interactive pie chart. While Barkai acknowledges that pre-built elements might feel like the most conservative tier of the spectrum, they offer unmatched advantages in fidelity and reliability.
- Developers retain total authority over styling, layout, and component state by pre-registering renderers in frameworks like React. - High-visibility workflows, such as an airline displaying real-time flight cards, require guaranteed determinism and pixel-perfect brand alignment. - “To some extent controlled generative UI is the most boring part of this spectrum, but it does give you pixel perfect designs and maximal determinism, which makes it a really great fit for the few most used surfaces in your applications,” notes Atai Barkai.
---
[26:02](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1562s) Pillar 2: Declarative Generative UI and Component Catalogs
The second pillar represents declarative generative UI, the core domain of A2UI. In this pattern, software teams do not code static single-purpose views; instead, they publish a component catalog of composable, LEGO-like building blocks that the agent dynamically assembles at runtime to satisfy nuanced user prompts. Barkai displays an interactive sales dashboard demo where a user asks for revenue figures paired with customer churn metrics. Rather than producing text, the agent dynamically bundles independent cards, headers, pie charts, and bar charts into a cohesive single dashboard view tailored on the fly to that specific query.
Implementing this requires setting up catalog definitions detailing what each element is and what arguments it accepts, alongside corresponding catalog renderers (such as React components). The protocol's middleware layer takes care of the internal state handshakes between AG-UI and A2UI, insulating developers from synchronization and transport complexities. Teams deliberately trade away some rigid pixel-level perfection and total determinism, because components are arranged dynamically. In return, they achieve massive breadth: a one-time catalog definition can power an infinite variety of tailored dashboard configurations, making it exceptionally well-suited for long-tail enterprise applications where engineering efficiency is paramount.
| Spectrum Pillar | Determinism & Styling | Assembly Mechanism | Best-Fit Use Cases | |:--- |:--- |:--- |:--- | | **Controlled UI** | Pixel-perfect, maximum determinism | Pre-built components invoked directly by agent tools | Primary, high-traffic user journeys (e.g., flight status cards) | | **Declarative UI** | High brand consistency, dynamic layout | LEGO-style component catalogs assembled on demand by agent | Long-tail consumer queries and internal enterprise dashboards | | **Open-Ended UI** | Variable fidelity, open-ended | Live HTML rendering or external app embedding in sandboxed iframes | Third-party extensions (MCP Apps) and hyper-custom dynamic tools |
- Teams author component catalogs once, detailing available props and layouts, which agents compose dynamically to meet arbitrary prompt requirements. - The AG-UI and A2UI middleware handshake automatically coordinates schema parsing and visual rendering without requiring custom agent backend pipelines. - “With declarative UI you're giving up some pixel perfect perfection... but what you get in return is very broad support for different user queries with a one time definition of a component catalog,” Atai Barkai explains.
---
[28:00](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1680s) Pillar 3: Open-Ended Generative UI and Sandboxed Execution
At the far end of the continuum sits open-ended generative UI, where systems discard build-time layout constraints to allow agents to render entirely arbitrary content. This tier divides into two primary modalities: MCP Apps and live-generated HTML sandboxes. MCP Apps are optimized for pulling third-party interactive utilities—frequently built for super hosts like ChatGPT, Claude, and Cursor—directly into custom host applications. The second modality allows the agent to write and execute raw, customized HTML and JavaScript on the fly within an isolated, secure iframe sandbox.
Barkai demonstrates this dynamic execution through an agent that synthesizes a fully operational, highly specialized custom calculator from scratch based on idiosyncratic user specifications. While this process is slower to generate and less deterministic than pre-compiled components, it yields fully functioning, interactive mini-applications that designers could never have anticipated ahead of time. Under AG-UI, developers can toggle between third-party MCP apps and full open-ended generation by adjusting configuration flags or passing target application URLs, without restructuring their underlying backend agent systems. Concluding his segment, Barkai shares his email (`atai@copilotkit.ai`), points attendees to a hallway demo and a specialized Google Cloud Next onboarding offering, and introduces Nicolas Le Pallec from AKQA.
- Open-ended generative UI relies on sandboxed iframe isolation to preserve client-side security while executing agent-generated scripts and HTML. - MCP Apps provide ready-made bridges to third-party tools originally architected for major AI platforms without bespoke integration overhead. - “With open ended generative UI, you're opening the door for the agent to display anything at all,” states Atai Barkai.
---
[30:40](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1840s) Nicolas Le Pallec on the Collapse of Navigation and Structured Intent
Nicolas Le Pallec, CTO EMEA at AKQA (part of WPP), takes the stage to explain why global brands and Fortune 500 enterprises must urgently embrace generative UI. He contends that digital interaction is undergoing a seismic, structural shift away from traditional website mechanics. For decades, online experiences were engineered almost exclusively around hierarchical navigation and browsing across static pages, forcing analytics engines to passively infer customer desire based on clicks and page views. Today, discovery happens upstream within conversational reasoning engines like ChatGPT and Gemini. When consumers arrive at a company website, they arrive with a well-formed objective; if the page fails to immediately adapt to that objective, visitors abandon it and return to their AI assistants.
To survive in this emerging "intent economy," enterprise systems must treat explicit intent as their primary signal, deploy modular frontends that assemble adaptively, and rebuild digital trust by responding to stated needs rather than relying on covert tracking. However, raw human intent is messy, emotional, and unstructured, making it difficult for enterprise logic to process. To bridge this gap, Le Pallec revisits the classic "Jobs to Be Done" framework developed in the 1990s, categorizing intent into three distinct dimensions: functional requirements (the product, size, or color), emotional drivers (perceived risk, confidence levels, and urgency), and social dynamics (peer perception, company politics, and workplace pressure). To illustrate how enterprises can extract and operationalize these multi-dimensional signals, Le Pallec introduces a real-world case study centered on "Synthesis," a payments-level fraud detection platform built for banks, fintechs, and e-commerce merchants.
- Modern users conduct preliminary research inside LLM platforms and land on enterprise domains with specific, pre-formulated goals. - Websites can no longer rely on static content hierarchies; they must shift from inferring behavior to directly serving explicit human intent. - “For the past 20 decades, we have built websites which were optimized around navigation,” Nicolas Le Pallec argues, highlighting how browsing is rapidly giving way to intent-driven interaction. - “Human intent is rich, it's messy. It's nuanced. Enterprises can't work with messy elements like that. So we need structured intent,” Le Pallec notes while breaking down the functional, emotional, and social facets of user decisions.
[33:48](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=2028s) From Visitor Intent to Real-Time Dynamic Interface Architecture
Nicolas Le Pallec illustrates how generative UI moves beyond simple text interactions by analyzing real-world visitor intent. In the example presented, a new security officer at a startup navigates recent spikes in cross-border payment fraud. A Gemini agent deconstructs the visitor's initial prompt into multiple operational dimensions: functional, personal, emotional, and social. Functionally, the user is looking for a robust fraud detection solution. Emotionally, the user needs reassurance and confidence in their decision. Socially, there is significant leadership pressure to make the right choice quickly. The system encapsulates these signals into a unified "intent object," which establishes the appropriate product matching, determines the precise tone of voice needed to communicate with that user, and dictates the experience design.
```mermaid flowchart TD accTitle: Intent to Generative Interface Pipeline accDescr: Three-stage architecture flowing from user intent deconstruction to enterprise brain governance, ending in design system layout assembly.
subgraph Interpret ["1. Interpretation Layer"] UI["User Intent Input"] --> Gemini["Gemini Agent"] Gemini --> Obj["Structured Intent Object<br/>(Functional, Emotional, Social)"] end
subgraph BrainLayer ["2. Brain / Knowledge Layer"] Obj --> Brain["Enterprise Brain"] VDB[("Vector DB<br/>Product Data")] --> Brain KG[("Knowledge Graph<br/>Enterprise Context")] --> Brain Comp["Compliance & Legal Layer"] --> Brain Brain --> ValidContent["Validated Content Object"] end
subgraph GenUI ["3. Generative Interface Layer"] ValidContent --> Assembler["Layout Assembler"] DS["Enterprise Design System<br/>(Components & Constraints)"] --> Assembler Assembler --> LivePage["Dynamic Tailored Webpage"] end ```
To transform that intent into a visual interface, Nicolas Le Pallec breaks the pipeline down into three decoupled stages: the interpretation layer, the enterprise brain, and the generative interface layer. The interpretation layer parses and categorizes incoming raw intent. That intent is handed off to the enterprise brain, which houses all product and brand data alongside governance and compliance rules. Finally, the generated, validated content object reaches the generative interface layer, which selects pre-built components from the enterprise design system and dynamically assembles the interface layout on the fly. Emphasizing why this strict separation of concerns matters for enterprise systems, Nicolas Le Pallec argues: “We don't want to be an agent in a black box where everything is controlled in prompt.”
- The enterprise brain combines a vector database storing product data with a knowledge graph that models complex enterprise relationships and contexts. - A dedicated compliance and legal validation layer checks all content before it reaches the rendering engine to prevent unauthorized claims. - The generative interface layer never generates unconstrained raw HTML/CSS from scratch; it works strictly within established design system constraints to preserve brand consistency and visual integrity.
---
[36:03](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=2163s) Live Demos: Tailoring Experiences to Different User Pressures
Nicolas Le Pallec demonstrates this architecture in action on a mock homepage for a company named Synthesis. A standard visitor sees a traditional homepage highlighting product features and value propositions (USPs). However, an intent input field pinned at the top allows users to state their exact goal. In the first scenario, a visitor enters an intent asking how to improve fraud detection without hurting user conversion rates. The system triggers the interpretation and brain layers, instantly generating an entirely bespoke solution page. The content is rewritten specifically for conversion-conscious security buyers, pulling exact ROI statistics, fraud detection product overviews, and contextual customer quotes out of the design system components.
A second test run highlights how dramatically the output shifts when emotional and social pressures change. A different user enters a high-urgency query seeking to stop an active spike in fraud within weeks rather than months. Recognizing the acute urgency and emotional distress, the engine shifts away from a long, comprehensive product explanation. Instead, it constructs a compact, high-impact page focused entirely on driving the user directly toward the next best action.
```mermaid flowchart LR accTitle: Comparative Intent-Driven Rendering accDescr: Two divergent visitor intents resulting in completely different dynamically assembled interface layouts.
subgraph IntentA ["Low Urgency / Evaluative Intent"] IA["'Improve fraud detection without hurting conversion'"] --> ResA["Detailed Solution Page<br/>• Specific conversion ROI stats<br/>• Relevant customer testimonials<br/>• In-depth component breakdowns"] end
subgraph IntentB ["High Urgency / Crisis Intent"] IB["'Fix fraud spike in weeks, not months'"] --> ResB["Streamlined Action Layout<br/>• Immediate response plan<br/>• Next-best action callouts<br/>• Zero extraneous marketing fluff"] end ```
The business impact of dynamic assembly is substantial. Nicolas Le Pallec notes that the enterprise partner testing this platform previously produced bespoke pitches and collateral as manual human-compiled PDFs, a workflow that took upwards of six hours per inquiry. With intent-driven generative UI, hyper-personalized pages are generated in seconds directly inside the browser. Quoting the customer's reaction to this operational shift, Nicolas Le Pallec shares: “We're no longer spending hours preparing responses. We can focus on the strategy discussion from the start.” Looking toward the immediate horizon of agentic interfaces, he concludes: “Static pages needs to become dynamic system. So as enterprises for the next web experiences, you need systems that understand reason and Compose in real time.”
- Turnaround time for producing tailored collateral dropped from more than six hours of manual human PDF drafting down to mere seconds directly on the web. - Manual design and custom copywriting overhead for prospective leads was completely eliminated. - Navigational paradigms across corporate web properties are inverted: user intent replaces rigid static site menus and pre-baked informational funnels.
---
[39:20](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=2360s) Closing Remarks and Community Collaboration for 2026
Alan Blount returns to wrap up the session, expressing deep gratitude to his co-presenters, the engineering teams behind the tools, and the audience. He underscores that while generative UI frameworks—such as A2UI, AG-UI, and MCP Apps—are pioneering foundational standards, establishing the future web architecture requires open, community-wide collaboration across developer ecosystems. He points out: “We are working on things that are new and we're coming up with really good foundational technologies and capabilities ourselves, but we're doing it together to build the new versions of the web.”
Alan Blount displays an on-screen QR code pointing to an anonymous feedback form, inviting attendees and remote viewers to shape the generative UI roadmap for 2026. The cross-team working group meets at least monthly—and often significantly more frequently—to iterate on interoperability standards across agent platforms, client frontends, and protocol layers. Alan Blount urges participants to share their exact needs and enterprise friction points, whether through the form or by talking to the team directly in the hallway after the presentation, reiterating in his closing sentence: “We are all in this together.”
- The feedback form is anonymous, with an optional field for contact details, designed to solicit community priorities for 2026 Generative UI projects. - Core maintainers and partner teams (spanning Google, CopilotKit, and MCP Apps) maintain a recurring cross-organizational cadence, meeting at least monthly to advance protocol standards. - Attendees are invited to engage directly in hallway discussions immediately following the session to discuss integration challenges and use cases.
## Notable quotes > [20:09](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1209s) We believe over the next few years all UI will be AI, which means that over the next few years, all interactions between people and technology are going to become increasingly mediated by agentic systems. — Atai Barkai
> [26:02](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1562s) With declarative UI you're giving up some pixel perfect perfection... but what you get in return is very broad support for different user queries with a one time definition of a component catalog — Atai Barkai
> [24:16](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1456s) To some extent controlled generative UI is the most boring part of this spectrum, but it does give you pixel perfect designs and maximal determinism, which makes it a really great fit for the few most used surfaces in your applications — Atai Barkai
> [30:40](https://www.youtube.com/watch?v=UsMDkEsR-ok&t=1840s) Human intent is rich, it's messy. It's nuanced. Enterprises can't work with messy elements like that. So we need structured intent — Nicolas Le Pallec
## Mentioned Alan Blount, Atai Barkai, Ido Salomon, Nicolas Le Pallec, A2UI, AG-UI, MCP Apps, Model Context Protocol, CopilotKit, AKQA, WPP, AgentCraft, PostHog, ChatGPT, Claude, Gemini, Gemini Enterprise, Opal, Google Cloud, Google Search, Anthropic, OpenAI, Walmart, Salesforce, Cisco, DocuSign, Function Health, Deutsche Telekom, LangChain, CrewAI, Mastra, Pydantic, AG2, HubSpot, Figma, Cursor, Cloud Code, Lit, Angular, React, Flutter, Material Design, JSON-LD, Synthesis
## Video description The future of the web isn’t just interactive – it’s adaptive. Break the “chat wall” with agents that customize UIs for any context. Join the core teams behind A2UI, a native-first standard that treats UI as declarative data for ultimate security and performance, establishing your design system as the “trust catalog.” This session also features CopilotKit’s CEO discussing AG-UI, which connects all frontends and agent backends, and one of MCP Apps’ co-creators promoting agent UI standardization everywhere. Learn when to choose which approach for brand-consistent, agent-driven, and agent-generated design. Discover how this powers Gemini Enterprise, Google Search, and the future of the agentic web.
Watch more Google Cloud Next 2026 Sessions → https://goo.gle/gcloud-next-2026 Subscribe to Google Cloud Tech → https://goo.gle/GoogleCloudTech
Speakers: Alan Blount, Atai Barkai, Ido Salomon, Nicolas Le Pallec
BRK2-094 #GoogleCloudNext
[Source](https://www.youtube.com/watch?v=UsMDkEsR-ok)