🔁 Anatomia do loop

Todo loop de agente decente segue o mesmo esqueleto de cinco passos: descobrir (juntar o contexto que falta), planejar (decidir o proximo movimento), agir (executar — rodar codigo, chamar uma ferramenta, escrever), verificar (checar se o resultado presta) e parar (sair do loop, com sucesso ou desistencia). Cada um desses cinco e um no. O loop inteiro e um grafo.

O que olhar: siga a seta de "verificar" que volta pra "descobrir" — essa e a aresta que fecha o ciclo e transforma a fila de passos num loop de verdade. A outra saida, pra "parar", e o que impede o grafo de rodar pra sempre. Sem as duas setas saindo de "verificar", voce nao tem um loop, tem um DAG disfarcado.

Existem dois jeitos de um loop parar: por sucesso (o verificador aprovou) ou por desistencia (bateu um teto e o loop nao vai passar mesmo insistindo). Um loop que so sabe parar por sucesso e um loop que pode rodar pra sempre — voce precisa das duas saidas, nao so de uma.

Cada volta do loop tem acesso a uma janela de contexto — a quantidade de texto que o modelo consegue "ver" de uma vez, contando prompt, historico e resultado das ferramentas. A pergunta que voce precisa responder antes de escrever o loop e: o que atravessa de uma volta pra outra, e o que fica pra tras?

Essa decisao — o que fica, o que sai, como resumir o que sai — e o embrião do que a Trilha 4 vai chamar de state schema: uma definicao explicita e nomeada do que viaja entre nos. Num loop simples voce pode ate decidir isso informalmente. Num grafo com varios nos, informal nao aguenta.

Existe uma versao radicalmente simples de loop que ficou popular: rodar o mesmo prompt repetidas vezes ate o objetivo ser alcancado, sem mudar nada entre as voltas alem do que o proprio agente escreveu em arquivos. Essa tecnica foi popularizada a partir do metodo Ralph, de Geoffrey Huntley — daí o apelido "Ralph loop" que voce vai ouvir por ai.

Um loop fechado mede o efeito do que acabou de fazer e usa essa medida pra decidir a proxima volta — isso se chama realimentação (em ingles, feedback): o resultado de uma acao volta como entrada da proxima. Um loop aberto so executa, sem olhar pra tras.

E aqui mora um limite que vale gravar: a qualidade da medida e o teto de qualidade do loop inteiro. Se o seu verificador so checa "o codigo rodou sem erro" mas nao "o codigo faz o que devia", seu loop fechado converge (chega numa resposta estavel) — so que converge pra a coisa errada. Fechar o loop nao basta; fechar bem e o trabalho.

Nada impede um loop de conter outro loop dentro de si. O loop externo decide o que fazer (qual tarefa pegar a seguir), o loop interno executa como fazer aquela tarefa especifica ate o proprio verificador dela passar. Cada volta do loop externo vira, ela mesma, um no no grafo maior.

O que olhar: a caixa grande tem sua propria seta de volta — e um loop. Cada caixa pequena dentro dela tambem tem uma seta de volta — outro loop, escondido dentro do primeiro no. Isso e aninhamento: um loop cujos nos, quando voce abre, sao eles mesmos loops inteiros.

// condicao de parada em camadas: criterio + teto
function loop(tarefa, verificar, agir, MAX_VOLTAS = 5) {
  let contexto = { tarefa, tentativas: [] };
  for (let volta = 1; volta <= MAX_VOLTAS; volta++) {
    // descobrir + planejar (aqui simplificados: so olham o contexto)
    const plano = "tentativa " + volta + " para: " + contexto.tarefa;

    // agir
    const resultado = agir(plano, contexto);
    contexto.tentativas.push(resultado);

    // verificar
    if (verificar(resultado)) {
      return { status: "sucesso", volta, resultado };  // parar por sucesso
    }
  }
  return { status: "desistencia", volta: MAX_VOLTAS };  // parar por teto
}

// exemplo concreto: "adivinhar" um numero
const alvo = 7;
const r = loop(
  "achar o numero " + alvo,
  (res) => res === alvo,
  (plano, ctx) => ctx.tentativas.length + 3   // tenta 3, 4, 5, 6, 7...
);
console.log(r);