Acelerando a UI generativa com A2UI assíncrono

Saiba como pré-gerar e armazenar em cache mensagens A2UI para eliminar a latência de inicialização e criar UI generativa instantânea e responsiva no Flutter.

A UI generativa (GenUI) está mudando a forma como eu construo interfaces de usuário. Em vez de apresentar a cada usuário um conjunto estático de telas, a GenUI permite que um agente de IA componha e atualize a interface dinamicamente, em tempo de execução, usando mensagens baseadas em JSON. No Flutter, o pacote genui me permite renderizar esses componentes gerados por IA na hora.

No entanto, criar apps agênticos traz um desafio familiar: latência na inicialização.

Se um app depende de chamar um modelo de linguagem grande (LLM) na inicialização para gerar a interface inicial, os usuários ficam presos esperando o modelo gerar uma resposta. Os LLMs precisam processar prompts de sistema, fazer chamadas de função para buscar registros no banco de dados e montar payloads de UI, e tudo isso pode levar mais tempo do que os usuários estão acostumados a esperar ao navegar para uma nova tela. Para que apps GenUI pareçam instantâneos e responsivos, eu precisava pré-gerar e colocar em cache esses layouts de UI antes mesmo de o usuário abrir o app.

Neste post, vou mostrar uma técnica para gerar interfaces de usuário com antecedência, armazenando em cache mensagens A2UI, e depois percorrer como pegar essas mensagens e exibi-las sem atraso em um app agêntico.


A arquitetura do cache de GenUI assíncrono

Para colocar isso em contexto, vamos ver como apliquei essa técnica de cache no meu app de exemplo, Commis, um assistente inteligente para cozinhas comerciais e equipes de buffet. A experiência do usuário gira em torno de uma interface de chat conversacional, na qual um chef pode discutir os próximos trabalhos de buffet com um assistente de IA para coordenar a atribuição de receitas e o número de convidados. No entanto, quando o chef abre o app pela primeira vez, ele não deveria ter que começar um chat do zero. Em vez disso, quero que o agente ofereça uma UI pré-gerada com informações e ações relevantes para cada trabalho.

Para resolver o problema de latência de gerar essa rica visão de inicialização, decidi separar o processo de geração dos componentes iniciais da interface do ciclo de vida de execução do app cliente. Gerar a UI de forma assíncrona em segundo plano sempre que os dados mudam permite que o backend coloque o layout em cache antecipadamente, deixando-o pronto para carregar instantaneamente na inicialização.

Eis como fica esse fluxo de geração em segundo plano:

Diagrama de sequência mostrando o fluxo assíncrono de geração de UI entre o Firestore, o gatilho da Cloud Function e a API do Gemini

Quando o usuário abre o app Flutter, eu contorno o LLM por completo, puxando a UI pré-computada direto do banco de dados e adicionando-a tanto ao histórico da conversa quanto à camada de transporte genui. Ao desacoplar essas duas fases, os usuários têm uma experiência de inicialização instantânea, mas eu ainda mantenho toda a flexibilidade de uma interface dinâmica gerada por IA. Vamos ver como montei isso.


1. Geração assíncrona de UI no backend

A primeira metade da solução fica no servidor, e estou usando o novo suporte (e tecnicamente experimental!) ao Dart nas Firebase Functions com um gatilho. Sempre que um registro de trabalho de buffet muda, uma função é disparada. Ela recupera os dados atualizados, envia um prompt ao Gemini para construir a UI e grava o JSON resultante em uma coleção do Firestore chamada "feeds:"

dart
// functions/bin/server.dart
​
import 'package:commis_functions/src/content_generator.dart';
import 'package:firebase_admin_sdk/firebase_admin_sdk.dart';
import 'package:firebase_functions/firebase_functions.dart';
​
void main() {
  final adminApp = FirebaseApp.initializeApp();
  final firestore = adminApp.firestore();
​
  runFunctions((firebase) {
    // NOTE: Firestore triggers (like onDocumentWritten) are currently
    // experimental in the Dart Cloud Functions SDK and are only supported
    // when running within the Firebase Emulator Suite.
    firebase.firestore.onDocumentWritten(
      (event) async {
        // Read the API key from the environment parameters
        final apiKey = StringParam(
            'GEMINI_API_KEY',
            ParamOptions(
              defaultValue: '',
              label: 'Gemini API Key',
              description:
                  'API key to use when accessing the Gemini Developer API',
            )).value();
​
        final jobId = event.params['jobId'];
        final jobData = event.data?.after?.data();
​
        // Ensure we actually have post-write data to process
        if (jobData == null) {
          print('Could not find post-write job data.');
          return;
        }
​
        final jobBuffer = StringBuffer();
​
        // ...
        // A whole bunch of lines that turn the job's properties into text for
        // the agent.
        // ...
​
        try {
          final generator = ContentGenerator(apiKey);
          // Via a class that encapsulates the call to the LLM, generate A2UI.
          final message = await generator.generateFeed(jobData.toString());
​
          if (message == noUiSentinel) {
            // Delete the cached document if the event is no longer upcoming
            await firestore.collection('feed').doc(jobId).delete();
            print('No UI generated; deleting feed for $jobId.');
            return;
          }
​
          // Cache the generated A2UI message in the feeds collection
          await firestore.collection('feed').doc(jobId).set({
            'message': message,
          });
​
          print('Wrote feed for $jobId.');
        } catch (e) {
          print('Error generating UI: $e');
          return;
        }
      },
      document: 'jobs/{jobId}',
    );
  });
}

Dentro dessa classe ContentGenerator, encapsulei uma instrução de sistema que inclui o catálogo do meu app (uma série de instruções sobre quais componentes de UI podem ser gerados e quais são suas propriedades), a escolha do meu modelo (neste caso, gemini-3.1-flash-lite) e outra lógica sobre o que retornar se não houver UI a mostrar para um determinado trabalho.

Também dei ao LLM algumas instruções rígidas sobre o que não incluir, que, pensando bem, fazem parecer que eu estou gritando com ele!

**RESPOND ONLY WITH A2UI MESSAGES FOR A NavigationCard OR "$noUiSentinel". NOTHING ELSE.**
**DO NOT INCLUDE ANY CONVERSATIONAL TEXT WHATSOEVER.**
**DO NOT INCLUDE ANY EXPLANATIONS OF WHAT YOU ARE DOING.**

Como este é um exemplo simples para uma demo, estou sendo bem restritivo quanto aos itens do catálogo que quero que o agente consiga criar. Isso não é um requisito, porém. Você pode dar aos seus agentes o catálogo inteiro e instruções para ir com tudo na criatividade, ou reduzir as opções disponíveis para manter as barreiras por perto.

Nesse caso, se um job de catering estiver chegando em breve (digamos, nos próximos dois dias), o Gemini responde com uma mensagem A2UI limpa que instrui o cliente a exibir um mapa e os detalhes de navegação. Se o evento estiver mais distante, ele retorna minha string sentinela "NO GENERATED UI", fazendo a função limpar o feed daquele job.

Com isso pronto, tenho uma coleção estável no Firestore cheia de cards pré-gerados para os jobs do usuário, o que significa que meu app está pronto para exibir UI gerada sem esperar por um modelo!


2. Consumindo UI em cache no Flutter

Do lado do cliente, o objetivo é simples: buscar as mensagens A2UI pré-geradas no Firestore e colocá-las na tela.

App Commis exibindo cards de jobs de catering pré-gerados e navegação no mapa

Eu conecto isso durante a inicialização da tela do agente:

dart
Future<void> _initAgent() async {
  // This repository is a class I use to hide away queries to Firebase. It's
  // really just grabbing values and providing a stream.
  final repository = context.read<FirestoreRepository>();
​
  String? feeds;
​
  try {
    // 1. Fetch active jobs and wait for their cached feed messages
    final jobs = await repository.getJobs();
    final feedFutures = jobs.map((job) => repository.getFeedMessage(job.id));
    final results = await Future.wait(feedFutures);
​
    // 2. Combine the non-empty cached A2UI messages
    feeds = results
        .map((r) => r?.trim() ?? '')
        .where((r) => r.isNotEmpty)
        .join('\n\n');
  } catch (e) {
    debugPrint('Error initializing agent: $e');
  }
​
  // 3. Initialize the agent session, passing the cached messages
  _agentService = FirebaseAILogicService(
    repository: repository,
    catalog: _catalog,
    cachedMessages: feeds,
  );
​
  // 4. Feed the cached messages directly to the transport adapter
  if (feeds != null && feeds.isNotEmpty) {
    _transport.addChunk(feeds);
  }
​
  setState(() => _isWaiting = false);
}

Se essa função encontrar mensagens A2UI em cache, ela as envia em duas direções:

  • Primeiro, ela as fornece para a minha classe de agente, AgentService. Elas são adicionadas à instrução do sistema ("These A2UI messages are already in place on the client...") para que o agente conheça o estado inicial da UI.

  • Segundo, elas são enviadas para a camada de transporte do GenUI via addChunk (continua sendo meu método favorito de todo o pacote!). Isso garante que sejam processadas, que as superfícies certas sejam criadas e que o usuário veja a UI gerada.

Com as duas etapas concluídas, os usuários veem os cards dos jobs de catering e o mapa na tela instantaneamente, sem precisar esperar o LLM pensar. Além disso, as mensagens seguintes do usuário para o agente acontecem em uma conversa com o histórico completo do que está na tela. Se o usuário vê um card de navegação de um job, ele pode dizer "Na verdade, muda a data desse para a próxima segunda", e o agente vai saber qual job está sendo visto e editar o certo.

Generalizando o padrão de cache

Embora meu projeto específico use Firebase e Flutter, esse padrão de pré-geração e cache se adapta a qualquer stack de backend que você preferir:

  • Gatilhos e jobs: gere UI diretamente a partir de eventos de escrita no banco, ou rode um job de cron periódico para pré-gerar a UI dos eventos próximos.

  • Armazenamento flexível: você não precisa de um banco pesado. Um key-value store rápido, uma tabela de cache simples ou até arquivos JSON estáticos hospedados em um CDN funcionam perfeitamente.

  • Agnóstico de cliente: qualquer app cliente capaz de lidar com A2UI (inclusive os feitos com outros frameworks!) pode ler esses payloads JSON e renderizá-los na inicialização.

Usei um exemplo bem simples neste artigo. Ele não trata de questões com múltiplos usuários nem da invalidação do cache depois que um evento termina, e imagino que ninguém se interesse muito por ajuda de navegação para um evento que aconteceu no fim de semana passado!

Dito isso, espero que isso inspire ideias sobre os tipos de experiências que você pode construir com A2UI gerado offline, e como criar, combinar e usar mensagens A2UI para tirar o melhor dos apps agênticos.


Experimente!

Pronto para construir seu primeiro app Flutter + A2UI ou testar suas habilidades com padrões assíncronos para GenUI?

  • Confira o Intro to GenUI Codelab oficial para aprender o básico de Generative UI.

  • Explore o flutter/demos repositório no GitHub para ver o código-fonte completo do assistente de chef Commis e de outros exemplos de padrões de GenUI dirigidos por Dart.

Bom desenvolvimento!

Mais do Flutter