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:
- Uma forma padrão de descrever a UI (para o agente declarar intenção).
- 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.

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. 🚀

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
- 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.
- Teste o modo aberto — experimente geração de código de UI bruto em iframe sandboxed pra entender os trade-offs.
- 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.
- 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.

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.