10 Key Changes in A2UI v0.9 and Flutter's GenUI Package

Introduction

Generative UI (GenUI) is revolutionizing how user interfaces are built by enabling agents to not only generate content but also decide how to display and interact with it. For Flutter developers, the A2UI protocol and the genui package have been essential tools. Recent updates, driven by A2UI v0.9, bring significant architectural changes that enhance flexibility and control. This article outlines the 10 key changes you need to know, whether you're migrating or starting fresh. Let's dive in.

1. What Is Generative UI and How Does It Work?

Generative UI, or GenUI, is a pattern where an AI agent not only creates text or media but also determines how that content is presented and made interactive for the user. This means the agent makes decisions about layout, widget selection, and user interaction, moving beyond simple content generation. For Flutter developers, implementing GenUI involves using the A2UI protocol along with the genui package. The agent communicates with a renderer (client) to compose and manage the UI's state, providing a dynamic, adaptive user experience.

2. Introducing the A2UI Protocol and Flutter's GenUI Package

The A2UI (Agent-to-User Interface) protocol is an open standard that defines how agents and renderers collaborate. It specifies message formats for requesting UI elements, receiving responses, and updating state. To make this practical for Flutter, the Flutter team created the genui package. This package acts as a bridge, connecting an agent to a catalog of available widgets and rendering them in the app. Recent updates to both the protocol and the package bring enhanced functionality and a more developer-friendly architecture.

3. Shift from Structured Output First to Prompt First

Earlier versions of the genui package followed a Structured Output First philosophy, where A2UI messages were streamed through structured output APIs. The v0.9 update introduces a Prompt First approach: agents now embed blocks of JSON directly within their text responses. This simplifies integration with large language models (LLMs) that generate text, as you no longer need separate structured output handling. It also makes the system more resilient and easier to debug, since JSON is part of the natural response.

4. Architectural Decoupling: A Three-Layer System

Previous releases bundled all logic into a monolithic ContentGenerator class. The new architecture is decoupled into three distinct layers:

• Engine (SurfaceController): Manages UI state and rendering.
• Transport (A2uiTransportAdapter): Handles message streaming between agent and renderer.
• Facade (Conversation): Provides a high-level API for chat state management.

This separation gives developers direct control over individual components, making it easier to customize retry logic, error handling, and chat history.

5. Removal of the ContentGenerator Class

One of the most significant changes is the elimination of the ContentGenerator class. In v0.7, this class wrapped the agent and handled prompt construction, network calls, and response parsing. With v0.9, you no longer pass a ContentGenerator to the SurfaceController. Instead, your app now directly manages the connection to the agent and uses a TransportAdapter to exchange messages. This shift reduces abstraction layers and gives you full authority over the interaction flow.

6. Direct Control Over LLM Interactions

Because the framework no longer wraps your agent, you now have complete freedom in setting up LLM connections. You can choose any model or provider, tweak generation parameters (temperature, max tokens, etc.), add custom functions, and implement your own retry and error-handling logic. This direct control means you're not limited by the genui package's API—you can integrate cutting-edge models or proprietary services exactly as needed.

7. No More Provider-Specific Wrapper Packages

Earlier versions required separate packages like genui_dartantic, genui_google_generative_ai, and genui_firebase_ai to support different LLM providers. With the removal of ContentGenerator, these wrappers are obsolete. The latest genui package tree no longer includes them. This simplifies dependencies and avoids version conflicts. You can now use any HTTP client or SDK to talk to your LLM, making the stack lighter and more flexible.

8. Migrating from v0.7 to v0.9: Dependency Cleanup

If you're migrating an existing app, start by removing old dependencies. Delete imports for genui_dartantic, genui_google_generative_ai, etc. Update your pubspec.yaml to use the latest genui package (v0.9.0). Then refactor your code: instead of creating a ContentGenerator, set up a direct LLM client (like Google AI for Dart) and implement a custom A2uiTransportAdapter. Your SurfaceController will now accept the transport adapter and a Conversation facade for managing state.

9. Setting Up New Chat Loops with TransportAdapter

With the new architecture, the typical chat loop changes. You instantiate an A2uiTransportAdapter that defines how messages are sent and received from the agent. Then create a Conversation object to track chat history. The SurfaceController uses these to manage the UI stream. Here's a simple example:

final transport = MyCustomTransport();
final conversation = Conversation();
final controller = SurfaceController(
  transport: transport,
  conversation: conversation,
  widgetCatalog: myCatalog,
);

You then handle user input by calling controller.sendMessage() and listen to state changes. This pattern gives you complete control over when and how messages are exchanged.

10. Benefits of the New Architecture

The decoupled, prompt-first design offers several advantages. Developers can now:

• Customize every aspect of the LLM interaction without fighting the framework.
• Optimize performance by choosing lightweight adapters and managing streams manually.
• Debug more easily because JSON appears directly in agent responses.
• Integrate with any LLM provider, including self-hosted models.
• Maintain simpler dependency trees with fewer external packages.

These improvements make the genui package more suitable for production applications where flexibility and reliability are paramount.

Conclusion

The updates to A2UI v0.9 and Flutter's genui package represent a major step forward for generative UI development. By moving to a prompt-first approach, decoupling the architecture, and removing wrapper packages, the Flutter team has empowered developers to build more customizable and efficient agent-driven interfaces. Whether you're building a chatbot, a dynamic form, or a fully adaptive UI, these changes give you the tools to do it your way. Start migrating today to take advantage of the new flexibility and control.