A2UI 0.9 is Google's answer to the same question Benioff answered last week. Different answer. Same architectural concession.

Four days after Salesforce declared that the API is the UI, Google published the spec that says the UI is generated by the agent. Both are responses to the same problem: enterprise software is being consumed by models, not humans. They have picked opposite architectures to solve it.

On April 19, Google Developers shipped A2UI v0.9, a framework-agnostic standard that lets AI agents declare UI intent and have client applications render the interface in real time. Official renderers ship for React, Flutter, Lit, and Angular. The spec works over MCP, WebSockets, REST, Agent-to-Agent, or any transport. The Decoder called it a new standard for portable generative UI.

The premise is straightforward. An agent can describe what the user needs to see, a form, a list, a chart, a checkout flow. The client application takes that description and renders it using its existing component library. The agent does not ship its own UI. The app does not hardcode every possible screen. The agent speaks UI, the frontend listens.

Google's developer blog describes the feature set plainly. Version 0.9 adds version negotiation, dynamic catalogs, resilient streaming, client-defined functions, and improved error handling. The SDK supports incremental parse and heal, so an interface can render as the model generates it rather than after the full response arrives.

The practical result is that a chatbot can produce a genuine product UI on the fly. A customer service agent surfacing a return flow can generate the form fields, address picker, and confirmation page using the retailer's own components. The retailer does not need to build a return chatbot. The agent builds the UI from the retailer's catalog.

Last week we covered Salesforce Headless 360 and Benioff's line that APIs are the UI. The architectural bet was that agents call APIs directly and the browser becomes optional. No front end required.

A2UI takes the opposite view. A front end is still required. It just gets drawn by the agent. The browser does not die. It becomes a rendering surface for agent-authored interfaces that share the host application's component vocabulary.

The two positions are not contradictory. They are different answers to different questions.

Salesforce is asking: how do we monetize workflow when humans no longer log in? Answer: expose the workflow as a protocol.

Google is asking: how do we keep humans in the loop when agents do the work? Answer: let the agent generate the UI, let the human still see and click.

The first is a bet on pure agent-to-workflow. The second is a bet on human-in-the-loop. Both concede that the static, hand-coded UI era is ending.

A2UI works over MCP, but it is not MCP. That distinction matters.

Model Context Protocol is how agents discover and invoke tools. It answers the question of what the agent can do. A2UI is how agents declare UI intent. It answers the question of how the human sees what the agent did or will do.

In practice, an agent using both would look something like this. MCP exposes a payments tool. The agent calls it. A2UI declares a confirmation screen showing the transaction details, authorization button, and merchant context. The client renders that screen using its own components. The human clicks. MCP fires the payment.

This is the architecture the Anthropic MCP spec implied but never specified. The UI layer was always going to be the next protocol. Google just published it.

What is still unresolved: whether Anthropic, OpenAI, and Microsoft will adopt A2UI, ship a competitor, or let the market fragment. The Google blog notes support for "AG UI" and "A2A" as alternative UI transports. The names alone signal that the UI-for-agents space is not yet consolidated.

The commerce implications are direct. Every agentic shopping flow we have covered this year has hit the same friction: how does the customer actually see and approve the transaction?

ChatGPT's product discovery pivot ended Instant Checkout partly because rendering a merchant-quality checkout inside a chatbot was brittle. Gap inside Gemini solved it by sending the checkout to Google Pay. Both were point solutions.

A2UI offers a general solution. An agent running a shopping flow generates the product card, the size selector, the payment confirmation, using the retailer's own components. The merchant keeps brand control. The agent keeps contextual control. The human still sees a coherent interface that matches the retailer's existing app.

The retailers that benefit are the ones with a strong existing design system and a clean component library. The retailers that lose are the ones whose UI is a decade of legacy screens with no reusable parts. That maps cleanly onto who is winning agentic commerce today and who is running behind.

Four protocols now matter for agentic commerce.

That is four standards in roughly twelve months, three of them from Google. The consolidation question is no longer whether MCP wins tool calls. It is whether Google becomes the de facto platform for agent infrastructure while Anthropic holds the tool-discovery layer and OpenAI takes the consumer surface.

Ralio's $2.5 million pre-seed, announced last week, already supports MCP, A2A, and AP2 out of the gate. The startups betting on this stack are picking up all three. That is the clearest market signal that the fragmentation is real and expected to persist.

Three signals over the next quarter.

First, whether OpenAI ships a competing UI generation standard or adopts A2UI. OpenAI's Sam Altman has been vocal about agents replacing apps. If ChatGPT's agent surface adopts A2UI, Google's standard becomes the default. If OpenAI ships its own, we are in a format war.

Second, whether enterprise SaaS vendors publish A2UI component catalogs. Salesforce, ServiceNow, Workday all have design systems. If their components become A2UI-addressable, the enterprise agent story shifts from Headless 360's "API only" to A2UI's "generate the screens."

Third, whether A2UI starts showing up in commerce flows before the end of Q2. Shopify is the most likely first mover. A Shopify app that exposes its design system as an A2UI catalog would let every agentic shopping experience draw a native-looking Shopify interface without the merchant building one. That is the payoff case.

Strip away the architecture and both Salesforce and Google are saying the same thing. The software interface is no longer a product. It is output.

For a quarter century, the interface was the product. Engineers built screens. Designers laid out flows. Users learned the software. The interface was both the moat and the revenue. The API was plumbing.

Both companies have now conceded that the interface is becoming a rendered payload, either skipped entirely (Headless 360) or generated per session (A2UI). The product is the data, the workflow, and the model. The interface is disposable.

If that holds, the companies that built their valuation on interface quality, the design-led SaaS platforms, the vertical software vendors, the category-defining apps, are facing a structural repricing. The interface was a moat. Not any more.

If the interface is a payload, what is the brand?

Charlie Major is a Product Development Manager at Mastercard. The views and opinions expressed in Major Matters are his own and do not represent those of Mastercard.