> ## Content Index
> Fetch the complete content index at: https://blog.leobecker.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# GenUI: Interfaces Generativas
- URL: https://blog.leobecker.com/genui/
- Published: 2026-11-01T14:55:44.000Z
- Updated: 2026-11-04T16:41:23.000Z
- Description: O que é GenUI, os quatro jeitos de gerar uma interface com IA, os protocolos que ligam agente e tela, o Solaris da Runway e o que muda para quem desenha.
- Author: Leo Becker
- Tags: Artigos

No fim de agosto de 2026, a Runway mostrou o [Solaris](https://runway.com/news/research/introducing-solaris?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), um modelo que desenha a interface de um software quadro a quadro, como se fosse vídeo, sem código por trás da tela. Você clica num gato e os cliques seguintes aplicam a pelagem dele em tudo o que você tocar. Ele ainda está em prévia, aberto só para parceiros, mas é a ponta mais extrema de uma ideia que já chegou ao celular de muita gente: **a tela deixa de ser desenhada antes e passa a ser montada pela IA na hora, para o pedido de cada pessoa.**

Essa ideia tem nome, **GenUI**, abreviação de generative UI (interface generativa), e entrou no uso comum sem muito barulho. Em novembro de 2025 o Google pôs no app do Gemini [respostas que viram página interativa](https://blog.google/products-and-platforms/products/gemini/gemini-3-gemini-app/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), feita sob medida para cada pergunta. O [Claude](https://claude.com/resources/articles/interactive-tools-in-claude?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) e o [ChatGPT](https://openai.com/index/introducing-apps-in-chatgpt/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) abrem apps dentro da conversa, e os protocolos abertos que ligam agentes de IA a telas foram adotados por Google, Microsoft, OpenAI e Anthropic em menos de dois anos.

0:00 

/0:20 

1× 

Demonstração do Gemini 3 do Google desenhando artefatos de forma interativa.

> **Para quem desenha produto, isso mexe no centro do trabalho. Se a tela é gerada, o que sobra para desenhar?** 

**Fiz uma pesquisa profunda sobre esse assunto e tento jogar um pouco de luz sobre isso neste post. Pra começar, contextualizando o rolê:**

- **GenUI é a interface montada por um modelo de IA no momento do uso**, a partir do pedido e do contexto de quem está usando. A tela não existe antes da conversa.
- Na maior parte dos casos o **modelo não inventa nada visual. Ele escolhe e combina componentes que alguém desenhou**, e por isso o **design system fica mais importante.**
- Há quatro jeitos de gerar uma interface (**componente pronto, montagem com catálogo, código livre e pixels**), e quanto mais liberdade o modelo ganha, menos controle você tem sobre marca, segurança e acessibilidade.
- Três protocolos abertos organizam a conversa entre o agente e a tela, o **AG-UI**, o **A2UI** e o **MCP Apps**.
- Em testes do Google e de Stanford, as **pessoas preferiram a interface gerada à resposta em texto** na maioria das comparações.
- O Solaris leva a ideia ao limite e desenha a tela como vídeo, **mas ainda erra texto e não é público.**
- O trabalho de quem desenha sobe um nível, para o catálogo, as intenções das pessoas e as regras de quando a IA pode agir sozinha.

## O que é GenUI

No software tradicional, toda tela, todo botão e todo fluxo são previstos, desenhados no Figma, programados e publicados antes de alguém abrir o aplicativo. Todo mundo recebe a mesma interface. Se a sua tarefa não estava nos planos de quem fez o produto, você se vira com o que tem, abrindo três telas para fazer uma comparação ou exportando uma planilha para montar o gráfico que faltou.

Na GenUI, parte dessa decisão vai para o momento do uso. O sistema recebe o pedido, o contexto e um conjunto de peças e regras, e o modelo monta a tela daquela tarefa. Em vez de um parágrafo sobre a previsão do tempo, aparece um card com a temperatura e os próximos dias. Em vez de uma lista de voos em texto, aparece uma tabela que dá para filtrar. A interface pode durar só aquela tarefa e sumir depois, como um aplicativo feito para resolver um problema de cinco minutos.

Três coisas costumam ser confundidas com GenUI. 

1) Layout responsivo segue regras fixas escritas no CSS e não cria nada novo. 

2) Chatbot que só responde em texto não tem camada visual. 

3) IA que escreve código para um desenvolvedor salvar no projeto, como o [Cursor](https://cursor.com/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) ou o [Copilot](https://github.com/features/copilot?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), trabalha antes da publicação, então a pessoa do outro lado continua recebendo uma tela pronta. 

**GenUI é quando a geração acontece para quem usa, durante o uso.**

A preferência das pessoas por esse formato já foi medida. Num [paper do Google Research](https://generativeui.github.io/static/pdfs/paper.pdf?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) publicado junto com o [Gemini 3](https://blog.google/products-and-platforms/products/gemini/gemini-3/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), avaliadores **preferiram a interface gerada à resposta em markdown em 82,8% das comparações**, sem contar o tempo de geração ([Google Research](https://research.google/blog/generative-ui-a-rich-custom-visual-interactive-user-experience-for-any-prompt/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui)). 

Contra sites feitos por especialistas a interface gerada ainda perde, mas ficou pelo menos comparável em 44% dos casos. Um grupo de Stanford chegou a resultado parecido, com a interface gerada vencendo o chat em 84% das comparações quando o modelo base era o Claude 3.7 e em 69% com o GPT-4o ([arXiv](https://arxiv.org/abs/2508.19227?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui)).

## Como chegamos aqui

```
Até 2023   Tela fixa
   │       Tudo é desenhado e programado
   │       antes. Todo mundo vê a mesma tela.
   ▼
2024       O modelo escolhe o componente
   │       A resposta chega como card
   │       interativo no lugar do parágrafo.
   ▼
2025       Agente e tela conversando
   │       Com protocolos abertos, a tela
   │       devolve estado e o agente pausa
   │       para a pessoa aprovar.
   ▼
2026       Interface em pixels
           Um modelo de vídeo desenha a tela
           quadro a quadro. Ainda em prévia.
```

A ideia de uma interface que se adapta a quem usa é velha na pesquisa de interação humano-computador. Desde o fim dos anos 1990 há sistemas que tentam [prever o que a pessoa quer](https://erichorvitz.com/chi99horvitz.pdf?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) e [calcular o melhor layout para cada perfil e cada tela](https://www.eecs.harvard.edu/~kgajos/papers/2004/supple-iui04.pdf?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), só que limitados a combinar peças previstas e sem entender linguagem natural.

**A virada veio com os modelos de linguagem.** 

Até 2023 a IA conversava por uma caixa de texto, e texto é um formato ruim para comparar planos, filtrar uma busca ou ler uma série de números. Em março de 2024 o [AI SDK](https://vercel.com/blog/ai-sdk-3-generative-ui?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), da Vercel, passou a deixar o modelo responder com componentes React no lugar de parágrafos. Em junho do mesmo ano vieram os [Artifacts do Claude](https://www.anthropic.com/news/claude-3-5-sonnet?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) e, em outubro, o [Canvas do ChatGPT](https://openai.com/index/introducing-canvas/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), janelas ao lado da conversa onde o resultado aparece e pode ser editado. Logo depois surgiram as ferramentas que geram um aplicativo inteiro a partir de um pedido, como o [v0](https://v0.app/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), o [Bolt](https://bolt.new/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) e o [Lovable](https://lovable.dev/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui).

Lançamento dos Artifacts do Claude

Entre 2025 e 2026 a ideia ganhou força e infra. Surgiram protocolos abertos para o agente conversar com a tela nos dois sentidos, o Google lançou com o Gemini 3 (e [acabou de lançar o 4](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-argon/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui)) respostas que viram página interativa, e Claude e ChatGPT passaram a abrir apps dentro da conversa pelo mesmo padrão. O Solaris é a fase seguinte, ainda experimental, em que nem existe código.

## Os quatro jeitos de gerar uma interface

```
▲ mais controle sobre marca e segurança

┌────────────────────────────────────────┐
│ Componente pronto                      │
│ o modelo chama a ferramenta e o app    │
│ mostra o card desenhado para ela       │
│ AI SDK · CopilotKit · MCP Apps         │
└────────────────────────────────────────┘
┌────────────────────────────────────────┐
│ Montagem com o seu catálogo            │
│ o modelo descreve a tela em JSON       │
│ só com peças do seu design system      │
│ A2UI · json-render                     │
└────────────────────────────────────────┘
┌────────────────────────────────────────┐
│ Código livre em sandbox                │
│ o modelo escreve HTML ou React do      │
│ zero e o resultado roda isolado        │
│ Claude Artifacts · v0 · Lovable        │
└────────────────────────────────────────┘
┌────────────────────────────────────────┐
│ Pixels                                 │
│ um modelo de vídeo desenha cada        │
│ quadro, sem código por trás            │
│ Runway Solaris, em prévia              │
└────────────────────────────────────────┘

▼ mais liberdade para o modelo
```

**A decisão mais importante num projeto de GenUI é quanta liberdade dar ao modelo. Ela define o que pode dar errado, quanto custa e quem garante que a tela segue a marca e funciona com leitor de tela.**

### 1 - Componente pronto

Alguém desenha e programa um componente para cada ferramenta que o agente pode usar, como o card do clima, a comparação de voos ou o formulário de aprovação. O modelo decide quando chamar a ferramenta e preenche os dados, e o app mostra o componente certo. 

É o caminho que a [documentação do AI SDK](https://ai-sdk.dev/docs/ai-sdk-ui/generative-user-interfaces?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) recomenda para produção, com o resultado de cada ferramenta ligado a um componente React. O MCP Apps segue a mesma lógica dentro dos chats, porque a ferramenta já vem com a própria interface em HTML, que o Claude ou o ChatGPT mostram isolada do resto da página. 

O controle é total, e o limite também, já que o modelo nunca mostra uma tela que ninguém previu.

### 2 - Montagem com o seu catálogo

Aqui o modelo compõe a tela. Ele recebe um catálogo de componentes do seu design system e devolve uma descrição em JSON dizendo quais peças usar, em que ordem e com quais dados, e o app desenha tudo com os próprios componentes. 

O [A2UI](https://a2ui.org/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), projeto aberto do Google, funciona assim e se define como "seguro como dado, expressivo como código". O [json-render](https://github.com/vercel-labs/json-render?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), da Vercel Labs, faz o mesmo em React e outras bibliotecas, e o modelo só consegue usar o que está no catálogo. 

Você ganha telas novas para tarefas que ninguém previu sem abrir mão da marca e da acessibilidade que já estão nos componentes.

### 3 - Código livre em sandbox

O modelo escreve HTML, CSS e JavaScript do zero, e o resultado roda isolado do resto do sistema. É o que acontece nos Artifacts do Claude, no V0 e no Lovable, e também no dynamic view do Gemini. Dá para gerar qualquer coisa, um jogo, uma calculadora de orçamento, uma visualização que não existe em biblioteca nenhuma. 

A conta vem em demora, em código que às vezes quebra, em visual que foge da marca e em acessibilidade que depende do que o modelo lembrou de escrever. Funciona muito bem para protótipo e para ferramenta de uso próprio.

### 4 - Pixels

Aqui um modelo de vídeo desenha cada quadro da interface, sem código por trás, e trata o clique como mais uma instrução. É o caso do Solaris, que eu detalho mais abaixo.

O Solaris não está sozinho nessa ponta. O [NeuralOS](https://arxiv.org/abs/2507.08800?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), da Universidade de Waterloo com o National Research Council Canada, saiu em julho de 2025 e simula um desktop Ubuntu inteiro, com uma rede que guarda o estado da máquina e um modelo de difusão que desenha cada tela a partir do mouse e do teclado, e tem [demo aberta](https://neural-os.com/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) para quem quiser testar. 

Em abril de 2026, pesquisadores da Meta e da KAUST publicaram o [Neural Computers](https://arxiv.org/abs/2604.06425?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), que trata o próprio modelo de vídeo como o computador, com protótipos de terminal e de interface gráfica. No mesmo mês apareceu o [Flipbook](https://www.fastcompany.com/91532926/flipbook-animated-browser-inspired-by-apple-hypercard?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), um protótipo de navegador em que cada página era uma imagem gerada e cada clique abria outra imagem sobre o ponto tocado, sem HTML por trás (em novembro de 2026 o endereço dele estava fora do ar).

A linhagem vem dos jogos, com o [GameNGen](https://gamengen.github.io/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), que rodou Doom gerando cada quadro sem motor de jogo, e com o Genie, do Google, que eu comento no artigo sobre [modelos de mundo](https://blog.leobecker.com/modelos-de-mundo/). E o texto é o calcanhar de aquiles de todos eles. O [ViMo](https://arxiv.org/abs/2504.13936?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), que prevê a próxima tela de um app de celular como imagem, separa gráfico e texto para as letras continuarem legíveis, e modelos mais novos, como o [Code2World](https://arxiv.org/abs/2602.09856?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) e o [gWorld](https://github.com/trillion-labs/gWorld?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), voltaram a prever a próxima tela em HTML. Não confunda com o [Disco](https://labs.google/disco?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), experimento do Google Labs que transforma as abas do navegador em apps: ele monta aplicações web com o Gemini 3 e fica no terceiro jeito, o código livre.

## Os protocolos que ligam o agente à tela

```
    ┌──────────────────────────────────┐
    │ App na frente da pessoa          │
    │ A2UI vira componente nativo      │
    │ MCP Apps roda HTML isolado       │
    └─────────────┬────────────────────┘
            ▲     │
            │     │   AG-UI
            │     │   texto, ferramentas,
            │     ▼   estado e pausas
    ┌───────┴──────────────────────────┐
    │ Agente                           │
    │ modelo, instruções, memória      │
    │ e regras                         │
    └─────┬──────────────────────┬─────┘
      MCP │                      │ A2A
          ▼                      ▼
┌───────────────────┐  ┌───────────────────┐
│ Ferramentas       │  │ Outros agentes    │
│ e dados, como     │  │ recebem partes    │
│ APIs e bancos     │  │ da tarefa         │
└───────────────────┘  └───────────────────┘
```

Um agente de IA conversa com três vizinhos diferentes. O [MCP](https://modelcontextprotocol.io/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) liga o agente a ferramentas e dados, como APIs, arquivos e bancos. O [A2A](https://a2a-protocol.org/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) liga um agente a outros agentes, quando ele delega parte da tarefa. E o [AG-UI](https://docs.ag-ui.com/introduction?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), criado pela [CopilotKit](https://www.copilotkit.ai/blog/introducing-ag-ui-the-protocol-where-agents-meet-users?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) em maio de 2025, liga o agente ao aplicativo que a pessoa está usando.

O AG-UI é um protocolo de eventos. Ele leva texto em pedaços, chamadas de ferramenta, mudanças de estado e o raciocínio do agente para a tela, e traz de volta o que a pessoa fez. A especificação foi [congelada como versão 1.0](https://github.com/ag-ui-protocol/ag-ui/discussions/2792?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) em setembro de 2026, e o protocolo já tem integração com o [Microsoft Agent Framework](https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/ui/ag-ui/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), o [Google ADK](https://adk.dev/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), o [LangGraph](https://www.langchain.com/langgraph?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), o [CrewAI](https://crewai.com/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) e o [Mastra](https://mastra.ai/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), entre outros. Ele não diz como a tela deve ser desenhada. Essa parte fica com o próprio app, com o A2UI ou com o MCP Apps.

Os dois últimos entregam coisas diferentes. O MCP Apps entrega HTML pronto, que roda num iframe isolado dentro do Claude, do ChatGPT, do VS Code e de outros hosts. Ele virou a primeira extensão oficial do MCP em janeiro de 2026 e junta o trabalho do [MCP-UI](https://mcpui.dev/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) com o do [Apps SDK da OpenAI](https://github.com/openai/openai-apps-sdk-examples?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) ([blog do MCP](https://blog.modelcontextprotocol.io/posts/2026-01-26-mcp-apps/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui)). O A2UI entrega dados, e cada app transforma esses dados em componentes nativos, com renderizadores para React, Angular, Flutter e web components. Se você quer que a sua ferramenta apareça dentro dos chats, o caminho é o MCP Apps. Se quer que o agente monte telas com a cara do seu produto, é o A2UI.

## A pessoa aprova no meio do fluxo

```
Agente        App              Pessoa
  │              │                 │
  │ andamento    │                 │
  ├─────────────►│                 │
  │ TEXT_MESSAGE │                 │
  │              │                 │
  │ pausa e pede │                 │
  │ confirmação  │                 │
  ├─────────────►│                 │
  │ interrupt    │  mostra o card  │
  ¦              ├────────────────►│
  ¦ execução     │                 │
  ¦ encerrada,   │  aprova         │
  ¦ estado salvo │◄─ ─ ─ ─ ─ ─ ─ ─ ┤
  │              │                 │
  │ retoma com a │                 │
  │ resposta     │                 │
  │◄─────────────┤                 │
  │ resume       │                 │
  │              │                 │
  │ conclui      │                 │
  ├─────────────►│                 │
  │ RUN_FINISHED │                 │
```

Um agente que move dinheiro, apaga dados ou manda e-mail em nome de alguém não deveria fazer isso sem uma confirmação. A GenUI resolve esse ponto com uma tela gerada para a ocasião, um card com o que vai acontecer e os botões de aprovar, ajustar ou cancelar.

No AG-UI 1.0 isso tem um mecanismo próprio, chamado [*interrupt*](https://docs.ag-ui.com/concepts/interrupts?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui). O agente encerra a execução avisando o motivo da pausa (confirmação, falta de informação ou uma ferramenta que precisa de aval) e o formato da resposta que espera. O app mostra o card, a pessoa decide e o app abre uma nova execução com a resposta, marcada como resolvida ou cancelada. Antes de pausar, o agente manda para o app uma foto do estado e das mensagens, e como a execução termina de verdade, nada fica rodando enquanto a pessoa pensa. O pedido também pode vir com prazo de validade.

Esse card é uma interface que alguém precisa desenhar. Que informação a pessoa precisa ver para aprovar com segurança? O que acontece se ela ajustar um valor? Como fica o card quando a aprovação expira? Essas respostas são de quem desenha o produto, e o agente só segue o que ficou definido.

## Solaris, a interface desenhada como vídeo

```
Interface em código    Solaris
┌───────────────────┐  ┌───────────────────┐
│ Pedido da pessoa  │  │ Pedido, clique    │
│ texto ou clique   │  │ ou arraste        │
└───────────────────┘  └───────────────────┘
          ▼                      ▼
┌───────────────────┐  ┌───────────────────┐
│ Modelo de         │  │ Modelo de         │
│ linguagem escreve │  │ linguagem decide  │
│ HTML e React      │  │ o que muda        │
└───────────────────┘  └───────────────────┘
          ▼                      ▼
┌───────────────────┐  ┌───────────────────┐
│ Navegador monta   │  │ Modelo de vídeo   │
│ a página com      │  │ desenha o quadro  │
│ HTML e CSS        │  │ em 720p           │
└───────────────────┘  └───────────────────┘
          ▼                      ▼
┌───────────────────┐  ┌───────────────────┐
│ Tela              │  │ Tela              │
│ o clique roda o   │  │ o clique gera     │
│ código que existe │  │ um quadro novo    │
└───────────────────┘  └───────────────────┘
```

O [Solaris](https://runway.com/news/research/introducing-solaris?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) é o primeiro de uma família que a Runway chama de interface world models, os modelos de mundo de interface. Ele foi construído sobre o [Gen-4.5](https://runway.com/research/introducing-runway-gen-4.5?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), o modelo de vídeo da empresa, e gera a interface quadro a quadro em 720p. Quando você clica, arrasta ou digita, a ação entra na geração dos próximos quadros. Escrevi sobre a família maior desses modelos no artigo sobre [modelos de mundo](https://blog.leobecker.com/modelos-de-mundo/).

Por trás do Solaris também há um modelo de linguagem. Ele guarda o estado da sessão, decide como a interface deve mudar e escreve o pedido para o modelo de vídeo, que só desenha. A Runway descreve isso como separar o raciocínio da renderização. Para chegar a tempo real, a equipe transformou um modelo que refinava cada clipe em dezenas de passos em um que gera um quadro de cada vez, em poucos passos, e depois treinou essa versão rápida nas próprias saídas, para a imagem não degradar em sessões longas. Segundo a Runway, a interação deixa de parecer interativa a partir de cerca de meio segundo de atraso, e esse é o limite que o modelo precisa respeitar.

Nos exemplos da Runway, o mesmo arraste sobre um raio X da mão pode virar zoom no pulso ou medição da mão, e uma aula sobre combustão deixa você arrastar a chama sobre materiais diferentes e ver reações fisicamente plausíveis.

```
Seguiu melhor o pedido
Solaris  ███████████████████████████ 62%
Código   ███████████ 25%
Empate   ██████ 13%

Se comportou de um jeito mais natural
Solaris  ████████████████████████████████ 72%
Código   █████████ 21%
Empate   ███ 7%

Código = interface feita pelo Claude Opus 5
250 participantes · 30 exemplos
quase 7.500 comparações em pares
Estudo da própria Runway, sem revisão
por pares.
```

A Runway testou o Solaris contra uma interface em código feita pelo [Claude Opus 5](https://www.anthropic.com/news/claude-opus-5?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), com os dois partindo da mesma imagem e recebendo os mesmos pedidos. Foram 250 participantes, 30 exemplos e quase 7.500 comparações em pares. Segundo o [paper](https://arxiv.org/abs/2609.00776?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), o Solaris foi preferido em 62% das comparações ao seguir o pedido (25% para o código, 13% de empate) e em 72% quando a pergunta era qual se comportava de um jeito mais natural (21% para o código). É um estudo da própria empresa, sem revisão por pares, com exemplos escolhidos por ela, como uma loja, uma sala e um farol, cenas visuais com o tipo de interação em que a própria Runway diz que o modelo vai melhor.

As limitações vêm da própria Runway. Texto estável e legível continua sendo um dos problemas mais difíceis da geração de vídeo, e a empresa sugere usar modelos de imagem nas telas cheias de texto, quando uma pausa curta é aceitável. Ela escreve que, em experiência comercial ou educativa, uma resposta errada e convincente é pior do que nenhuma resposta. A coerência em sessões longas segue em pesquisa, a interface ainda precisa funcionar com leitor de tela e gerar cada quadro custa mais do que servir uma página feita uma vez. O acesso é por formulário, sem API e sem data de lançamento.

Fora da empresa, ninguém conseguiu testar o modelo, e as críticas batem nesses mesmos pontos. Jim Christian, que escreve um blog independente sobre IA, lembra que uma interface sem estrutura por trás não tem o que ser lido, porque desenhar pixels com cara de botão não produz nada que o leitor de tela consiga anunciar ([Signal Over Noise](https://signalovernoise.at/posts/2026/09/01/runway-solaris-interface-world-model/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui)). Maximilian Schreiner, do [The Decoder](https://the-decoder.com/runways-solaris-is-an-ai-system-that-generates-software-interfaces-in-real-time/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), aponta que a Runway deixa em aberto se as pessoas querem mesmo interfaces que mudam o tempo todo.

## Os problemas que ainda estão em aberto

A gente aprende uma interface pela repetição, e o botão que sempre fica no mesmo lugar vira memória do corpo. Se cada pedido gera um layout um pouco diferente, a pessoa perde essa referência, e isso pesa mais em ferramenta de uso diário do que numa consulta pontual.

Tempo e acessibilidade também contam. [O próprio Google avisa](https://research.google/blog/generative-ui-a-rich-custom-visual-interactive-user-experience-for-any-prompt/?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) que a geração da interface pode levar um minuto ou mais, uma espera que só compensa quando a tela entregue poupa mais do que isso. Na montagem com catálogo, a acessibilidade vem dos componentes, que já foram testados, enquanto no código livre ela depende do que o modelo escreveu naquela vez e nos pixels não existe estrutura para o leitor de tela ler.

Na segurança, código gerado precisa rodar isolado, e por isso o MCP Apps [exige iframe em sandbox](https://github.com/modelcontextprotocol/ext-apps/blob/main/specification/2026-01-26/apps.mdx?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui). O A2UI resolve pelo outro lado, porque o agente só pede componentes que o app já conhece e não manda nada para ser executado.

Por fim, o mercado ainda está se acomodando. A [Tambo Cloud](https://tambo.co/blog/posts/tambo-is-shutting-down?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui), serviço hospedado de uma das bibliotecas de GenUI para React, deixa de responder depois de 31 de outubro de 2026, e [o código continua aberto](https://github.com/tambo-ai/tambo?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui) para quem quiser hospedar. Apostar em padrões abertos, como AG-UI, A2UI e MCP Apps, reduz o estrago quando um fornecedor fecha.

## O que muda para quem desenha

```
┌──────────────────────────────────────────┐
│ Regras de autonomia                      │
│ o que o agente faz sozinho, mostra       │
│ antes ou só faz com aprovação            │
│  ┌────────────────────────────────────┐  │
│  │ Intenções                          │  │
│  │ o que a pessoa veio fazer          │  │
│  │  ┌──────────────────────────────┐  │  │
│  │  │ Catálogo                     │  │  │
│  │  │ componentes, tokens e a      │  │  │
│  │  │ descrição de cada um         │  │  │
│  │  │  ┌────────────────────────┐  │  │  │
│  │  │  │ Tela gerada            │  │  │  │
│  │  │  │ pelo modelo,           │  │  │  │
│  │  │  │ montada na hora        │  │  │  │
│  │  │  └────────────────────────┘  │  │  │
│  │  └──────────────────────────────┘  │  │
│  └────────────────────────────────────┘  │
└──────────────────────────────────────────┘
```

O modelo monta a tela, mas trabalha dentro de camadas que alguém precisa desenhar. A mais próxima da tela é o catálogo. No json-render, cada componente entra com as propriedades que aceita e uma descrição do que faz, e é essa descrição que o modelo lê para decidir. No A2UI, o agente só pode pedir o que está no catálogo. Um componente sem descrição ou com nome ambíguo acaba usado no lugar errado, e por isso a documentação do design system passa a ser lida também pelo modelo.

Em volta do catálogo ficam as intenções. Em vez de desenhar cada tela, você mapeia o que as pessoas vêm fazer no produto (comparar, aprovar, corrigir, entender um número) e o que cada intenção precisa ter na tela para funcionar. A designer e pesquisadora Joana Cerejo resume essa mudança dizendo que a IA deixa a interface barata de produzir e leva o trabalho do desenho de telas para a definição de intenção ([When Intent Becomes the New UI](https://www.jcerejo.com/writing/when-intent-becomes-the-new-ui?utm%5Fsource=leobecker&utm%5Fmedium=blog&utm%5Fcampaign=genui)).

Por fora ficam as regras de autonomia, que dizem o que o agente faz sozinho, o que ele mostra antes de fazer e o que só acontece com aprovação. Para a Cerejo, a intenção só funciona quando vira regra desse tipo, que diga quando o sistema desacelera, pede confirmação, devolve o controle ou se recusa a agir. Somam-se a isso os estados que todo componente gerado precisa ter, como carregando, pronto, erro e esperando aprovação, e a avaliação, que pode seguir o caminho do Google e de Stanford e comparar a tela gerada com a resposta em texto em tarefas reais.

## Na prática, por onde começar

```
Um erro na tela custa caro?
  │
  ├─ sim ─► Componente pronto, com
  │         aprovação humana nas ações
  │         sensíveis
  │ não
  ▼
A tela vai para clientes?
  │
  ├─ sim ─► Montagem com o seu catálogo
  │         A2UI ou json-render
  │ não
  ▼
Código em sandbox, para uso próprio
ou protótipo

Pixels ficam para depois, porque o
Solaris ainda não é público.
```

Se você não programa, comece pelo uso. Peça ao Claude ou ao Gemini uma ferramenta interativa no lugar de uma explicação, como um comparador de orçamentos ou um painel com os números de uma campanha, e repare no que funcionou e no que atrapalhou na comparação com a resposta que o mesmo pedido gera em texto.

Se você desenha produto, trate o design system como catálogo. Escolha os componentes que resolvem a maioria das tarefas do seu produto e escreva para cada um quando usar, quando não usar e quais dados ele precisa, como se estivesse explicando para alguém que acabou de chegar no time. Depois monte uma tabela simples de autonomia, com cada ação, o risco dela e o que a pessoa vê antes de ela acontecer. E desenhe o card de aprovação e os estados de erro, que são as telas que mais pesam na confiança de quem usa.

Se você programa, comece ligando uma ferramenta a um componente, com o AI SDK ou com a CopilotKit sobre o AG-UI. Quando a variedade de telas crescer, passe para a montagem com catálogo, com o json-render ou o A2UI. Deixe o código livre para protótipos internos e use o MCP Apps quando quiser que a sua ferramenta apareça dentro do Claude e do ChatGPT.

## Resumo da Ópera

Manjar de design system é mais valioso do que nunca daqui pra frente. Mas não apenas como operar um, e sim a lógica conceitual dos seus componentes e como eles juntos podem entregar uma boa experiência para os usuários.

Modelos generativos como o Solaris mostram até onde a ideia pode ir, mas ainda tropeçam em texto e são muito caros, mas apontam um norte.

Pra gente que trabalha com engenharia criativa, a oportunidade está em desenhar o sistema dentro do qual o modelo trabalha, com os componentes, as descrições, as regras de autonomia e os critérios de uma boa resposta. 

Minha indicação é começar pelo mais simples. Pegue os dez componentes mais usados do seu design system e escreva a descrição de cada um como se fosse para um modelo ler, com quando usar, quando não usar e quais dados ele precisa.

bju na bundinha e até a próxima.

Leo Becker