Corrija o Loop, Não a Saída: O Ativo Durável de Engenharia de IA É o Harness

A Anthropic moveu cerca de um milhão de linhas do runtime Bun de Zig para Rust em menos de duas semanas. Todos os testes que o projeto já tinha continuaram passando. Dezenove regressões apareceram depois do merge, e as dezenove foram corrigidas. A execução consumiu 5,9 bilhões de tokens de entrada e 690 milhões de tokens de saída, cerca de US$165.000 em modelo, e o runtime reescrito caiu de 6.745MB para 609MB de memória. O que importa aqui é onde o time gastou suas horas humanas.

Essas horas foram para a máquina que produziu o Rust: o livro de regras, a revisão adversarial, o harness de paridade. O milhão de linhas de Rust, eles em grande parte não leram na mão. Quando a saída voltava errada, a correção subia para o processo, e o processo regerava a saída.

A Migração Corrigiu o Processo, Não o Código

O próprio relato da Anthropic enuncia a regra de operação de forma direta: a disciplina era reparar “o processo (loop) que produziu o código” e deixar o loop emitir saída correta na próxima passada. Essa única frase é o método inteiro comprimido. Uma tradução ruim de um arquivo Zig é um sintoma. A causa é uma regra ausente, uma dependência não declarada, ou um comportamento que a verificação de paridade nunca afirmou. Você conserta o arquivo e resolve uma instância. Você conserta o loop e resolve toda instância que ia falhar da mesma maneira.

O loop tinha seis passos, e nenhum dos passos determinísticos foi deixado a critério do modelo:

Preparar. Construir um livro de regras, um mapa de dependências e um inventário do que ainda não traduz de forma limpa.
Estressar as regras. Atacar o livro de regras antes de confiar nele, para que as ambiguidades apareçam no quadro branco em vez de em 400 arquivos.
Traduzir. Modelos pequenos fazem o grosso da implementação; modelos grandes revisam a saída de forma adversarial, procurando o que a passada barata deixou escapar.
Compilar. Agentes corretores dedicados levam o build ao verde.
Smoke test. Confirmar que a coisa roda antes de qualquer conversa sobre correção.
Casar comportamento. Um harness de paridade compara o runtime novo com o antigo e segura a linha da semântica.

A inteligência mora em exatamente dois lugares: a revisão adversarial no passo 3 e a caça a ambiguidades no passo 2. Todo o resto é andaime. O livro de regras é um documento. O mapa de dependências é um grafo. O compilador é determinístico. O harness de paridade é um teste que passa ou não passa. Uma outra portabilidade da Anthropic moveu 165.000 linhas de Python para TypeScript em um único fim de semana com o mesmo formato de máquina, o que é o indício de que isso é um método repetível e não uma história de heroísmo pontual.

O Mesmo Movimento em Um Centésimo da Escala

Adam Jacob, construindo a System Initiative, pegou um fluxo de agentes que ele chama de “pântano” e rodou a jogada idêntica na escala de uma única tarefa. O estudo de caso Garfield começou em 4,6 milhões de tokens, 12,8 minutos e 23 agentes coordenando uns aos outros em linguagem natural. Ele o reconstruiu para 506.000 tokens, 6,6 minutos e 3 agentes. Oito vezes mais barato. Metade do tempo de relógio. Vinte agentes de coordenação apagados.

A economia veio de tirar a coordenação das mãos do modelo. Na versão pântano, agentes conversavam com outros agentes para decidir o próximo passo, e cada uma dessas conversas era token, latência e uma chance nova de deriva. Na versão reconstruída, a sequência vive em código tipado e determinístico. O modelo é invocado só onde uma decisão de fato precisa de julgamento. Tudo que uma função consegue decidir, uma função decide.

Dois esforços de engenharia, duas ordens de grandeza distantes em escopo, chegaram ao mesmo desenho. Quando o modelo está fazendo trabalho que um harness tipado faria de forma mais barata e mais confiável, mova esse trabalho para o harness. Reserve o modelo para os passos onde o julgamento dele é o produto de fato.

O Modelo É a Entrada Trocável; O Loop É o Ativo

Já defendemos a tese da camada determinística a partir dos primitivos: ganchos bloqueiam e avaliações verificam em torno de um núcleo probabilístico, e engenharia de loop é onde a confiabilidade realmente vive. Essas duas execuções acrescentam a parte que muda como você deve orçar. O harness é o ativo durável. O modelo é um componente que você troca.

Pense no que sobrevive da migração do Bun. Não o Rust. O livro de regras, o mapa de dependências, o harness de paridade e o loop de seis passos sobrevivem ao modelo específico que os preencheu. Rode a próxima migração em um modelo mais barato ou mais novo e o andaime continua de pé, porque o andaime nunca dependeu de qual modelo estava traduzindo. O mesmo vale para o código de coordenação tipado de Jacob. Ele não liga para qual modelo senta no único ponto de decisão que ele deixou aberto.

Isso inverte o instinto padrão. O instinto, quando um sistema de agentes rende mal, é buscar um modelo maior e torcer para que a capacidade extra cubra a estrutura ausente. Os dois times fizeram o contrário e chegaram a um resultado que o modelo maior sozinho não produziria. A Anthropic usou modelos pequenos no grosso de uma migração de um milhão de linhas e gastou seu orçamento de inteligência na revisão adversarial. Jacob conseguiu 8x removendo chamadas de modelo. A alavanca esteve no loop o tempo todo.

Há uma consequência de governança que vale enunciar. Um modelo que você não consegue auditar se torna confiável no momento em que roda dentro de um harness que você consegue. O harness de paridade foi o que deixou a Anthropic entregar um runtime escrito por máquina com confiança: a correção foi afirmada por testes determinísticos, com a confiança no gerador fora da conta. É a mesma lógica que faz de harnesses para sistemas de longa duração a unidade de confiabilidade, em vez da chamada individual de agente.

Faça Isto Agora

Pegue um fluxo de agentes que você já roda em produção e audite-o contra uma única pergunta: onde o modelo está tomando uma decisão que uma função tipada poderia tomar no lugar?

Liste todo lugar onde o modelo é invocado. Para cada um, anote qual decisão ele toma e se essa decisão tem uma resposta certa que uma função poderia computar. Sequenciamento, roteamento, validação de formato, retentativas e coordenação entre passos quase nunca precisam de modelo. Se agentes no seu sistema conversam com outros agentes para decidir o que acontece a seguir, essa conversa é o seu pântano Garfield, e é a primeira coisa a mover para código determinístico.

Depois encontre a falha de maior frequência que seu agente produz e recuse-se a corrigir a saída. Rastreie-a até o passo do loop que a deixou passar. Se uma tradução está errada, o que falta é a regra ou a verificação de paridade; a linha de código é só o sintoma. Conserte o loop para que essa classe de falha não sobreviva à próxima execução, e você terá gasto sua hora construindo um ativo que compõe, em vez de remendar uma saída que não compõe.

O movimento vencedor para 2026 é um loop bom o suficiente para que um modelo menor consiga rodar dentro dele com segurança.

Fontes

Anthropic. “How Anthropic Runs Large-Scale Code Migrations with Claude Code.” Julho de 2026.
Adam Jacob (System Initiative). “A Practical Guide to Reducing Token Spend.” Julho de 2026.

A Victorino ajuda líderes de engenharia a transformar fluxos de agentes em harnesses determinísticos e auditáveis que seguem confiáveis conforme os modelos mudam: contato@victorino.com.br | www.victorino.com.br