Google presented A2UI 1.0, the new version of its open protocol for generative UI, at Flutter Create. Somnio was one of the partners on stage: our CEO, Mauricio Pastorini, showed callAgentFunction running in an open-source investing app we built in Flutter.
A2UI (Agent-to-User Interface) is an open protocol that lets an AI agent answer with an interactive screen instead of text, which each app then renders with its own native components. Most AI assistants still answer with a wall of text, even when the question is about something people would rather see or act on, and generative UI starts from the idea that an agent driving an interaction should be able to build interface instead of writing paragraphs. A2UI is the protocol that makes that interface portable, and 1.0 is the version built for teams shipping products with it.
Google presented A2UI 1.0, the new version of its open protocol for generative UI, at Flutter Create. Somnio was one of the partners on stage: our CEO, Mauricio Pastorini, showed callAgentFunction running in an open-source investing app we built in Flutter.
A2UI (Agent-to-User Interface) is an open protocol that lets an AI agent answer with an interactive screen instead of text, which each app then renders with its own native components. Most AI assistants still answer with a wall of text, even when the question is about something people would rather see or act on, and generative UI starts from the idea that an agent driving an interaction should be able to build interface instead of writing paragraphs. A2UI is the protocol that makes that interface portable, and 1.0 is the version built for teams shipping products with it.
What Google announced about A2UI at Flutter Create
Flutter Create is the Flutter team's live event about what is new in Dart and Flutter, with partners and community members joining for deep dives on topics like multi-window on desktop, custom design libraries, developer experience and real customer stories. One of its sessions was dedicated to A2UI 1.0 and what it means for Flutter developers, hosted by Andrew Brogdon from the Flutter team.
The session walked through the protocol's new features one at a time, each shown by someone who had built with it. Andrew Brogdon covered allowedParents and allowedChildren, multiple catalogs and extensibility metadata, Illia Romanenko from SOLID showed the new Express inference format with a healthcare demo, and Mauricio Pastorini presented callAgentFunction for Somnio Software.
For Flutter developers there was also a practical update: genui (which started as flutter_genui) is replaced by three packages, a2ui_flutter, a2ui_core and a2ui_agent, and a2ui_flutter renders A2UI on mobile, web and desktop.
What is A2UI 1.0?
A2UI 1.0 is the current version of A2UI, an open-source protocol for generative UI released under Apache 2.0 and documented at a2ui.org. An agent describes the view it wants, and each app draws it with its own native components, whether the user is inside the company's own app or in an assistant that hosts it. The agent can only place components the developer registered, which keeps every screen on brand.
Version 1.0 adds bidirectional function calls, accessibility support and extensions for additional metadata. It ships with renderers for React, Angular and Lit on the web, Flutter on mobile, web and desktop, and SwiftUI on iOS, with Jetpack Compose support on its way to 1.0. On the agent side there are SDKs for Python, TypeScript and Dart.
Atlassian, Alation, Bloomberg and ByteDance are already building with it, and Google already uses A2UI in Gemini Notebook and Gemini Enterprise, and is moving Gemini Enterprise to 1.0. Google's launch post also lists a set of partner demos to explore, and Somnio's investing companion is one of them.
An open-source investing app built with A2UI and Flutter
Ask the AI assistant in most investing apps why your portfolio moved this week and you get a paragraph with five percentages in a sentence. Nobody reads their money that way, and understanding the portfolio is only step one. Acting on it is why anyone opens the app at all.
For the A2UI 1.0 launch we built an open-source investing companion for a crypto portfolio, where the agent answers by building an interface. Ask "What moved my portfolio today?" and it returns an attribution waterfall, one bar per holding, instead of a paragraph.
The flow our CEO, Mauricio Pastorini, chose to open with is the one that sold us on A2UI. Someone types a single sentence, "Put about $10k into the majors, keep it diversified," and gets back a draft order with every leg laid out (BTC, ETH and SOL), the weight of each one, the fees and the cash left over.
Then the interface talks back. Step up the amount on one leg and the ticket itself calls the agent, which reruns the same tool and redraws the total, the weights and the remaining cash in the same card. Each tap updates the card in under a second, and no new message appears in the chat.
That round trip is callAgentFunction. As Mauricio put it in the session, without it generated UI is a picture of an answer, and with it, it becomes a tool.
How does callAgentFunction work in A2UI 1.0?
callAgentFunction is a message a renderer sends to invoke a function the agent exposes. The agent answers with an agentFunctionResponse and an updateDataModel aimed at the component that made the call, so the view redraws in place without a new conversation turn.
This is the message our Flutter app sends when a view needs to be recomputed. It names the function (renderView), the catalog it belongs to and the arguments, which are only the options that view declares:
In our implementation a callAgentFunction never reaches the model, and the test suite asserts that with a null model client. Invalid input is refused rather than guessed at: an unknown view, an unknown option or a value out of range returns INVALID_FUNCTION_CALL, and componentId is restricted to an identifier so it cannot be used to write elsewhere in the data model. The full examples live in docs/a2ui/v1.0/examples/ in the repository.
Which taps should reach the model?
Before writing a line of code we ran every fintech use case we could think of through one test: would an agent composing interface on the fly beat a well designed form? Eight went in and five came back out, because a form already answers them. Risk profiling is a form, and so is expense categorization.
Three earned the agent: understanding what moved, the tax impact of a sale, and drafting an order. That left the question where we spent most of our time, which is whether every tap should reach the model. Our answer was no, and the line we drew is what we call the question-or-edit rule:
- A new question opens a new agent turn: Tapping a bar on the attribution waterfall, or one of the suggested chips, asks something the app does not know yet, so it goes to the model.
- An edit to a known answer calls a function: Changing the amount on a draft order is not a question, since the answer is already defined, so the ticket calls
renderViewand the backend recomputes it with no model and the same view.
Send every tap to the model and the app drags. In the session the difference was shown side by side, with a new agent turn taking several seconds and a function call updating the card almost instantly.
Two rules we would keep on any fintech project
The model does no arithmetic
In the repository we call it the numbers-from-tools invariant. Attribution, tax lots and order cost all come from deterministic backend tools, and every figure arrives as a pre-formatted string the model copies verbatim. Gemini picks the tool and picks the component, while the math belongs to code that can be tested. The rule is enforced by tests rather than by prompt wording: nothing in lib/ formats a number, does math or reads the clock to produce a figure, and an architecture test fails if one does.
The agent draws only from the catalog we registered
Our catalog holds the finance components the app needs, such as the attribution waterfall, the tax-lot table, the order ticket and the payoff curve. Each has a frozen id like attribution.waterfall.v1 or taxlots.table.v1, so a change to its shape arrives as a new id rather than as a silent edit. With allowedParents and allowedChildren we also declare which components nest inside which (a payoff chart, for example, can only appear inside an order ticket). The agent chooses the view, and the brand keeps its rules.
Run the open-source app yourself
The project is on GitHub under Apache 2.0: somnio-projects/finance-google-a2ui. It is a Flutter web app with a FastAPI agent backend on Cloud Run, and the finance components come with their schemas, ready to reuse.
The portfolio is simulated and nothing executes, which keeps the demo reproducible. You can try the hosted version at finance-a2ui-v1.web.app, or run it locally with Docker and no API key:
The web app comes up at http://localhost:3002. Without GEMINI_API_KEY the agent uses a deterministic scripted version that replays the demo flows, and once the key is set the same code path calls Gemini.
What this means for teams building with generative UI
The common thread in the Flutter Create session was that generative UI is moving from demos to products, and A2UI 1.0 brings the pieces that move requires: guardrails on what the agent can compose, faster generation, catalogs that scale across teams and interfaces that can act. callAgentFunction is the part that lets generated UI do something without paying a model round trip for every interaction.
The design work sits around it, though. Deciding which use cases deserve an agent at all, which interactions are new questions and which are edits to an answer the system already has, and keeping numbers out of the model are what let a product team trust what the screen shows. Those choices travel well beyond crypto portfolios, to any app where an agent's answer has to be correct and on brand. At Somnio we build products with Flutter at the core, and this app is where we put those rules to the test with the A2UI team at Google.
FAQ
What is A2UI 1.0?
A2UI 1.0 is the current version of A2UI, an open-source protocol for generative UI released by Google in November 2026. It lets an agent answer with an interactive screen that each app renders with its own native components, with renderers for Flutter, React, Angular, Lit and SwiftUI and agent SDKs for Python, TypeScript and Dart.
What is callAgentFunction in A2UI?
It is a message introduced in A2UI 1.0 that lets a rendered component call a function the agent exposes. The agent answers with the result and a data model update for that same component, so the view refreshes in place without a new conversation turn and, in Somnio's implementation, without calling the language model.
What are allowedParents and allowedChildren in A2UI 1.0?
They are catalog rules that declare which components can nest inside which. They are enforced by our renderer, so a team can stop the agent from composing layouts that break the product's design rules, like an order table inside a button.
What is the Flutter package for A2UI?
It is a2ui_flutter, which together with a2ui_core and a2ui_agent replaces genui (and, before it, flutter_genui). It renders A2UI on mobile, web and desktop and supports multiple catalogs on the same surface.
What is the question-or-edit rule in generative UI?
It is the line Somnio drew for its A2UI finance app: an interaction that asks something new opens a new agent turn and goes to the model, while an edit to an answer the system already has calls a function on the agent and is recomputed by deterministic code. It keeps generated interfaces fast and predictable.
Can I run Somnio's A2UI finance app without a Gemini API key?
Yes. The repository runs locally with Docker and no API key. Without a key, the agent uses a deterministic scripted version that replays the demo flows, and adding GEMINI_API_KEY switches the same code path to Gemini. The portfolio is simulated, and the app places no orders.
If you're searching for a trusted software development partner, look no further. Contact us today to learn how we can help you turn your vision into reality with our tailored, high-quality solutions.
