GenUI Ephemeral Experiences: What the Flutter & Dart 2026 Roadmap Actually Promises

The Flutter & Dart 2026 roadmap, published February 24, 2026 by Emma Twersky, contains a short section with outsized implications: “GenUI, ephemeral experiences and agentic apps.” Two paragraphs, two separate ideas — one shipping now, one under investigation. Here’s what it says and what you can actually build on.

The claim, as written

The roadmap states the team is “fundamentally changing app architecture to enable agentive UIs — interfaces that aren’t just pre-built, but adapt in real-time to user intent,” powered by the Flutter GenUI SDK and the A2UI protocol, “enabling AI models to generate rich experiences dynamically.”

Then the second idea: “To support this, we are investigating evolving the Dart language by adding support for interpreted bytecode in the Dart runtime. This enables ‘ephemeral’ code delivery, where specific portions of an app can be loaded on demand without requiring a full app store update — a critical technical step for truly agentic apps.”

Read the qualifiers carefully. GenUI and A2UI exist today — the genui package is on pub.dev (still labeled experimental/alpha in the docs). Interpreted bytecode is investigated, not shipped. No timeline, no API surface. Treat it as direction, not a dependency.

What “ephemeral experience” means in practice

Today, generative UI in Flutter is server-driven within a fixed vocabulary. The agent sends A2UI messages — createSurface, component updates, data-model updates — and your app renders them through a Catalog of widgets you shipped in the binary. The experience feels ephemeral because the composition changes per user and per turn, but the components are compiled into your release.

The bytecode work targets the remaining gap: shipping genuinely new logic — not just new arrangements of existing widgets — without an app store round trip. Interpreted bytecode loaded on demand would let a portion of app behavior arrive at runtime, the way web apps have always worked, but inside a compiled Dart app. That’s the “critical technical step” framing: agentic apps that adapt to intent eventually need to adapt their logic, not only their layout.

What you can build now

You don’t need bytecode delivery to get most of the value. The current stack already supports ephemeral-feeling experiences:

// Client: define the vocabulary once, at build time.
final controller = SurfaceController(
  catalogs: [CoreCatalogItems.asCatalog().copyWith([bookingCard, slotPicker])],
);
final transport = A2uiTransportAdapter(onSend: _callAgent);
final conversation = Conversation(controller: controller, transport: transport);

// Surfaces appear and disappear as the agent creates and deletes them.
conversation.events.listen((event) {
  if (event is ConversationSurfaceAdded) {
    setState(() => _surfaceIds.add(event.surfaceId));
  } else if (event is ConversationSurfaceRemoved) {
    setState(() => _surfaceIds.remove(event.surfaceId));
  }
});

Practical patterns that hold up under this architecture:

• Compose flows, not screens. Design catalog items that the agent can assemble into task-specific surfaces — a checkout, a booking, a report — instead of pre-wiring every screen.
• Keep state in the DataModel. Input widgets write to bound paths; the agent reads the data model as context on the next turn. That’s what makes a session feel continuous.
• Version your catalog like an API. Since the server can only request widgets you shipped, the catalog is a contract between app releases and your agent backend. Deprecate items the same way you’d deprecate endpoints.
• Design for deletion. Ephemeral means surfaces go away too. Handle ConversationSurfaceRemoved deliberately rather than leaking IDs in a list.

What to watch

Three roadmap signals around this section tell you where it’s heading. First, full-stack Dart: Dart Cloud Functions for Firebase with ~10ms cold starts, and Dart support work with the Genkit team — the agent side of the loop moving into Dart. Second, the A2UI ecosystem keeps expanding beyond Flutter (web renderers, agent frameworks like ADK and AG2), so the protocol layer is the stable bet even as client SDKs evolve. Third, the bytecode work is language-level, which means when it lands it will land for the whole Dart ecosystem, not just Flutter.

The roadmap itself carries the standard disclaimer: it’s aspirational strategy, plans shift through the year. But the sequencing is unambiguous — GenUI and A2UI now, interpreted bytecode later, both pointing at the same destination: apps whose UI and behavior are generated in the moment. If you’re investing in agent-driven product surfaces in 2026, the catalog-driven GenUI architecture is the thing to design against today.

Sources

• Flutter & Dart’s 2026 roadmap
• GenUI SDK for Flutter
• A2UI
• genui on pub.dev