When selecting a vacation, users may simply want to compare six packages side by side and then click on a date. However, chat-based intelligent agents often present flight details, hotel information, and prices in long blocks of text, before finally providing a link to proceed. In a tutorial published on October 29th by Google and CopilotKit (referred to as A2UI), they took a different approach: they incorporated selectable cards and input fields into the conversation, allowing users to continue their booking process within the original interface.
After the interface is generated in response to a request, the requirements for what the software team needs to deliver also change. Previously, an entire page was arranged by designers, but now it can be broken down into a set of predefined components that can then be combined by the agent according to the task at hand. When a user asks about travel, flight cards appear; when the user provides additional seat requirements, the interface updates with the corresponding options. This mechanism advances the conversation to a point where structured information can be submitted.
The model describes the intent, and it's up to the client to decide how to draw it.
A2UI is an open standard launched by Google that is independent of application frameworks. Agents use data to describe the interface, and applications use existing components to complete the rendering. Tutorials explain it in terms of two common approaches: developers can prepare complete cards in advance, or they can let the model generate the interface code that runs directly in a sandbox. The most commonly used declarative mode, A2UI, allows agents to combine interfaces from the component directory provided by the application.
There is one detail here that can change the product's judgment: the component directory is under the control of the client. Data sent by the agent must pass through this directory, and components that are not within the trusted set will be blocked. As a result, the software team still controls the brand style, component capabilities, and the interactions that are allowed to occur. Allowing the model to decide which card is needed at any given moment is different from giving the model the ability to execute code arbitrarily; these represent two different levels of permission.
The base directory provides 18 common components, covering layout, display, input, and containers. The official documentation also states that most production applications will define their own directories. For example, the map component can be drawn by the front-end, while the agent only provides the coordinates. In this way, the implementation of the map and the intended data usage can be separated: the front-end maintains stability, while the agent handles where the user wants to go this time.
The flight cards in the tutorial also demonstrate how this division of labor is implemented. The application declares fields such as the airline, departure time, arrival time, and number of stops, and binds them to its own rendering components. The component descriptions are included in the model prompts, while the field rules validate the returned data. The quality of a single interface generation depends not only on whether the model understands the task but also on how the team defines these business fields.
Click to confirm before submitting the selection back to the agent.
CopilotKit plays a role in connecting within this scheme. The agent issues a A2UI operation, which is then transmitted to the client as an event by AG-UI; the choices made by the user on the interface are also returned through the same event stream. Google's ADK, LangChain, and Strands among other compatible frameworks can participate in this process. Although the backend frameworks may differ, the interface descriptions use a common language.
More valuable changes occurred in the second round of interaction. Many generative interfaces are only responsible for producing a result once, and become outdated after the data changes. The A2UI interface in the tutorial binds the user's input to the data paths and the buttons to the fields that need to be submitted. Once the user selects a seat and enters their email address, they click confirm, and then the application sends these values back to the agent, which in turn updates the same interface.
Email validation is performed on the client side. When the format is incorrect, the page can directly display a prompt without the need to call an additional model for this error. This small arrangement sets a practical cost boundary: deterministic checks are left to the software, while task understanding and the organization of the next steps are handled by the agent. For users, it is easier to deal with an error that appears right next to the input field than to have to explain it again during a conversation.
For software delivery, this remains a development and integration solution. The tutorial provides the access endpoints, the directory of registration components, and the paths to start example applications; however, the production team still needs to integrate their own business operations. The booking card can collect information, but how actual transactions are authorized and executed is still determined by the specific application. The official demonstration has taken the interface one step further, but it does not provide a transaction backend that all enterprises can directly use.
This division of labor will affect the competition for enterprise software entry points. The chat box attracts users to express their needs, while the component directory determines which of these needs can be transformed into effective actions. Teams that control this directory can integrate their own forms, maps, and business cards into intelligent conversations; the integration framework is responsible for transmitting the selected options back. By eliminating one page transition for users, application developers gain an additional asset that needs to be maintained: an interactive capability that can be called by intelligent agents and is also subject to their own constraints.
