A IA Que Se Pesquisa: O Segredo dos Agentes Autônomos

Claro! Aqui está o conteúdo reescrito e traduzido para Português do Brasil, na voz do Lucas Tech:

Pare de ‘Conversar’ com a IA! O Segredo por Trás da ‘Engenharia de Loops’ Que Fará Ela AGIR SOZINHA!

Olá, pessoal! Aqui é o Lucas Tech… E hoje a gente vai mergulhar em um conceito que está revolucionando como interagimos com a Inteligência Artificial. Se você ainda está digitando um prompt, lendo a resposta e depois digitando outro, prepare-se: você está prestes a descobrir como fazer a IA ir MUITO ALÉM e trabalhar de forma autônoma para você!

A maioria das pessoas ainda usa a IA como se fosse uma caixa de busca de 2015. Você digita, lê, digita de novo. Mas tem um jeito novo, muito mais potente, que troca esse vai e vem manual por um loop. Neste guia, vou te explicar o que é a tal da Engenharia de Loops na IA, baseada em trabalhos GIGANTES como o autoresearch do Andrej Karpathy e o paper Bilevel Autoresearch (que é tipo o próximo nível!). Peguei essa inspiração do @0xCodila no X. Se liga que isso vai mudar o jogo!

O Que Raios é Essa Tal de Engenharia de Loops?

Pra começar, vamos comparar dois jeitos de usar a IA. Um prompt é uma instrução única, e depois você decide o próximo passo. Já um loop é um objetivo que o modelo persegue até alcançar.

A IA, dentro de um loop, planeja, age, verifica o próprio resultado e repete! Você define o objetivo uma vez, e o loop se vira para iterar. O ponto chave aqui é que um loop só vale a pena se o trabalho for mensurável. Ou seja, se você consegue saber se a IA está melhorando ou não.

As 3 Peças Chave Que Fazem Um Loop Funcionar de Verdade

Então, o que diferencia um loop de verdade de um chatbot que só repete as coisas? Todo loop confiável tem três partes essenciais:

Um verificador que avalia cada tentativa. Pode ser um teste que passa, uma métrica que melhora ou um build bem-sucedido. Sem ele, a IA simplesmente concorda consigo mesma repetidamente, e não é isso que a gente quer, né?
Estado para registrar o que foi tentado, o que falhou e o que ainda falta. Um pequeno arquivo lateral permite que a próxima execução continue, em vez de recomeçar do zero. Pensa como um "histórico de trabalho" da IA.
Uma condição de parada para evitar custos descontrolados ou que a IA fique rodando para sempre. O loop para quando o objetivo é atingido, ou depois de um número N de tentativas. Essencial para não estourar o orçamento!

O Loop de Karpathy: Desvendando o `autoresearch`

Essas três partes não são só teoria, gente! No dia 7 de março de 2026 (sim, 2026, é coisa de futuro!), Karpathy lançou o autoresearch, um repositório open-source sob a licença MIT. Ele vem com três arquivos principais e cerca de 630 linhas de código. O projeto viralizou em dias e hoje tem quase 90.000 estrelas no GitHub. Não é pouca coisa! Depois, foi batizado como o famoso "Loop de Karpathy".

O design é super enxuto, mas rigoroso. O agente edita apenas o train.py, que contém o modelo GPT, o otimizador (Muon e AdamW) e o loop de treinamento. Ele não pode tocar nas utilities de avaliação em prepare.py. Essa separação impede que o agente facilite o teste em vez de realmente melhorar o modelo. Enquanto isso, um humano escreve o program.md, as instruções que o agente deve respeitar.

Cada ciclo executa um experimento. O agente lê o código, propõe uma mudança, treina por cinco minutos, e então decide se mantém ou volta atrás. A métrica de pontuação é o val_bpb (bits por byte de validação), e quanto menor, MELHOR! Esse orçamento de tempo permite cerca de 12 experimentos por hora, o que significa que uns 100 podem rodar durante a noite.

Os resultados relatados são CONCRETOS. Karpathy aplicou isso ao seu código nanochat GPT-2, já otimizado. Rodou por dois dias, completou cerca de 700 experimentos e manteve 20 melhorias genuínas! Juntas, essas correções reduziram o tempo de treinamento do GPT-2 em 11%, de 2,02 para 1,80 horas. É um ganho e tanto! Uma descoberta, por exemplo, foi uma implementação de QK-Norm que estava sem um multiplicador escalar, deixando a atenção muito difusa entre os heads.

Detalhe: humanos cansam depois de uma dúzia de experimentos, mas o loop… ah, o loop não! Separadamente, o CEO da Shopify, Tobi Lütke, rodou o autoresearch durante a noite em um modelo interno e relatou uma melhoria de 19% após 37 experimentos. O recado do Karpathy é claro: se você tem uma métrica objetiva, o gargalo é VOCÊ!

Prompt Simples vs. Loop vs. Loop de Nível Duplo: Qual a Diferença?

As diferenças ficam bem mais claras quando a gente coloca lado a lado:

Aspecto	Prompt Único	Loop de Karpathy (`autoresearch`)	Bilevel Autoresearch
Você define	Cada passo	O objetivo, uma vez	O objetivo, uma vez
Quem itera	Você	Agente interno	Agente interno + externo
Verificador	Você, manualmente	`prepare.py` (`val_bpb`)	Mesma métrica, dois níveis
Estado	Apenas no chat	Log de experimentos	Log mais código injetado
Papel do humano	Motor	Autor de `program.md`	Autor de `program.md`
Resultado relatado	Varia	700 execuções → 20 correções, 11% mais rápido	Queda 5x maior no `val_bpb`

Os 5 Blocos Essenciais Para Construir Seu Próprio Loop

Sendo assim, as equipes de engenharia de IA estão montando loops super eficientes usando cinco blocos de construção reutilizáveis:

A Automação que dispara o loop em um cronograma, evento ou gatilho.
Uma Habilidade que armazena o conhecimento do projeto em um arquivo markdown, lido a cada execução.
Sub-agentes que separam o ‘escritor’ do ‘revisor’, já que um modelo que se avalia sozinho tende a ser muito generoso.
Conectores que permitem que o loop aja dentro de ferramentas reais, como um sistema de tickets ou o Slack.
Por fim, o Verificador que continua sendo a porta de entrada que rejeita trabalhos ruins.

Ferramentas como Claude Code e Codex já trazem todos esses cinco elementos!

Bilevel Autoresearch: Um Loop Acima do Loop (A Meta-Pesquisa!)

Aí, os pesquisadores foram além e fizeram uma pergunta ainda mais instigante: se o autoresearch pesquisa, será que dá pra fazer autoresearch do autoresearch? O artigo Bilevel Autoresearch: Meta-Autoresearching Itself respondeu um sonoro SIM!

O loop interno é igual ao original do Karpathy: propõe, treina, avalia, mantém ou descarta. Já o loop externo observa o loop interno, lendo seu código e rastros. Ele identifica onde a própria busca está travando. Aí, ele escreve novos mecanismos em Python, injeta eles em tempo de execução e roda o loop interno de novo.

O resultado foi validado no benchmark de pré-treinamento GPT do Karpathy. O loop externo cortou o val_bpb 5 vezes mais do que o loop único (-0.045 vs -0.009). Impressionante, né? E o mais legal: ambos os loops usaram o MESMO LLM, então o ganho veio da arquitetura, não de um modelo mais ‘inteligente’!

Na prática, o design se divide em três níveis. O Nível 1 executa o loop base. O Nível 1.5 ajusta os parâmetros de busca a cada cinco iterações. E o Nível 2 gera os mecanismos através de uma sessão de quatro rodadas. Os experimentos relatados usaram uma RTX 5090 de 32GB e um orçamento de 300 segundos.

A razão é super importante: o loop interno ficava voltando para os mesmos ‘preconceitos’ (ou priors), mesmo depois que eles paravam de funcionar. O loop externo quebrou esses padrões forçando uma exploração BEM diferente.

Casos de Uso: Onde Mais Posso Aplicar Isso?

Essas ideias vão muito além do pré-treinamento, viu?

Para modelos de IA, um loop busca hiperparâmetros até o val_bpb cair.
Para software, ele refatora até que os testes, tipos e o build passem.
Para conteúdo, ele reescreve até que todas as pontuações da rubrica atinjam um limite.
Para dados, ele ajusta um pipeline até que as verificações de esquema funcionem.

Cada caso tem uma coisa em comum: um ‘portão’ automático que pode reprovar o trabalho.

Experimente Você Mesmo: Um Loop em Um Único Prompt!

Teoria é legal, mas você pode sentir a mecânica disso na prática, sem precisar de Claude Code ou Codex! Cole isso em qualquer modelo de IA capaz e veja ele se autocorrigir:

Você vai trabalhar em um loop até a tarefa atingir o nível desejado.

TAREFA:
[descreva EXATAMENTE o que você quer que seja produzido]

CRITÉRIOS DE SUCESSO (seja rigoroso):

[critério 1]
[critério 2]
[critério 3]

PROTOCOLO DO LOOP, repita a cada turno:

PLAN – declare o próximo passo único.
DO – produza ou melhore o trabalho.
VERIFY – pontue o resultado de 1 a 10 em cada critério. Seja honesto.
DECIDE – se cada critério for 8+, imprima FINAL e pare.
Caso contrário, imprima ITERATING e corrija o ponto mais fraco primeiro.

REGRAS:

Nunca considere concluído até que cada critério seja 8 ou superior.
Cada passagem deve corrigir a pontuação mais fraca da última VERIFICAÇÃO.
Não faça perguntas. Faça uma suposição sensata e continue.
Comece.

Por baixo dos panos, o fluxo de controle é simples. O esqueleto abaixo mostra essas três partes em Python: um verificador, uma decisão e duas condições de parada.

python
current = baseline
best = evaluate(current) # verificador: val_bpb menor é melhor
for step in range(MAX_STEPS): # condição de parada 1: orçamento de experimentos
candidate = propose_change(current) # agente edita train.py
score = train_and_eval(candidate) # treina 5 min, depois verifica
if score < best: # mantém apenas melhorias reais
current, best = candidate, score # confirma

else: descarta o candidato, restaura o baseline

if best <= TARGET:                   # condição de parada 2: objetivo atingido
    break

Ambas as versões são limitadas, claro. Você ainda é o gatilho, e fechar a aba apaga o estado. Mas adicionar automação, um arquivo de estado e um ‘portão’ de verdade transforma isso em um loop autônomo e poderoso!

Veja Acontecer na Prática!

A demonstração interativa abaixo mostra um loop completo em ação: propor, treinar, verificar, e então manter ou reverter. Ajuste o objetivo e o limite de passos, e veja o val_bpb cair até a condição de parada ser acionada. É top demais!

1){ cx.strokeStyle=”#76B900″; cx.lineWidth=2.2; cx.beginPath(); state.hist.forEach((v,i)=>{ i?cx.lineTo(X(i),Y(v)):cx.moveTo(X(i),Y(v)); }); cx.stroke(); // fill cx.lineTo(X(state.hist.length-1),H-18); cx.lineTo(X(0),H-18); cx.closePath(); cx.fillStyle=”rgba(118,185,0,.10)”; cx.fill(); // last point const li=state.hist.length-1; cx.fillStyle=”#5c9000″; cx.beginPath(); cx.arc(X(li),Y(state.hist[li]),3.4,0,7); cx.fill(); } } // ———- ui ———- function paintStats(){ $(‘s-exp’).innerHTML=state.exp+’/’+state.maxExp+’‘; $(‘s-best’).textContent=state.best.toFixed(4); $(‘s-kept’).textContent=state.kept; $(‘s-rb’).textContent=state.rb; } function clearStages(){stages.forEach(s=>s.className=”stage”);} function lit(i){clearStages(); stages[i].classList.add(‘on’);} function log(html,cls){ const d=document.createElement(‘div’); d.className=”ln”; d.innerHTML=html; const L=$(‘log’); L.appendChild(d); L.scrollTop=L.scrollHeight; } const sleep=ms=>new Promise(r=>setTimeout(r,ms)); // ———- the loop ———- async function runLoop(){ if(running) return; running=true; $(‘btn-run’).disabled=true; $(‘log’).innerHTML=”; log(‘$ agent: read program.md → start experiments‘); // reset run state, keep controls state.best=1.20; state.exp=0; state.kept=0; state.rb=0; state.hist=[1.20]; state.mechs=0; paintStats(); drawChart(); let improveScale=0.020; // typical improvement magnitude when a change helps let stuck=0; // consecutive no-gain runs (inner loop plateau) while(state.exp<state.maxexp state.best="">state.target){ state.exp++; // 01 propose lit(0); $(‘status’).textContent=”Experiment “+state.exp+’ · proposing a change to train.py…’; await sleep(220); // outer (bilevel) loop: every few stuck runs, inject a new search mechanism let injected=false; if(state.bilevel && stuck>=3){ state.mechs++; stuck=0; improveScale*=1.6; // illustrative: breaks the plateau injected=true; log(‘↻ outer loop: search stalled → injected mechanism #’+state.mechs+’ (explore new directions)‘); await sleep(340); } // 02 train (animate 5-min budget) lit(1); $(‘status’).textContent=”Experiment “+state.exp+’ · training (5-min budget)…’; const tb=$(‘tbar’); tb.style.width=”0%”; for(let p=0;p<=100;p+=8){ tb.style.width=p+’%’; await sleep(16); } // 03 verify — produce a candidate val_bpb lit(2); $(‘status’).textContent=”Experiment “+state.exp+’ · verifying val_bpb…’; await sleep(200); const helps=Math.random() < (state.bilevel?0.55:0.42); // fraction of changes that help let cand; if(helps){ const gain=improveScale*(0.4+Math.random()); cand=Math.max(state.target-0.02, state.best-gain); }else{ cand=state.best + Math.random()*0.03; // regression } // 04 decide if(cand < state.best-1e-6){ state.best=cand; state.kept++; stuck=0; stages[3].className=”stage pass”; stages[2].className=”stage pass”; log(‘exp ‘+String(state.exp).padStart(2,’0′)+’ · val_bpb ‘+cand.toFixed(4)+ ‘ ✓ KEEP‘+(injected?’ (post-inject)‘:”)); }else{ state.rb++; stuck++; stages[3].className=”stage fail”; stages[2].className=”stage fail”; log(‘exp ‘+String(state.exp).padStart(2,’0′)+’ · val_bpb ‘+cand.toFixed(4)+ ‘ ↻ ROLL BACK‘); } tb.style.width=”0%”; state.hist.push(state.best); paintStats(); drawChart(); await sleep(260); } clearStages(); const hit=state.best<=state.target; $(‘status’).textContent = hit ? ‘Stop condition: target reached at experiment ‘+state.exp+’.’ : ‘Stop condition: experiment budget (‘+state.maxExp+’) reached.’; log(‘— loop halted — best val_bpb ‘+state.best.toFixed(4)+ ‘ · kept ‘+state.kept+’ · rolled back ‘+state.rb+ (state.bilevel?(‘ · mechanisms injected ‘+state.mechs):”)); running=false; $(‘btn-run’).disabled=false; postHeight(); } function resetAll(){ if(running) return; state.best=1.20; state.exp=0; state.kept=0; state.rb=0; state.hist=[1.20]; state.mechs=0; clearStages(); $(‘tbar’).style.width=”0%”; $(‘log’).innerHTML=”; $(‘status’).textContent=”Ready. Press “Run loop” to start.”; paintStats(); drawChart(); } // ———- wire controls ———- $(‘i-target’).addEventListener(‘input’,e=>{state.target=+e.target.value; $(‘v-target’).textContent=state.target.toFixed(3); if(!running){paintStats();drawChart();}}); $(‘i-steps’).addEventListener(‘input’,e=>{state.maxExp=+e.target.value; $(‘v-steps’).textContent=state.maxExp; if(!running){paintStats();drawChart();}}); $(‘i-bilevel’).addEventListener(‘change’,e=>{state.bilevel=e.target.checked; $(‘tg’).classList.toggle(‘amberon’,e.target.checked); $(‘c-tag’).textContent=e.target.checked?’lower is better · bilevel on’:’lower is better’;}); $(‘btn-run’).addEventListener(‘click’,runLoop); $(‘btn-reset’).addEventListener(‘click’,resetAll); // ———- resize + auto-height for WordPress ———- function postHeight(){ const h=document.documentElement.offsetHeight+40; if(window.parent) window.parent.postMessage({loopDemoHeight:h},’*’); } function onResize(){fitCanvas(); drawChart(); postHeight();} window.addEventListener(‘resize’,onResize); // ———- init: real values on load ———- fitCanvas(); paintStats(); drawChart(); postHeight(); setTimeout(postHeight,300); })();</state.maxexp>

Minha Visão

Gente, a ‘Engenharia de Loops’ é o divisor de águas que a gente estava esperando para a IA. Chega de tratar esses modelos superpoderosos como meros assistentes de digitação. Com os loops, a gente dá autonomia real para a IA resolver problemas complexos, otimizar processos e, como o Karpathy bem disse, nos tira do gargalo!

Isso não é só uma melhoria; é uma mudança fundamental na forma como pensamos em desenvolvimento com IA. Significa que, em breve, teremos IAs que aprendem ativamente, corrigem seus próprios erros e evoluem sozinhas para atingir objetivos, liberando nosso tempo para desafios ainda maiores e mais criativos. É o futuro batendo na nossa porta, e ele parece INCRÍVEL!

E aí, o que você acha dessa revolução? Qual tarefa você gostaria que uma IA começasse a resolver de forma autônoma AGORA mesmo usando Engenharia de Loops?

Referência: Matéria Original