🔁 Anatomy of a loop

Every decent agent loop follows the same five-step skeleton: discover (pull in the missing context), plan (decide the next move), act (execute — run code, call a tool, write), verify (check whether the result is any good) and stop (exit the loop, either successfully or by giving up). Each of these five is a node. The entire loop is a graph.

What to look at: follow the "verify" arrow back to "discover" — this is the edge that closes the cycle and turns the queue of steps into a real loop. The other exit, to "stop", is what keeps the graph from running forever. Without both arrows leaving "verify," you don't have a loop; you have a disguised DAG.

There are two ways for a loop to stop: on success (the verifier approved) or by giving up (hit a limit and the loop won't get past it, no matter how much you insist). A loop that only knows how to stop on success is a loop that can run forever—you need both outcomes, not just one.

Each iteration of the loop has access to a context window — the amount of text the model can "see" at once, including the prompt, history, and tool results. The question you need to answer before writing the loop is: what carries over from one iteration to the next, and what gets left behind?

This decision—what stays, what gets removed, and how to summarize what’s removed—is the seed of what Track 4 will call state schema: an explicit, named definition of what travels between us. In a simple loop, you can decide this informally. In a graph with multiple nodes, informal doesn’t hold up.

There is a radically simple version of a loop that became popular: run the same prompt repeatedly until the goal is reached, without changing anything between rounds except what the agent itself wrote to files. This technique was popularized through the method Ralph, by Geoffrey Huntley — hence the nickname "Ralph loop" you’ll hear around.

A loop closed measures the effect of what it just did and uses that measure to decide the next iteration—this is called feedback (in English, feedback): the result of one action becomes the input for the next. A loop open just executes, without looking back.

And here’s a limit worth remembering: the quality of the measure is the quality ceiling for the entire loop. If your verifier only checks “the code ran without errors” but not “the code does what it’s supposed to,” your closed loop converges (reaches a stable answer)—but it converges on the wrong thing. Closing the loop isn’t enough; closing it well is the work.

Nothing prevents a loop from containing another loop. The outer loop decides what do (which task to pick up next), the inner loop runs how do that specific task until its own verifier passes. Each turn of the outer loop becomes a node in the larger graph itself.

What to look at: the large box has its own return arrow—it’s a loop. Each small box inside it also has a return arrow—another loop, hidden inside the first one. That’s nesting: a loop whose nodes, when you open them, are themselves entire loops.

// 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);