Google on October 29, 2026 published a joint guide with CopilotKit setting out how AI agents can answer people with working interfaces - selectable lists, date pickers, maps and booking forms - instead of paragraphs of text. The post on the Google Developers Blog, credited to the Google A2UI Team and CopilotKit chief executive Atai Barkai, pairs A2UI, Google's open standard for describing an interface as data, with CopilotKit's agent-integration stack, which carries those descriptions to an application over a second open protocol called AG-UI. An agent can only assemble components the application has registered in advance, a design Google presents as the core of its security model. The guide gives no adoption figures, names no production deployment of A2UI and does not mention advertising.

In Short

Google and a start-up called CopilotKit showed developers how to make AI assistants reply with buttons, lists and maps instead of long blocks of text. This matters to any brand or publisher that runs an assistant in its own app or site, because the agent can only build screens from parts the app approved beforehand, which keeps the result looking like the brand rather than like the AI. Nothing changes for advertising yet: none of the material says anything about ads, measurement or sponsored placements.

A tutorial, not a product launch

The post is filed under How-To Guides, Best Practices and Learn, and it reads as a walkthrough rather than an announcement. It opens with a travel exchange that, in Google's account, captures how most agent conversations looked until recently:

User: "Find me a holiday package to Bali in March."
Agent: (six packages in prose, each with dates, hotel, flights, price)
User: "The five-night one with breakfast."
Agent: "Here's the link. You can book it on the operator's site."

"Agents could plan the trip, but everything came back as walls of text," according to the post. They had "no standard way to render a selectable list of packages, a map of the destinations, or a date picker to carry you through the rest of the booking, inside the conversation itself."

The authors define the fix in one line. "Generative UI is the layer that lets agents build interfaces at runtime, shaped by what each request needs," the post states. Building it, they argue, "takes two pieces: a way to describe the UI and an agentic stack that connects your agent to your application and renders that UI." A2UI supplies the first piece. CopilotKit, which integrates with agent frameworks including LangChain, AWS Strands and Google's Agent Development Kit (ADK), supplies the second, along with a chat surface, a runtime and A2UI renderers for React and Angular. CopilotKit also offers its own A2UI renderers for Vue and Slack, according to the post.

What the guide does not do is date A2UI itself. The project's site lists four versions of the specification, the oldest marked "Legacy," but gives no release dates for any of them.

Between templates and model-written code

Google places generative UI on a spectrum. At one end, developers build every component ahead of time, and the agent only picks which one to show and with what data. "It's brand-safe but it does not allow for deep customization and personalization based on the user's intent," the post says. At the other end, the agent returns "a raw UI program written in HTML, Javascript and/or Dart that renders inside a sandboxed iframe." That handles cases nobody planned for, according to Google, "at the cost of a surface that drifts from your design system and executes code a model wrote."

Google's own consumer products have leaned toward the open end. When Gemini 3 arrived on November 18, 2025, Google introduced generative UI that lets the model create web pages, games, tools and applications, including a Gemini app experiment called dynamic view that designs and codes custom interfaces in real time, and AI Mode features for Google AI Pro and Ultra subscribers in the United States. By December, Google was writing code for simulations, visualizations and widgets that run directly inside search results, among them a mortgage calculator with sliders for loan amount, interest rate and term. Anthropic took a similar path in June 2025, when Claude artifacts began turning Claude-written code into working React applications.

A2UI, by Google's description, "works through the entire spectrum." It can take part in controlled generation with decision models, a subject covered in a separate Google Developers Blog post from October 27 titled "Fast, reliable A2UI, with swappable inference formats," and in open-ended code generation that outputs A2UI messages. But one mode dominates. "The declarative mode, where agents assemble pre-declared components and functions, is the most popular," according to the post, which offers no usage figures to support the ranking.

How A2UI describes an interface

Catalogs instead of code

The A2UI site frames the problem as a question: "how can AI agents safely send rich UIs across trust boundaries?" Its answer is that agents never send code at all. They send "declarative component descriptions that clients render using their own native widgets," and the site likens the arrangement to "having agents speak a universal UI language."

Security is the first of three properties the Google post lists. "A2UI is a declarative data format rather than executable code. The client keeps a catalog of trusted components, so anything the agent invents outside that set is caught before it reaches the screen," it states. The A2UI site goes further, saying agents "can only use pre-approved components from your catalog," which it presents as a defence against "UI injection attacks."

A2UI comes with a Basic Catalog, which "ships 18 general-purpose primitives across layout, display, input, and containers," according to Google. From those 18 pieces, an agent can compose a flight comparison, a booking form and a confirmation screen, all of which the post uses as illustrations. The set is small by design. "The Basic Catalog is deliberately sparse, so most production apps define their own custom catalog," the post says, adding that a custom component "can be anything your frontend already renders, including a live map the agent fills with coordinates while your renderer draws the route." Its example is a route from San Francisco to Daly City drawn on an interactive map.

Flat JSON, streamed piece by piece

The second property concerns how large language models produce the payload. "The payload is a flat list of small JSON messages that reference each other by ID, so the agent emits it incrementally and the client renders components as they arrive," the post explains. A model does not need to produce a perfectly nested document in one go; the A2UI site says LLMs "can build UIs incrementally without perfect JSON in one shot." The site calls the structure an "adjacency list model" and describes the resulting behaviour as progressive rendering, in which "users see the interface building in real-time instead of waiting for complete responses."

Portability is the third. "The same response renders through React, Lit, Angular, SwiftUI, Jetpack Compose (Android) or Flutter (multi-platform), and through community renderers for Vue, or even the terminal," according to Google. The A2UI repository also contains a Markdown renderer and transports such as A2A, a protocol for agents to communicate with one another.

The A2UI site sets out the interaction in six steps. A person sends a message; the agent generates A2UI messages describing structure and data; those messages stream to the client; the client renders them with native components; the person interacts, sending actions back; and the agent responds with updated A2UI messages.

Four versions of the specification

According to the A2UI site, the specification has moved through four versions, none of them dated:

  • v0.8 (Legacy) - described as "Structured Output first," with baseline surfaces, components, data binding and the adjacency list model.
  • v0.9 (Stable, previous) - a "Philosophical shift to Prompt-First," introducing createSurface, client-side functions, custom catalogs, modular schemas and formatting for validation errors.
  • v0.9.1 (Current) - the "current production release," which standardizes the application/a2ui+json MIME type and relaxes constraints on surface identifiers.
  • v1.0 (Candidate) - a release candidate, previously designated v0.10 in draft, which adds client-to-server remote procedure calls (actionResponse) and action IDs and renames "theme" to "surfaceProperties."

A2UI is licensed under Apache 2.0 and was "created by Google with contributions from CopilotKit and the open source community," according to the site.

Where AG-UI fits

A2UI describes what an interface contains. It does not say how that description travels; Google calls the format "transport-agnostic by design." In the Google and CopilotKit setup, the carrier is AG-UI.

"CopilotKit is built on AG-UI (Agent-User Interaction Protocol), which supports A2UI payload and provides Agent SDKs across many agentic backends," the post states. The division of labour is spelled out in three sentences: "Your agent emits A2UI operations. AG-UI carries them to the client as typed events. When the user takes any action, the values are sent back along the same stream."

According to its GitHub repository, AG-UI is "an open, lightweight, event-based protocol that standardizes how AI agents connect to user-facing applications." Agent backends emit events that match one of "AG-UI's ~16 standard event types" and accept a handful of simple inputs. A middleware layer lets the protocol run over any event transport, naming server-sent events, WebSockets and webhooks, and allows "loose event format matching" so agents and apps built separately can still interoperate. The repository ships a reference HTTP implementation.

The project positions itself against the two better-known agent protocols. In the repository's words, the Model Context Protocol "gives agents tools," A2A "allows agents to communicate with other agents," and AG-UI "brings agents into user-facing applications." Its listed features include streaming chat, bi-directional state synchronization, generative UI, frontend tool integration and human-in-the-loop collaboration.

AG-UI "was born from CopilotKit's initial partnership with LangChain and CrewAI," the repository says. Its integration table now runs long. Frameworks marked as first-party and supported include Microsoft Agent Framework, Google ADK, Google Antigravity, AWS Strands Agents, Mastra, Pydantic AI, Agno, LlamaIndex and AG2, with AWS Bedrock Agents in progress. Antigravity, Google's agent-first development environment, was recast as a unified harness at Google I/O in May 2026. Community integrations cover the Claude Agent SDK, the Claude Managed Agents SDK, Langroid, Omnara and Cloudflare Agents, with the OpenAI Agent SDK listed as in progress. The table also marks A2A, Amazon Bedrock AgentCore, Oracle's Agent Spec and MCP Apps as supported, alongside SDKs for Kotlin, Go, Dart, Java, Rust, Ruby, C++ and .NET. On the client side, it names CopilotKit, a terminal client, Slack and Microsoft Teams, and React Native.

The repository's activity figures, as displayed on October 31, give some sense of scale: 16,900 stars, 1,500 forks, 175 contributors, 70 releases (the latest dated October 30, 2026) and 5,142 commits, with 291 open issues and 255 open pull requests. TypeScript accounts for 39.3% of the code, Python for 35.3% and C# for 9.7%. The project carries an MIT licence and lists version 1.0.3. Stars and forks measure developer interest rather than production use, and neither project discloses how many applications run the protocols in production.

The setup Google published

According to the post, setup "comes down to two things: connecting your agent to CopilotKit, and defining which components the agent is allowed to use."

On the agent side, Google's example uses its own ADK. A package called ag_ui_adk "wraps any ADK agent and serves it as an AG-UI endpoint on FastAPI." The sample defines an agent named flight_agent, running on a model identified as gemini-3.8-flash, with the instruction "Help users find and book flights." The application then registers that endpoint with the CopilotKit runtime at /api/copilotkit, which the post calls "a few lines of standard setup" that "needs nothing A2UI-specific."

The interface work happens in the browser. "A2UI itself turns on from the client, where your components already are," the post says. The JavaScript sample declares a single custom component, FlightCard, with four properties: airline, departure time and arrival time as text, and the number of stops as a number. Each property is typed with a Zod schema, a validation library. The definitions are mapped to the developer's own React component, bundled into a catalog with the identifier flight-catalog alongside the Basic Catalog, and handed to the CopilotKit provider.

Two lines in the guide explain how the agent decides. "The description goes into the agent's prompt, so the model knows when to reach for FlightCard instead of a generic card. The Zod schema validates the props it sends back." The choice of component, in other words, is a model decision steered by a sentence of natural language. The schema checks shape, not truth: it can confirm that the stops field holds a number, but not that the flight has that many stops. Accuracy still depends on the tools the agent calls and on the model.

The catalog can be configured on the server ahead of time, or created dynamically and "shipped from the client to the server with the request." Google's ADK example used the dynamic route, which, according to the post, is why the agent could call a generate_a2ui function without the developer defining it.

CopilotKit is not mandatory. Developers "can also consume the event stream directly with @ag-ui/client and hand the A2UI operations to any compliant renderer," the post notes, naming Google's @a2ui/react package and its Flutter, Lit and Angular equivalents.

One surface, many steps

Google argues that most generated interfaces suffer from a basic flaw. "Most agent-generated UI is one-shot. The agent draws something, you read it, and it goes stale the moment anything changes," the post says. "A2UI surfaces are bi-directional and the components are reactive, which makes multi-step flows possible."

Its reference architecture for a flight booking places the agent on Google Cloud Run. A person uses an app running CopilotKit and the A2UI renderer. The main agent, built on ADK, LangGraph or Strands, hands interface work to a dedicated A2UI sub-agent through generate_a2ui; that sub-agent makes model calls to Gemini on Google Cloud. The main agent separately calls two tools, search_flights and book_flight, which reach an airline's API. Surface operations flow to the app over AG-UI, and actions and selected values flow back.

"Two things make the round trip work: inputs bound to a data path, and a button carrying an action that names which paths to send back," according to the post. Its JSON example defines a cabin selector, a component called ChoicePicker set to allow one choice between Economy and Business, whose value is bound to the path /booking/cabin. A Confirm button carries an action named confirmBooking that collects the values stored at /booking/cabin and /booking/email.

Validation happens before any model is involved. "Validation runs on the client, so a bad email shows an error inline without a model call. Nothing reaches the agent until the button fires," the post states. Once it does, the client sends the bound values and the agent re-emits the interface under the same surface identifier. "That is how the whole flow lives on one surface: flight search, results, passenger details, and confirmation."

The post lists four benefits that every AG-UI integration inherits:

  • Minimal server-side setup - the catalog reaches the agent on setup, so registering it on the client is enough.
  • Generation in a dedicated sub-agent - catalog and protocol rules stay out of the main agent's context window, and the surface streams to the client as the sub-agent produces it.
  • Self-healing output - invalid generations are caught and the specific errors go back to the model for correction, "so nothing broken reaches the screen."
  • Graceful failure - when retries run out, the surface resolves to a short message and the conversation continues "instead of dying in an error state."

The sub-agent design has a cost the post does not quantify. Each surface involves its own model calls, and retries add more, yet the guide publishes no latency, token or price figures. Developers can scaffold a starter app with a single command, npx copilotkit@latest create --name my-app --framework a2ui, and CopilotKit's Dojo hosts three runnable demos: a fixed server-side schema, a dynamic schema against a custom catalog, and an error-recovery case "where an invalid first render heals into a valid one." Google also points to an A2UI Composer, a visual editor that generates A2UI JSON without installation.

The A2UI site adds two demonstrations of its own. In one, a landscape architect application, a person uploads a photo, Gemini interprets it, and the agent generates a custom form for landscaping needs. In the other, an agent answers a numerical question with a chart and a location question with a Google Map, both custom components supplied by the client.

CopilotKit's commercial pitch

CopilotKit's website describes the company as "THE ENTERPRISE PRODUCT STACK FOR AGENTS" under the line "Connect any agent to any user." It lists user surfaces including Vue, Angular, React, iOS, Android, Slack, Teams and WhatsApp, and agent frameworks including the OpenAI Agents SDK, Claude Agent SDK, LangChain, Google ADK, AWS Strands and Mastra, plus "18 more agents." The site states that CopilotKit is "Trusted by the majority of the Fortune 500s and Global 50" but provides no list. It names two customers through testimonials: Docusign and Evergreen Wealth. "The AG-UI architecture lets us cleanly decouple our agent framework from the frontend, so we can evolve each independently," said Bryan Godwin, chief technology officer of Evergreen Wealth, according to the site.

For marketers, the most relevant part of the pitch concerns data. CopilotKit promotes "automatic learning," which captures "In-app interactions. What users do in your app: clicks, edits, and navigation outside the chat," as well as agent-user interactions such as "ask, feedback signals, approvals, edits, retries." Customers define "learning containers for users, groups of users, or entire organizations"; "self-improving skills are automatically adopted by your agents"; and the data can be exported "to fine-tune custom models." A product analytics module tracks which jobs people attempt, the paths they take and where they abandon or ask for help.

On ownership, the company says customers can "Self-host both the open-source SDK and the enterprise runtime. Nothing leaves your infrastructure," or use its managed Copilot Cloud, with data stored in a database the customer already runs. The site highlights TechCrunch coverage of a $27 million Series A round from May 2026, a DeepLearning.AI short course taught by Barkai titled "Build Interactive Agents with Generative UI," and a Google Cloud Next talk on A2UI, AG-UI and MCP Apps. The site's copyright line names the operating company as Tawkit, Inc.

Why it matters for marketers and publishers

Brand control moves into the catalog

Google's own framing explains why brands may pay attention. The controlled end of its spectrum is described as "brand-safe"; the open end produces "a surface that drifts from your design system." A2UI's catalog model lets a company's existing components, styled in its own design system, become the only vocabulary an agent can use on its screens. For a retailer, travel company or publisher building an assistant into its own app, that is a different proposition from letting a model generate HTML.

The travel example matters for the same reason. The old pattern the post describes ends with an agent sending people to "the operator's site." The new one keeps search, results, passenger details and confirmation on a single surface. Whose surface that is depends on who runs the agent. In Google's reference architecture, it is the developer's own application. In AI Mode and the Gemini app, where Google has shipped model-coded interfaces since late 2025, it is Google's. The October 29 post does not say whether A2UI is used in Search, AI Mode or the Gemini app.

The timing invites comparison. A day earlier, on October 28, Google opened a preview of its Connected Apps Platform, through which developers bring their services into Search and the Gemini app using a cloud-hosted MCP server or Android's AppFunctions APIs. Google said more than 50 Connected Apps were live across the two products. The A2UI guide does not mention that platform, and neither post explains how, or whether, a connected app's interface would be described in A2UI.

Another layer in a crowded protocol stack

Advertising has spent the past year absorbing agent protocols. Google released an open-source MCP server for the Google Ads API on October 7, 2025, which at launch operated only in read-only mode. Eight days later, on October 15, 2025, the Ad Context Protocol (AdCP) launched as version 2.0.0, built on MCP and offering both MCP and A2A access methods, with PubMatic, Scope3, Swivel, Triton, Optable and Yahoo as founding members. Within weeks, the industry was split over whether another protocol was needed while existing standards remained underused. In January 2026, Google launched the Universal Commerce Protocol, co-developed with Shopify, Etsy, Wayfair, Target and Walmart, with built-in support for the Agent Payments Protocol, A2A and MCP. And on April 29, 2026, Meta opened its ad system to Claude and ChatGPT, letting the assistants create and edit ads, ad sets and campaigns through MCP.

Those protocols govern what agents can do and whom they talk to. AdCP, for example, defines how buying and selling agents exchange campaign instructions. A2UI and AG-UI address a different question: what a person sees once an agent has an answer. That is the layer where campaign dashboards, product listings and checkout flows would surface in agent-driven software.

None of the four sources mentions advertising, sponsored components, ad measurement or attribution. Because a custom component "can be anything your frontend already renders," nothing in the specification as described would stop a commercial unit from appearing in a catalog. How such a unit would be labelled inside an agent-generated surface, and how its exposure would be counted, is not addressed.

Interaction data and the learning loop

CopilotKit's learning features record clicks, edits and navigation inside the host app as well as inside the chat. For marketers, that is behavioural data of the kind normally governed by analytics consent; for publishers, it is a record of what readers ask and abandon. The company's answer is self-hosting and customer-owned databases. The Google post itself says nothing about data handling, retention or consent.

Standards bodies are only starting on these questions. On October 21, 2026, the W3C's Strategy Team circulated a draft nine-point declaration on people and AI agents, whose map of unresolved work lists Generative UI among the AI-in-the-platform topics. The draft holds that an agent acting for a person owes that person loyalty, transparency and safety, as a browser does.

What the catalog does not protect

The catalog prevents an agent from executing code or rendering components outside the approved set. It does not, on the post's own description, verify what the agent writes into those components. A manipulated agent - for instance, one hit by prompt injection through a document or web page it processed - could still fill a valid FlightCard with wrong departure times or a false stop count. The Zod schema would pass it, because each field holds the right type. PPC Land reported in July 2025 that tool poisoning attacks target the layer between MCP clients and servers, a reminder that each new protocol hop adds a place where content can be tampered with.

A2UI also runs in the opposite direction from another Google proposal. WebMCP, which the Chrome team opened in early preview in February 2026, lets websites expose structured tools so agents can act on a site without parsing pixels. A2UI lets agents draw on an app. Together, the two proposals point to software built to be read and assembled by agents, not only by people.

What the materials leave out

Several basic facts are missing. The post does not say when A2UI was first published, and the A2UI site dates none of its four specification versions or the expected finalization of v1.0. Google's claim that declarative generation is "the most popular" mode comes with no figures. No production deployment of A2UI is named, inside or outside Google. The guide gives no performance data on latency, token consumption or error rates, even though its architecture adds a sub-agent and correction retries. CopilotKit's site links to a pricing page but its homepage publishes no prices. And none of the material addresses advertising, consent or how agent-generated surfaces would be measured.

Timeline

Summary

Who: Google, through its A2UI team, and CopilotKit, whose chief executive Atai Barkai co-wrote the guide. AG-UI, the protocol CopilotKit is built on, grew out of CopilotKit's partnership with LangChain and CrewAI. The audience is developers building agents into apps; the implications reach brands, retailers, travel companies and publishers that run assistants in their own products.

What: A how-to guide showing agents generating interactive interfaces with A2UI, a declarative JSON standard in which agents may only use components from an app's registered catalog, carried to the app by AG-UI, an event-based protocol with about 16 standard event types. The Basic Catalog has 18 primitives, most production apps define their own, and interfaces are bi-directional, so one surface can handle search, selection, details and confirmation.

When: The guide was published on October 29, 2026. The A2UI specification's current production release is v0.9.1, with v1.0 a release candidate; neither is dated. The latest AG-UI release on GitHub is dated October 30, 2026.

Where: On the Google Developers Blog, with code and specifications published on GitHub under Apache 2.0 (A2UI) and MIT (AG-UI) licences. The reference architecture runs the agent on Google Cloud Run with Gemini models, rendering in apps built with React, Angular, Flutter, SwiftUI, Jetpack Compose, Lit, Vue or Slack.

Why: Google argues that text replies cannot carry an agent through tasks such as booking, while letting models write raw interface code drifts from a company's design system and runs code a model produced. The catalog approach is pitched as both safer and more consistent with a brand's look. For marketing, it adds an interface layer on top of MCP, A2A, AdCP and UCP, yet none of the material addresses advertising, data consent or measurement.