§ Writing7 min read

A2UI's catalog is an API contract

A2UI 1.0 lets agents compose native screens from registered components. Treat the catalog as a versioned client API, and keep data exposure and action authority explicit.

On 11 November, Google announced A2UI 1.0, which it calls the first stable release of its open protocol for generative UI. An agent can describe a screen as structured messages; the host app renders it using its own registered components.

“With A2UI, the agent describes what to show, and every app draws the UI with its own native components.”

Google Developers Blog, A2UI 1.0, 11 November 2026

That is a useful boundary. The model describes a screen; it does not send a bundle of arbitrary HTML and JavaScript for the host to run. But the boundary has to be designed. A catalog decides which components and renderer functions exist. A data model decides what values are available to those components and, in one protocol mode, what is sent back to the agent. A server still decides whether a requested change is allowed.

This is design analysis with illustrative TypeScript. I have not deployed A2UI, run its renderers or independently tested its security or latency. The example is a hypothetical travel-rebooking assistant.

The catalog is a client API

A2UI describes a stream of JSON messages. The v1.0 protocol defines messages to create a surface, update its components, update its data model, and delete the surface. The application registers a catalog of component and function schemas; the renderer maps those names to the app’s native widgets and local functions. The catalog guide says the agent and renderer need matching catalog definitions.

For the travel assistant, the catalog could include a row of flight options, a fare summary, and a button to select one. It should not include a generic “run this JavaScript” component. That is the architectural advantage of sending structured data instead of executable UI code: the host decides the vocabulary the agent is allowed to use.

The vocabulary is still an API. Change a component’s required field, reinterpret a function argument or remove a catalog entry, and an older agent may produce messages the current renderer cannot use. A2UI 1.0 supports mixing catalogs within a surface, with components resolving through an explicit @catalogId or the surface’s default catalog. The evolution guide says an unresolved catalog causes a render or function-call error, not a fallback to some other catalog.

I would give each catalog a stable ID and a compatibility policy, just as I would for a public API. Pin the catalog and protocol version for an active interaction. Deploy the renderer and agent changes in a sequence that keeps both sides compatible. Test unknown component names, old catalog IDs and malformed properties as ordinary contract failures, not as model-quality failures.

Boundary The protocol can constrain The host still must decide
Component catalog Known widgets and properties Which widgets fit this task
Data model Values bound into the screen Which values the agent may see
Renderer function Caller role and activation rule Whether a server mutation is allowed
Message stream Message shape and ordering What stale or duplicate intent means

One switch can send the whole screen state

The data boundary deserves its own review. In the v1.0 schema, createSurface has an optional sendDataModel flag. It defaults to false. If the agent sets it to true, the protocol says the renderer sends the full data model for that surface in the metadata of every message it sends to the agent.

Picture a rebooking surface containing a passenger’s name, itinerary, loyalty details, available fares and a selected seat. If that full model is sent back with each action, the agent gets all of it, not just the chosen flight ID. The protocol does not say that every app must enable this. It makes the data flow explicit, which is a good reason to inspect the setting and the model instead of treating a native screen as a privacy boundary.

Google’s launch post describes server-side binding as a way for sensitive values not to reach the model. I read that as a claim about a particular binding design, not a guarantee supplied by A2UI for every integration. The protocol’s sendDataModel option is the concrete counterexample to making the claim universal. Keep it off unless the agent needs the whole surface state. If it does need context, send the smallest fields required for the next decision and verify what is attached to the outbound message.

That review should include logs and traces. A field may be hidden in the rendered screen and still be present in a data model or message envelope. Redact at the boundary where the message is assembled, and test the actual serialized payload, not only the visual component tree.

A gesture is not server authority

A2UI 1.0 also adds function calls in both directions. A function in a catalog can declare allowedCallers as rendererOnly, agentOnly or rendererOrAgent; the default is rendererOnly. It can also set requiresUserActivation. The function documentation says that a function requiring user activation must remain renderer-only, and that the renderer checks the caller and activation policy at runtime.

Those controls are useful. A device-local function that opens a link or invokes a share sheet can be restricted to a direct user gesture, rather than being called by a passive binding or a message from the agent. But the tap is evidence of interaction with the UI, not proof that the user has authority to change a booking. The browser or mobile renderer cannot be the final policy enforcement point for a business operation.

When the user selects a flight, I would send an intent to the application server and have the server re-check the authenticated principal and current booking before making the change. The UI can include a quote version so a stale price becomes a conflict instead of an accidental booking.

type RebookIntent = {
  itineraryId: string;
  offerId: string;
  quoteVersion: string;
};

async function rebook(intent: RebookIntent, principal: Principal) {
  await policy.require(principal, "reservation:change", intent.itineraryId);
  const offer = await offers.currentFor(intent.itineraryId, intent.offerId);
  if (offer.version !== intent.quoteVersion) throw new ConflictError();
  return reservations.rebook(principal, offer);
}

The UI sends a request. The endpoint checks permission and fresh state before it calls the booking service. That is the separation I want: A2UI governs what the renderer can present and which local functions may run; the application API governs what the user and agent may change. My earlier approval design post covers the stronger token contract needed when a specific human approval must authorise a sensitive call. This post is about the renderer and data contract around that action.

Test the contract, not the screenshot

A screenshot can show that a card looks right. It cannot prove what the agent received or whether a stale button can still perform a mutation. I would test the protocol at each boundary:

  1. Catalog: unknown component, function or catalog IDs fail closed; old and current catalog versions behave as intended.
  2. Data: sendDataModel is false by default in the deployed surface; enabling it is covered by a payload test that asserts exactly which fields leave the renderer.
  3. Function: an agent-originated call to a renderer-only function is rejected; a function marked as requiring user activation cannot run from a passive binding or incoming message.
  4. Server: a forged or replayed UI event cannot bypass authenticated-user checks, current-record checks or idempotency rules.
  5. Stream: messages arrive in order; an update for a deleted or stale surface does not resurrect an old choice.
  6. Version: each supported renderer passes the same contract suite against the catalog version it claims to implement.

The practical distinction is small but important. The catalog is not merely a visual theme. It is the set of interface capabilities the agent can address. The data model is not merely screen state. Depending on configuration, it is also an outbound payload. And a button is not an authorisation decision.

What I’d do on Monday

  1. Give each agent UI a task-specific catalog with only the components and functions it needs.
  2. Keep sendDataModel off unless a reviewed use case requires it; test the exact outbound payload when it is enabled.
  3. Mark renderer-only, agent-only and shared functions deliberately; require direct user activation for renderer-side effects that need a gesture.
  4. Re-authorise every server-side mutation against the current principal and resource state.
  5. Pin protocol and catalog versions, then run conformance tests for every renderer before rollout.
  6. Trace surface ID, catalog ID, function ID and server decision together, while redacting data that should not leave the host.

Limitations

This is a design review, not a security assessment of A2UI. I have not run the reference renderers or tested whether a particular implementation enforces these contracts correctly. The Google release page is dated 11 November and calls A2UI 1.0 the first stable release; the current protocol page itself lists a 8 June 2026 last-updated date. I use the blog date as the announcement date, not as the origin of the spec. Google also says Jetpack Compose supports v0.9.1 today, with v1.0 coming, so protocol stability does not yet mean identical renderer support across every listed platform.

Sources


  1. 6 min read

    A safety score is not a safety decision

    A safety evaluation should test the model, the controls around it and the exact configuration a release decision covers.


  2. 12 min read

    Approval is a capability, not a question

    Human approval only counts if the agent can't talk its way past it. Four properties, a scorecard of October's framework changes, and a token bound to the call.


  3. 11 min read

    The prompt said no internet: what four months of agent escapes teach builders

    Between July and October 2026, labs reported agents crossing boundaries that existed only as text. Each failure maps to a software control you can build.