Agentes querem compilar

Agentes de IA estão começando a compilar. Em toda a stack, em meados de 2026, a mesma separação está sendo lançada de todas as direções: o modelo decide, e algo que não é um modelo executa. Em vez de agir ao vivo dentro do loop do modelo, os agentes emitem um artefato determinístico, um plano, um DAG, um script de workflow, e o entregam a um runtime que reexecuta, retoma e audita como software comum. O modelo está se tornando o front-end de um compilador, que interpreta intenções bagunçadas e as transforma em uma representação intermediária. Runtimes determinísticos estão se tornando o back-end. A agência ao vivo está sendo reprecificada como o modo caro que você reserva para exploração, falhas inéditas e bom gosto. {.answer-block}

Em 1º de julho, um Show HN apareceu com um título que se lê como uma declaração de tese: “Agente de programação que compila intenção em um DAG determinístico antes de rodar”. O projeto é o Rigorix, um runtime em Rust que se descreve como “um runtime determinístico de agente de programação para engenharia de software com IA repetível e auditável” e resume sua divisão de trabalho em uma linha: “O LLM gera o código; o Rigorix governa a execução.”³ Quatorze pontos, um comentário, fácil de passar direto. Parei nele porque é a terceira vez em outras tantas semanas que vejo a mesma forma ser lançada de uma direção diferente, e a forma, não uma ferramenta específica, é a história.

TL;DR

• A Anthropic traçou a linha canônica em dezembro de 2024: workflows rodam “por caminhos de código predefinidos”, agentes “direcionam dinamicamente seus próprios processos”.¹ Essa era uma bifurcação em tempo de design que um humano escolhia. Ela está migrando para o tempo de execução, e é o modelo que está escolhendo.
• Nos workflows dinâmicos do Claude Code, o modelo escreve um script de orquestração em JavaScript que um runtime executa fora da conversa: retomável com resultados em cache, comparável via diff com execuções anteriores, salvável como um comando que você reexecuta.²
• A mesma forma chega de mais três direções: ferramentas indie que compilam tarefas em linguagem natural em DAGs executáveis (Rigorix)³, frameworks que se recusam a rodar um grafo não compilado (LangGraph)⁴ e infraestrutura de execução durável que envolve loops de agentes em workflows reexecutáveis (Temporal)⁵.
• A compilação compra o que sempre comprou: cache, reconstruções incrementais, artefatos comparáveis via diff, revisão antes da execução. E custa o que sempre custou: julgamento congelado em tempo de compilação.
• A agência ao vivo ainda vence em exploração, estados de erro inéditos e bom gosto. A regra operacional: a primeira execução é pesquisa; toda execução depois dela quer ser um build.

A bifurcação era em tempo de design. Está virando tempo de execução.

O trabalho anterior aqui é “Building Effective Agents”, da Anthropic, publicado em 19 de dezembro de 2024 e ainda a taxonomia padrão para esse espaço. Ele define workflows como “sistemas em que LLMs e ferramentas são orquestrados por caminhos de código predefinidos” e agentes como “sistemas em que LLMs direcionam dinamicamente seus próprios processos e uso de ferramentas, mantendo controle sobre como realizam as tarefas”. Seu conselho na hora de escolher: “workflows oferecem previsibilidade e consistência para tarefas bem definidas, enquanto agentes são a melhor opção quando flexibilidade e tomada de decisão guiada pelo modelo são necessárias em escala”.¹

Por dezoito meses, essa frase foi lida como um cardápio. Você, o projetista do sistema, escolhia a coluna da esquerda ou a da direita antes de escrever uma linha. A virada de 2026 é que o cardápio está desabando em um pipeline. O agente faz a passada flexível, guiada pelo modelo, exatamente uma vez, em tempo de planejamento, e a saída dessa passada é um workflow: caminhos de código predefinidos, gerados sob demanda, para esta tarefa. Você ganha a flexibilidade do agente em tempo de compilação e a previsibilidade do workflow em tempo de execução, do mesmo sistema, em fases.

A pergunta “workflow ou agente?” está sendo respondida do jeito que os compiladores responderam “flexibilidade ou velocidade?”: ambos, separados por um artefato.

Três sinais, uma direção

Primeiro, o ambiente ficou determinístico

A camada de harness chegou lá antes dos agentes. Hooks disparam em eventos de ciclo de vida com códigos de saída que o modelo não consegue negociar. Regras de permissão são avaliadas antes da chamada de ferramenta, não depois. Toda a disciplina de arquitetura de agentes em 2026 é uma casca determinística em torno de um núcleo estocástico, e sua admissão sem rodeios: para qualquer coisa que precisa acontecer todas as vezes, paramos de pedir ao modelo e começamos a impor na fronteira. O determinismo chegou primeiro às bordas.

Depois, o artefato durável venceu a conversa

O segundo sinal é o que sobrevive a uma sessão. Conversas evaporam; a verificação, a especificação, o teste persistem, e os agentes otimizam contra eles com tanta força que a verificação vira a especificação. A lição por baixo: a transcrição não é o resultado. O artefato é, porque é a única coisa que a próxima sessão, o próximo agente e o próximo engenheiro conseguem segurar. Depois que você aceita isso para a verificação, aceitar para planos de execução é um passo curto. Se a verificação durável sobrevive à conversa que a produziu, o plano durável também sobrevive.

Agora o próprio plano é o artefato

O terceiro sinal é o novo, e é o assunto deste ensaio. Agentes começaram a emitir sua execução como um artefato de primeira classe em vez de executá-la ao vivo.

O Claude Code lançou isso como superfície de produto. Um workflow dinâmico é “um script JavaScript que orquestra subagentes em escala”: o Claude escreve o script para a tarefa que você descreve, e um runtime o executa em segundo plano enquanto a sessão continua responsiva. A documentação é explícita sobre o que mudou de mãos: “Um workflow move o plano para o código”. Na própria tabela comparativa deles, a resposta para “quem decide o que roda em seguida” não é o Claude. É o script. Toda execução grava esse script em um arquivo que você pode abrir, comparar via diff com o script de uma execução anterior, editar e relançar. Interrompa uma execução e a retome, e “os agentes que já concluíram retornam seus resultados em cache, e o restante roda ao vivo”.²

O Rigorix constrói a mesma forma vindo da direção indie, e sua arquitetura se lê como um livro-texto de compiladores: o planejamento avança por classificação de intenção, depois extração de parâmetros, depois geração do DAG; um motor guiado por templates executa o grafo sob portões de risco, orçamentos e permissões, com envelopes de auditoria assinados com HMAC para a trilha. Sua definição do ganho é precisa: “Repetível significa que a mesma intenção produz a mesma estrutura de execução sob os mesmos templates e políticas”.³

Os frameworks já estavam lá, escondendo a mesma ideia em um verbo de API. O LangGraph modela a lógica do agente como nós (“funções que codificam a lógica dos seus agentes”) ligados por arestas, e sua documentação declara a exigência em negrito: “Você DEVE compilar seu grafo antes de poder usá-lo”. Compile com um checkpointer e “o LangGraph salva checkpoints nas fronteiras de super-steps”, que é o que torna retomável uma execução pela metade.⁴

E a camada de infraestrutura chegou por baixo. O Temporal, a plataforma de execução durável, envolve loops de raciocínio de agentes em workflows cujo progresso persiste fora de qualquer processo: “o Temporal acompanha o progresso da aplicação e armazena todos os resultados de Activities”, de modo que um agente que travou “retoma de onde parou” em vez de raciocinar de novo do zero. Sua integração com o Agents SDK da OpenAI, anunciada em 30 de julho de 2025, tornou esse empacotamento um caminho suportado em vez de um padrão que você monta na mão.⁵

Ferramenta indie, superfície de produto, framework, infraestrutura. Quatro direções, uma forma: o modelo decide, o artefato executa.

Leve a analogia do compilador ao pé da letra

Analogias em textos sobre IA costumam ser decoração. Esta é estrutural, porque as previsões decorrem dela.

O front-end de um compilador faz o parse do código-fonte, verifica a semântica e emite uma representação intermediária. Essa é exatamente a fase de planejamento que esses sistemas executam: a classificação de intenção do Rigorix é o parse, a extração de parâmetros é a análise semântica, a geração do DAG é o codegen. O script de workflow é a IR. O back-end então faz o que back-ends fazem: agenda paralelismo, impõe limites de recursos (o Claude Code limita uma execução a 16 agentes concorrentes e 1.000 no total²) e memoiza. Quatro consequências se seguem.

Planos ganham caches de build. Semântica de retomada é compilação incremental. O Claude Code retorna resultados de agentes em cache ao retomar; o argumento do Temporal para quem constrói agentes é que a recuperação a partir do ponto de falha preserva tokens em vez de rodar o modelo de novo para regenerar trabalho perdido.⁵ O próximo passo são estágios de plano endereçados por conteúdo: reexecutar um workflow cujos estágios iniciais não mudaram vai pulá-los do jeito que o make pula objetos inalterados.

Planos ganham diff. A documentação de workflows convida você a comparar via diff o script de uma execução com o de uma execução anterior.² Uma vez que o plano é texto, o desvio de plano se torna visível do jeito que o desvio de código é, e “a orquestração desta migração mudou desde o trimestre passado” vira um evento revisável em um pull request, não um projeto de arqueologia através de transcrições.

O plano vira a superfície de revisão. Antes de um workflow rodar, o Claude Code mostra as fases planejadas e oferece “View raw script” (ver o script bruto) antes do consentimento.² Esta é a peça que conecta com o rumo da revisão. Eu argumentei que os agentes substituíram o revisor, não a revisão: o trabalho humano se deslocou de inspecionar diffs para ser dono da intenção. O plano compilado é o artefato onde essa revisão deslocada acontece, porque é o único lugar em que a intenção é legível antes que a execução gaste qualquer coisa. Você não consegue revisar dez mil decisões ao vivo. Você consegue revisar um script de quarenta linhas. Espere que a aprovação de grandes operações de agentes migre de aprovar o diff depois para aprovar o plano antes.

Desvio dispara recompilação, não remendo. Quando um plano compilado falha porque o mundo mudou, uma API renomeada, uma dependência atualizada, o movimento errado é editar o DAG na mão. Isso é remendar código-objeto. O loop certo roda o front-end de novo: mesma intenção, ambiente novo, plano fresco. Runtimes duráveis já absorvem falhas transitórias dentro do artefato com retries; desvio ambiental é a classe de falha que escapa para o compilador. Harnesses vão ganhar detectores de desvio que invalidam planos do jeito que sistemas de build invalidam caches, e “recompilar no desvio” vira um loop permanente em vez de um resgate manual.

Onde cada modo vence

A tabela é uma fronteira, não um ranking. Tudo abaixo da fronteira está prestes a ficar muito mais barato e muito mais confiável. Tudo acima dela continua caro porque deve continuar.

O que a compilação não compra

Três coisas continuam ao vivo, e fingir o contrário é como esse padrão vai ser vendido além da conta.

Exploração. Em uma base de código desconhecida ou em um problema genuinamente novo, o plano é a descoberta. Ainda não há nada para compilar porque decidir é o trabalho. Compilar antes de entender produz um artefato confiante da sua ignorância, e o runtime vai executá-lo com perfeição.

Estados de erro inéditos. Um plano compilado trata as falhas que seu autor antecipou. Políticas de retry são respostas determinísticas a problemas esperados. Quando o problema é inesperado, retry determinístico é um loop, não uma correção, e o movimento correto é escalar de volta para o front-end, onde um modelo pode olhar o erro real e pensar.

Bom gosto. Um workflow é julgamento congelado em tempo de compilação, e julgamento congelado envelhece. Julgamento fresco executado com desleixo vence julgamento velho executado com perfeição, porque a versão velha falha com confiança. Ninguém deveria compilar a decisão sobre qual deve ser a sensação de usar o produto.

Há também um alerta a trazer do lado da verificação. Um DAG é uma superfície de checagem, e tudo o que o plano omite deixa silenciosamente de ser o trabalho, a mesma dinâmica que faz testes visíveis virarem a especificação de fato. A compilação concentra todo o julgamento do modelo sobre uma tarefa em um único artefato, o que concentra o trabalho humano em ser dono desse artefato. A revisão não desaparece quando o plano compila. Ela se move para o tempo de planejamento, e ganha uma única página de alta alavancagem para trabalhar.

A posição

A regra pela qual eu opero agora é simples: a primeira execução de qualquer tarefa é pesquisa e merece um agente ao vivo; a segunda execução é um build e merece um artefato. O Claude Code entrega essa regra como UX: peça ao Claude para escrever o workflow uma vez, salve o script da execução como um comando, reexecute para sempre.² O Rigorix a entrega como governança. O Temporal a entrega como infraestrutura. O LangGraph a entregou anos antes como um verbo de API que ninguém leu como um manifesto.

Agentes querem compilar pela mesma razão que os programadores quiseram. Decidir é caro e precioso. Executar deveria ser entediante, inspecionável e grátis de repetir. A indústria passou 2024 e 2025 provando que modelos sabem decidir. O trabalho de 2026 é garantir que eles só precisem decidir uma vez.

Principais conclusões

• A primeira execução é pesquisa, a segunda é um build. Rode uma tarefa inédita com um agente ao vivo; no momento em que ela se repetir, congele-a em um artefato e pare de pagar por julgamento fresco em um problema resolvido.
• Compile primeiro os 80% entediantes. Tarefas rotineiras de release, varreduras de migração, lotes de tradução, passadas de auditoria: alta repetição, verificação barata. Exploração, depuração e bom gosto continuam ao vivo.
• Adote o loop de recompilar no desvio. Quando um workflow compilado quebra porque o mundo mudou, não remende o artefato na mão. Mande o modelo de volta para regenerar o plano contra a nova realidade, revise o diff, congele de novo.
• Revise o plano, não a transcrição. Uma vez que a execução é determinística, o plano é a página de maior alavancagem do sistema. Leia-o do jeito que você leria um script de migração, porque é isso que ele é.

FAQ

O que significa um agente de IA compilar seu plano?

Significa que a saída do agente é um artefato determinístico e inspecionável, um script de workflow ou um DAG, em vez de uma sequência de ações ao vivo. O modelo faz seu raciocínio em tempo de planejamento e emite o artefato; um runtime que não é um modelo o executa com semântica de replay, retomada e auditoria. Os workflows dinâmicos do Claude Code (um script JavaScript escrito pelo modelo e executado por um runtime) e o Rigorix (tarefas em linguagem natural compiladas em DAGs executáveis) são exemplos já lançados.

Qual é a diferença entre um workflow de IA e um agente de IA?

As definições canônicas da Anthropic de 2024: workflows são “sistemas em que LLMs e ferramentas são orquestrados por caminhos de código predefinidos”, enquanto agentes “direcionam dinamicamente seus próprios processos e uso de ferramentas”. A atualização de 2026 é que a fronteira está virando uma fase dentro de um único sistema em vez de uma escolha entre dois sistemas: o agente roda sua passada dinâmica uma vez, em tempo de planejamento, e gera ele mesmo os caminhos de código predefinidos.

Workflows de agente compilados são melhores do que agentes autônomos?

Para tarefas repetidas e de forma bem definida, sim: um workflow compilado é mais barato por execução, retomável com resultados em cache e revisável antes de executar. Para exploração, estados de erro inéditos e decisões de julgamento, não: um plano compilado é julgamento congelado em tempo de compilação, e essas tarefas precisam de julgamento aplicado no momento. A divisão prática é pela contagem de execuções: mantenha a primeira execução ao vivo, compile tudo o que você vai rodar duas vezes.

Quais ferramentas compilam a intenção de agentes em artefatos determinísticos hoje?

Quatro exemplos verificados em julho de 2026. Workflows dinâmicos do Claude Code: o modelo escreve um script de orquestração em JavaScript, um runtime o executa, scripts salvos viram comandos reutilizáveis. Rigorix: um runtime open-source em Rust que compila tarefas em linguagem natural em DAGs executados sob restrições de política, orçamento e permissão. LangGraph: grafos precisam ser compilados antes de rodar, com checkpoints nas fronteiras de super-steps. Temporal: workflows de execução durável que persistem o progresso do agente e retomam a partir do ponto de falha.

Fontes