Loops de agentes: o que sobrou depois do hype do Ralph loop

Em 2025, Geoffrey Huntley batizou de Ralph loop uma ideia constrangedoramente simples: colocar um agente de código dentro de um while true de bash e deixar rodando. O nome vem do Ralph Wiggum, dos Simpsons — persistência alegre e ingênua. Ele provou o ponto deixando um agente construir uma linguagem de programação, compilador incluído, numa corrida longa sem supervisão.

O truque pegou. Virou post, virou palestra, virou pacote — a Vercel Labs chegou a publicar um ralph-loop-agent para o AI SDK. E, como todo truque que pega, passou por aquela fase em que virou resposta para tudo: “não precisa orquestrar nada, é só rodar em loop”.

Minha leitura, um ano depois: o hype esfriou, e ainda bem. Porque o que sobrou é a parte boa — e a parte boa não é o while true. É o que você coloca dentro dele.

O que o Ralph loop acertou de verdade

Três coisas, e todas continuam certas.

A primeira: contexto fresco a cada iteração. Cada volta abre um processo novo, com janela limpa. Isso ataca de frente a degradação de contexto longo, que é o modo de falha mais comum de agente de código. Foi exatamente o princípio que usamos ao construir o Relentless: a memória entre iterações não vive numa conversa infinita, vive no git.

A segunda: memória externa em disco. O estado sai da cabeça do agente e vai para arquivos, commits, artefatos — coisas que sobrevivem ao fim do processo e que um humano consegue ler.

A terceira: persistência barata bate genialidade cara. Vinte tentativas medianas com verificação entre elas costumam vencer uma tentativa brilhante sem verificação nenhuma. Isso é estatística, não filosofia.

Onde o loop burro queima dinheiro

O problema nunca foi o loop. Foi o loop sem nenhuma das três perguntas que importam: quando eu paro, como eu sei que melhorou, e quanto isso pode custar.

Sem critério de parada, o agente entra em oscilação. Já vi um loop passar a madrugada trocando uma abstração por outra e voltando para a primeira — commit A, commit B, commit A de novo — cada volta com contexto limpo, cada volta convencida de que estava consertando algo. Contexto fresco é uma faca de dois gumes: o agente não lembra que já tentou isso.

Sem verificação, o loop otimiza aparência. O agente “termina” a tarefa, o loop pergunta se acabou, o agente responde que sim porque o texto que ele escreveu parece uma conclusão. Autoavaliação em loop é uma máquina de gerar confiança sem gerar acerto.

Sem orçamento, o loop transforma um erro de julgamento em fatura. Deixar um agente rodando sem teto de tokens, tempo ou iterações é a versão 2026 de esquecer um cluster ligado no fim de semana. A diferença é que o cluster pelo menos não commita.

Loop com critério de parada: loop-until-dry

O padrão que mais uso é o que chamo de loop-until-dry. Você não roda até “estar pronto” — você roda até o loop ficar seco.

Uma rodada é seca quando ela não produz mudança material: nenhum arquivo relevante alterado, nenhuma tarefa fechada, nenhum teste novo passando. Uma rodada seca sozinha não decide nada, porque pode ser azar. Duas ou três rodadas secas seguidas — o K do critério — significam que a fonte de trabalho acabou de verdade. Aí você para.

O detalhe que faz diferença é medir secura no artefato, não na narrativa do agente. Diff vazio é seco. “Acredito que a implementação está completa” não é.

Loop com verificação: gerar, refutar, aceitar o que sobreviver

Loop bom não é gerar-e-repetir, é gerar-e-tentar-derrubar. A iteração vira um mini-processo adversarial: um passo produz o artefato, outro passo — com contexto próprio e objetivo invertido — tenta refutar. Só entra no repositório o que sobreviveu à tentativa de refutação.

A iteração só entrega o que sobrevive à tentativa de refutação — e o loop inteiro para quando K rodadas seguidas saem secas.

Isso muda o que o loop otimiza. Sem refutação, ele converge para o que parece pronto. Com refutação, ele converge para o que resiste. E o refutador mais barato quase nunca é um LLM: teste, compilador, type checker, linter e schema derrubam mais coisa por real gasto do que qualquer prompt de revisão.

É a mesma ideia de verificação adversarial que descrevi em grafos de agentes, só que aplicada no tempo em vez de no espaço.

Loop com orçamento: teto antes de começar

Todo loop que roda sem supervisão precisa de três tetos declarados antes da primeira volta: máximo de iterações, máximo de tokens (ou custo) e máximo de tempo de parede. E precisa de uma regra de saída para quando bater no teto — abrir um relatório do estado, não sumir no meio.

Três tetos declarados antes da primeira volta. Ao bater em qualquer um deles, o loop escreve o estado e para — não some no meio.

Orçamento também é uma decisão de arquitetura, não só de contabilidade. Quando você sabe quanto uma tarefa pode custar, você decide o modelo por nó em vez de usar o mais caro em tudo. Foi isso que virou o Smart Auto Mode do Relentless: escolher o modelo pela complexidade real da tarefa, não pelo medo de errar. A economia não vem de usar modelo pior — vem de parar de usar modelo caro para renomear variável.

Loop é o motor, grafo é o mapa

A discussão “loop ou grafo?” é falsa, e ela atrasou muita gente boa em 2025.

Grafo é topologia: quem depende de quem, o que pode rodar em paralelo, onde ficam as barreiras e os verificadores. Loop é dinâmica: quantas vezes um nó tenta antes de desistir, e o que faz o conjunto avançar até secar.

Eles se compõem em dois níveis. Dentro do nó, o loop é local — tenta, verifica, tenta de novo, com orçamento próprio e critério de parada próprio. Fora, o loop é global: o grafo inteiro roda de novo enquanto houver trabalho, e para quando K rodadas seguidas saem secas. Loop sem grafo é força bruta cara. Grafo sem loop é uma esteira que trava no primeiro nó teimoso e espera um humano.

Um ano depois do meme, é isso que sobrou do Ralph loop — e é bastante. Não a promessa de que persistência substitui arquitetura, mas a prova de que persistência estruturada é surpreendentemente forte. O while true era a parte fácil. Critério de parada, refutação e orçamento são o trabalho.

Se você já deixou um agente rodando a noite inteira e acordou com uma fatura e nenhum progresso, o problema não foi o loop. Foi a ausência das três perguntas. Fale com a gente ou conheça nossa consultoria agêntica — e se quiser ver o motor rodando, o Relentless é open source.