Por que UI Generativa é o próximo passo dos agentes de IA?

Olha só, os agentes de IA já evoluíram bastante — eles planejam viagens, buscam voos, montam pacotes de férias. Mas até pouco tempo, tudo voltava como um paredão de texto. Você pedia "pacote pra Bali em março" e recebia seis parágrafos com datas, hotéis e preços. Sem mapa, sem seletor de data, sem lista clicável. 😩

UI Generativa muda esse jogo: o agente constrói interfaces em tempo de execução, moldadas por cada requisição. Em vez de despejar texto, ele compõe componentes interativos — cards, formulários, mapas — que o usuário pode clicar, preencher e enviar.

O desafio? Você precisa de duas peças:

  1. Uma forma padrão de descrever a UI (para o agente declarar intenção).
  2. Uma stack agêntica que conecta seu agente à aplicação e renderiza essa UI.

Neste tutorial, vamos construir um app de UI generativa usando A2UI (padrão framework-agnóstico para declarar intenção de UI) e CopilotKit (construído sobre o protocolo AG-UI). Vamos usar o Google ADK como backend, mas o padrão funciona com LangChain, Mastra, Strands e outros frameworks compatíveis com AG-UI.

Quer ver como features de IA escalam em produção? Dá uma olhada na nossa análise sobre como o Spotify gerou 1,4 bilhão de stories personalizadas.

Developer integrating A2UI catalog with CopilotKit for generative UI agent chat Coding Session Visual

Passo a Passo: Ligando A2UI com CopilotKit

Passo 1: Configurando o backend do agente (exemplo com Google ADK)

O pacote ag_ui_adk envolve qualquer agente ADK e o serve como endpoint AG-UI no FastAPI:

# main.py — backend FastAPI expondo o agente ADK via AG-UI
from fastapi import FastAPI
from google.adk.agents import LlmAgent
from ag_ui_adk import ADKAgent, add_adk_fastapi_endpoint

root_agent = LlmAgent(
    name="flight_agent",
    model="gemini-3.8-flash",
    instruction="Ajude usuários a encontrar e reservar voos. Chame generate_a2ui para mostrar resultados.",
)

adk_agent = ADKAgent(
    adk_agent=root_agent,
    app_name="flights",
    user_id="demo_user",
    use_in_memory_services=True,
)

app = FastAPI()
add_adk_fastapi_endpoint(app, adk_agent, path="/")

Passo 2: Definindo o catálogo de componentes (React/TypeScript)

No lado do cliente, defina quais componentes o agente pode renderizar. Use schemas Zod para validação de props:

// catalog.ts — declare componentes permitidos e mapeie para renderers
import { CopilotKit, CopilotChat } from '@copilotkit/react-core/v2';
import {
  createCatalog,
  type CatalogDefinitions,
  type CatalogRenderers,
} from '@copilotkit/a2ui-renderer';
import { z } from 'zod';

// Defina o schema que o agente deve seguir
const catalogDefinitions = {
  FlightCard: {
    description: 'Um resultado de voo com companhia, horários e paradas.',
    props: z.object({
      airline: z.string(),
      departs: z.string(),
      arrives: z.string(),
      stops: z.number(),
    }),
  },
} satisfies CatalogDefinitions;

// Mapeie nomes de schema para seus componentes React reais
const catalogRenderers = {
  FlightCard: MyFlightCard, // seu componente React
} satisfies CatalogRenderers;

const catalog = createCatalog(catalogDefinitions, catalogRenderers, {
  catalogId: 'flight-catalog',
  includeBasicCatalog: true, // inclui 18 primitivas de uso geral
});

O campo description vai direto pro prompt do agente, então o modelo sabe quando usar FlightCard em vez de um card genérico. O schema Zod valida as props em tempo de execução.

Passo 3: Lidando com inputs bidirecionais (fluxo multi-etapa)

Para fluxos multi-etapa (ex: reserva), vincule inputs a data paths e anexe ações aos botões:

{
  "id": "cabin",
  "component": "ChoicePicker",
  "variant": "mutuallyExclusive",
  "options": [
    { "label": "Econômica", "value": "eco" },
    { "label": "Executiva", "value": "biz" }
  ],
  "value": { "path": "/booking/cabin" }
},
{
  "id": "confirm",
  "component": "Button",
  "child": "confirm_label",
  "action": {
    "event": {
      "name": "confirmBooking",
      "context": {
        "cabin": { "path": "/booking/cabin" },
        "email": { "path": "/booking/email" }
      }
    }
  }
}

A validação roda no cliente, então um email inválido mostra erro inline sem chamar o modelo. Nada chega ao agente até o botão disparar. Aí o cliente envia os valores vinculados, e o agente re-emite contra o mesmo surfaceId — mantendo todo o fluxo numa única superfície.

Passo 4: Gerando um app starter

npx copilotkit@latest create --name my-app --framework a2ui

Isso cria um app A2UI starter com integração CopilotKit Agent, pronto pra rodar. 🚀

React code editor showing A2UI catalog definitions and Zod schemas for flight booking UI System Abstract Visual

Limitações e Cuidados Importantes

Não é bala de prata. O A2UI é deliberadamente enxuto — o Catálogo Básico traz só 18 primitivas. A maioria dos apps em produção vai precisar definir um catálogo customizado, o que significa mapear cada componente que você quer que o agente renderize. É trabalho inicial.

Superfície de segurança. No extremo aberto do espectro, agentes podem retornar código de UI bruto (HTML/JS/Dart) que renderiza dentro de um iframe sandboxed. Poderoso, mas arriscado — você está executando código que um modelo escreveu. O modo declarativo (componentes pré-declarados) é mais seguro e mais popular em produção.

Drift do design system. Permitir que agentes componham UIs arbitrárias pode quebrar a consistência da marca. O extremo controlado (componentes predefinidos) é brand-safe mas limita personalização. Escolha seu ponto no espectro com consciência.

One-shot vs. reativo. A maioria das UIs geradas por agente é one-shot — o agente desenha, você lê, e fica obsoleto na primeira mudança. Superfícies A2UI são bidirecionais e reativas, o que viabiliza fluxos multi-etapa, mas você precisa explicitamente vincular inputs a data paths e definir ações. Não é automático.

Lock-in de framework (leve). O A2UI é framework-agnóstico, mas o caminho CopilotKit é React-first. Existem renderers para Flutter, Lit e Angular (@a2ui/react, equivalentes Flutter, Lit, Angular), mas o ecossistema é menos maduro fora do React.

Próximos passos de aprendizado

  1. Explore o CopilotKit Dojo — demos executáveis de A2UI incluindo schema fixo no servidor, schema dinâmico contra catálogo customizado, e um exemplo de recuperação de erro onde um primeiro render inválido se cura num válido.
  2. Teste o modo aberto — experimente geração de código de UI bruto em iframe sandboxed pra entender os trade-offs.
  3. Integre com seu design system existente — mapeie sua biblioteca de componentes para definições de catálogo A2UI e teste a composição pelo agente.
  4. Leia a documentação do A2UI — aprenda a integrar A2UI com qualquer framework de sua escolha.

Se você também se interessa pelo lado de infraestrutura de IA agêntica, confira nosso artigo sobre NVIDIA BlueField-4 e scale-in para fábricas de IA.

Architecture diagram of AG-UI agent streaming A2UI surfaces to CopilotKit frontend Developer Related Image

Conclusão

UI Generativa é a camada que transforma agentes baseados em texto em aplicações interativas. O A2UI te dá um padrão framework-agnóstico para declarar intenção de UI, e o CopilotKit (sobre AG-UI) te dá a stack pra renderizar. O padrão é direto: defina seu catálogo uma vez, deixe o agente compor componentes por requisição, e vincule inputs a data paths para fluxos multi-etapa.

Comece pelo modo declarativo (componentes pré-declarados) pela segurança de marca, e só migre pro modo aberto de geração de código quando realmente precisar. O trabalho inicial de mapear seu catálogo de componentes se paga em cada interação subsequente do agente.

Fonte: Build Generative UI Apps with A2UI and CopilotKit

Este conteúdo foi elaborado com o auxílio de ferramentas de IA, com base em fontes confiáveis, e revisado pela nossa equipe editorial antes da publicação. Não substitui o aconselhamento de um profissional especializado.