8 Key Changes in the Latest Updates to A2UI and Flutter's GenUI Package

Generative User Interfaces (GenUI) represent a cutting-edge paradigm where AI agents not only produce content but also orchestrate how that content is displayed and interacted with. For Flutter developers, implementing GenUI has always relied on A2UI—an open protocol facilitating collaboration between agents and renderers. The Flutter team's genui package bridges this gap by offering a catalog of widgets for agents to use. Recent updates to both A2UI (v0.9) and the genui package introduce transformative changes that reshape how developers build AI-driven UIs. This listicle breaks down the top eight modifications you need to know, from architectural shifts to practical migration steps.

1. Shift to a Prompt-First Philosophy

The foundational change in the latest genui release is moving from a “Structured Output First” approach to a “Prompt First” paradigm. Previously, A2UI messages were streamed through structured output APIs, tightly coupling the agent's responses to specific formats. Now, agents embed JSON blocks directly as plain text within their responses. This shift simplifies integration with large language models (LLMs) by allowing the agent to decide when and how to output JSON. Developers can now rely on standard prompting techniques, making it easier to guide the agent’s behavior without fighting against rigid API structures. This also opens the door for more natural language interactions, as the agent can weave UI decisions into conversational text.

2. Architecture Decoupling: Engine, Transport, Facade

Version 0.9 of the genui package completely decouples the framework into three distinct layers. The Engine (SurfaceController) handles state management and rendering logic. The Transport (A2uiTransportAdapter) manages message streaming between the agent and renderer. The Facade (Conversation) provides a high-level API for chat state management. This separation eliminates the monolithic ContentGenerator class that previously encapsulated prompt construction, network calls, and response parsing. Now, each layer functions independently, giving developers granular control over their AI interactions. You can customize the transport adapter to work with any LLM provider, and the engine remains agnostic to how messages are generated. This architectural shift aligns with modern software design principles, promoting testability and flexibility.

3. Removal of ContentGenerator and Provider-Specific Wrappers

With the architecture decoupling, the ContentGenerator class and its associated provider-specific wrapper packages (like genui_dartantic, genui_google_generative_ai, and genui_firebase_ai) have been completely removed. In earlier versions, developers had to pass a ContentGenerator to the SurfaceController, which internalized all LLM interactions. Now, your app is responsible for setting up its own connection to an agent and handling message exchange through the TransportAdapter. This not only simplifies the package’s dependency tree but also eliminates vendor lock-in. You are free to choose any LLM provider, configuration, or custom function without being constrained by wrapper APIs. The removal represents the most significant code change for migration, requiring developers to refactor their existing implementations.

4. Direct Control Over LLM Interactions

The deprecation of provider wrappers hands you full control over how your application interacts with Large Language Models. Instead of relying on framework-managed network calls, you can now directly initiate chat sessions, manage retry logic, and handle errors as you see fit. This means you can tweak generation parameters (like temperature, top-p, or max tokens) per request, add system prompts, and integrate custom tools or functions without going through an intermediary API. The genui package no longer “wraps” your agent; it simply provides the scaffolding for displaying and updating the UI based on agent messages. This change empowers developers to optimize performance, reduce latency, and fine-tune responses for specific use cases—all while keeping the UI layer clean and reactive.

5. Simplified Migration Steps: Dependency Cleanup

Migrating from v0.7.0 to v0.9.0 requires a systematic cleanup of dependencies. First, remove any references to provider-specific packages like genui_dartantic or genui_firebase_ai from your pubspec.yaml. Next, update the core genui package to the latest version. The removal of these wrappers means you'll need to directly import the LLM SDK of your choice (e.g., google_generative_ai or firebase_ai for standard tasks). Additionally, replace any import statements that reference ContentGenerator with new imports for SurfaceController, A2uiTransportAdapter, and Conversation. The team has provided migration guides in the package documentation, but the core principle is simple: you build the connection to the agent yourself, then plug it into the transport adapter.

6. New Chat Loop Wiring

In the old architecture, chat loops were handled implicitly by the ContentGenerator class—streaming responses and managing state behind the scenes. With the new decoupled layers, you must explicitly wire up the chat loop. This involves creating a Conversation facade instance, initializing an A2uiTransportAdapter with your custom agent connection, and passing that to the SurfaceController. The controller then listens for UI update events and triggers re-renders. You have full visibility into the message history, allowing you to implement features like context trimming, conversation branching, or manual injection of system prompts. While this adds a bit of initial setup code, it dramatically increases transparency and debuggability. The new pattern encourages a clear separation of concerns: the agent generates raw text with embedded JSON, the adapter parses it, and the engine updates the Flutter widget tree accordingly.

7. Enhanced Customization of Widget Catalogs

The genui package originally provided a pre-defined catalog of Flutter widgets for the agent to choose from. The update refines this catalog, making it easier to extend with custom widgets. Now, you can define which widgets are available to the agent by configuring the SurfaceController with a custom set of renderable components. This is done through a new WidgetRegistry system that maps JSON schema elements to actual Flutter widgets. For example, you can register a custom chart widget or a specialized form component. The agent references these widgets by name in its generated JSON, and the engine instantiates them automatically. This opens up endless possibilities for branded or domain-specific UIs, as you are no longer limited to the defaults. Combined with the decoupled architecture, this makes genui a true framework for adaptive interfaces.

8. Improved State and Error Handling

Because the new architecture exposes chat history and transport state directly, you now have comprehensive control over error handling and retry logic. In previous versions, if a network call failed or the LLM returned malformed JSON, the framework would either crash or silently handle it. Now, you can catch exceptions at the transport layer, implement exponential backoff, or redirect the conversation to a fallback model. The Conversation facade provides methods to inspect the current state (e.g., whether the agent is waiting, generating, or finished). This enables sophisticated UI feedback like loading spinners, error banners, or graceful degradation. For production apps, this level of control is invaluable—you can ensure a robust user experience even when the underlying LLM service experiences hiccups.

Conclusion

The latest updates to A2UI and the Flutter genui package mark a significant evolution towards developer autonomy and architectural clarity. By moving to a prompt-first model, decoupling core layers, and eliminating opaque provider wrappers, the framework empowers you to build generative UIs with unprecedented flexibility. Whether you are migrating an existing app or starting fresh, these eight changes simplify customization, improve error resilience, and give you direct control over LLM interactions. As GenUI continues to grow, embracing these patterns will ensure your applications remain flexible, performant, and aligned with the future of AI-driven interfaces.