Chinese
Uncategorized

A2UI 1.0: What Frontend Teams Still Own When Agents Render the UI

A2UI 1.0 lets agents describe interactive screens through a structured protocol. The component and action boundaries still belong to the product team.

Jacky Wang 4 min read 66 views

When I build admin and booking flows, the part that worries me is not an agent producing an ugly temporary screen. It is an agent quietly changing the meaning of an action. A button that was meant to save a draft must not become “submit payment” because a model assembled a different interface.

On November 11, the Google Developers Blog introduced A2UI 1.0, a protocol direction in which an agent sends a structured description and the client renders the interactive screen using its own components. The easy explanation is “let the model write HTML”. I think that misses the important boundary.

Google’s announcement mentions bidirectional function calls, swappable inference formats, secure data binding, and open-source renderers for React, Angular, Lit, Flutter, SwiftUI, and Jetpack Compose. The useful mental model is that the agent proposes intent and data, while the product client decides which views, components, and actions exist.

The primary references are the A2UI 1.0 announcement and the Google Developers agents index. I use the announcement for protocol and renderer details, not to claim that every product already supports the same runtime.

Structure is more valuable than a clever prompt

It also changes what I would test. Alongside screenshot tests, I would add structural cases: unknown components are rejected, missing fields produce recoverable errors, repeated actions are deduplicated, and unauthorized resources render an empty or blocked state. Those tests do not depend on the model’s wording, so they continue to work when the model changes. For a maintained product, that is more valuable than an impressive single demo.

Plain text is fine for conversation, but it is a poor contract for changing a booking, reviewing an order, or confirming a refund. A structured UI description gives the client something it can validate: data types, required fields, allowed actions, and missing state. The application does not have to inject model-produced strings directly into the page.

A deliberately small example might look like this:

{
  "view": "booking-review",
  "data": {"date": "2026-11-18", "status": "draft"},
  "actions": ["edit", "save"]
}

This is not a complete A2UI schema. It is the boundary I would want the team to discuss first. The client should allowlist view and actions, and the server must check identity and resource ownership again. If the model emits save, that does not grant it the right to save anything.

The component library must be stronger than the prompt

If every agent can invent its own buttons, forms, and error states, the product soon becomes a collage. I would expose components as typed building blocks. A date picker accepts available dates. A payment button has an explicit confirmation state. An error component explains what the user can do next. The agent can compose those blocks, but it cannot inject arbitrary scripts or arbitrary navigation around them.

That is not a smaller role for frontend engineers. It is a more durable one. The model maps intent to structure. The frontend owns consistency, keyboard behavior, responsive layout, loading states, and failure states. The backend owns authorization and the final side effect. When those responsibilities are explicit, a generated interface is less likely to become something that looks clickable but has an unclear consequence.

Failure states deserve protocol support

Disconnected networks, timed-out tools, stale data, and double clicks are normal in agent workflows. If a protocol describes only the successful screen, complexity returns as a collection of client-side patches. I would want actions to expose states such as pending, needs-confirmation, failed, and completed. The client should also retain a request ID so retries do not create duplicate writes.

A2UI 1.0 is interesting because it makes the rendering contract more explicit. I would not interpret it as the frontend disappearing. It is more likely to move frontend work away from one-off page assembly and toward validated components, state machines, accessibility, and action contracts.

I would try this first on read-only order lookup and booking drafts, not refunds or production configuration. An agent that can explain why a button is present, what data it can change, and what happens when the action fails is ready for more interaction authority. Until then, generated UI should remain a proposal rendered inside boundaries owned by the product team.

发表评论