> Nível 10 de Agent Harness Patterns, uma trilha de padrões sobre como funcionam os agentes de IA. Versão web: https://harnesspatterns.dev/pt/patterns/fresh-laps · Todos os padrões (em inglês): https://harnesspatterns.dev/llms.txt

# Voltas limpas

Alguns trabalhos são longos demais para uma sessão. Rode-os em voltas: um agente novo a cada volta, e o progresso anotado onde o próximo consiga encontrar.

## O problema

Alguns trabalhos não cabem numa execução: migrar 300 arquivos, traduzir um catálogo inteiro, corrigir cada teste quebrado de um repositório. Cada passo acrescenta uma chamada de ferramenta e um resultado ao histórico, e o loop reenvia tudo isso a cada turno.

Esse é o Muddle, a sessão sem fim. À tarde ele já carrega cada passo desde a manhã: as requisições são enormes, os resultados antigos soterram os novos, e o modelo começa a refazer trabalho que já fez ou a pular trabalho que só tinha planejado. Nada quebra. A qualidade simplesmente vai escorrendo.

A compactação (nível 7) freia o Muddle. Mas não o detém: um trabalho longo o bastante acaba resumindo os próprios resumos.

## A solução

Não mantenha um único agente vivo durante o trabalho inteiro. **Rode em voltas**. A cada volta, o seu código inicia um agente novo com o histórico vazio e o mesmo objetivo. Ele faz uma fatia do trabalho, anota como as coisas ficaram e termina. Depois o seu código confere o trabalho em si e, se não estiver pronto, inicia a próxima volta.

- **Uma sessão longa**
   Manter o mesmo agente e o mesmo histórico durante o trabalho inteiro.
   Cada turno reenvia tudo desde o começo. As requisições ficam mais pesadas, o modelo tem mais dificuldade de achar o que importa nelas, e, passada a janela, ele quebra.
- **Compactar no caminho**
   A mesma sessão, mas encolhendo as mensagens antigas quando o histórico se aproxima do limite (nível 7).
   Ganha tempo, não resolve. Cada compactação perde detalhe, e um trabalho longo o bastante acaba compactando os próprios resumos.
- **Voltas limpas**
   Dividir o trabalho em voltas. Cada volta é um agente novo com o histórico vazio. O que ele precisa saber, ele lê de arquivos.
   Cada volta começa pequena e limpa. O preço: cada volta gasta um ou dois turnos para se situar, e os arquivos precisam dizer tudo o que importa.

O segredo é que nada importante vive no histórico. O trabalho está no disco (a ponte), e também uma nota curta dizendo até onde se chegou (`PROGRESS.md`). Um agente novo não precisa lembrar da volta anterior. Só precisa ler.

O padrão costuma ser chamado de **Ralph loop**, por causa de um one-liner de shell que passava a um agente de código o mesmo prompt de novo e de novo. Agentes de código o usam em refactors longos, com a árvore do git e um arquivo TODO como estado.

## O elenco

O mesmo elenco de sempre, desta vez num cânion.

- **O alçapão** (o seu código): Inicia um agente novo a cada volta (`createIterationAgent`) e recebe a resposta dele. É o loop em volta do loop.
- **O Astor de uma volta** (uma execução do agente): O loop do agente do nível 2, com o próprio bandoneón. Começa vazio e vai embora flutuando quando a volta termina.
- **A ponte** (o trabalho): O que as ferramentas mudaram no disco. Nenhuma volta joga isso fora.
- **A placa** (PROGRESS.md): Um recado curto de cada volta para a seguinte: o que está feito, o que vem depois.
- **DONE?** (isDone): A sua checagem, entre as voltas. Ela mede a ponte, não o que o modelo diz sobre ela.
- **LAP 3/5** (maxIterations): O fusível. Se o trabalho nunca passa na checagem, o loop para mesmo assim.

Observe as duas barras no topo. *Esta volta* é o quanto cada requisição pesa de verdade, e ela recomeça a cada volta. *1 sessão* é o quanto as mesmas requisições pesariam se um único agente tivesse feito as três voltas: ela nunca desce.

## O código

**Com astorlm:** `runGoalLoop` recebe uma fábrica que devolve um agente novo, a sua checagem `isDone` e um fusível `maxIterations`. As ferramentas escrevem em arquivos, então cada volta encontra o trabalho onde a anterior o deixou.

**Do zero:** O loop do nível 2, chamado dentro de um `for`. O histórico é uma variável local de cada chamada, então cada volta começa vazia de graça.

**Com astorlm**

```ts
import { OpenAIProvider, createLocalAgent, runGoalLoop, tool } from 'astorlm'
import { existsSync, readFileSync, writeFileSync } from 'node:fs'
import { z } from 'zod'

// Any OpenAI-compatible endpoint: OpenAI, Ollama, LM Studio, vLLM, a proxy…
const LLM = { baseURL: 'http://localhost:11434/v1', apiKey: 'YOUR_API_KEY' } // local servers usually ignore the key

// The state lives on disk, not in any history: the bridge, and a progress note.
const GAP = 36
const bridgeLength = (): number => (existsSync('bridge.json') ? JSON.parse(readFileSync('bridge.json', 'utf8')).length : 0)

const readProgress = tool({
  name: 'read_progress',
  description: 'Read PROGRESS.md: what earlier laps built, and where to start.',
  schema: z.object({}),
  execute: async () => (existsSync('PROGRESS.md') ? readFileSync('PROGRESS.md', 'utf8') : 'Nothing built yet.'),
})

const layBricks = tool({
  name: 'lay_bricks',
  description: 'Lay up to 12 bricks of the bridge, starting at brick number "from".',
  schema: z.object({ from: z.number().int().min(1), count: z.number().int().min(1).max(12) }),
  execute: async ({ from, count }) => {
    const to = Math.min(from + count - 1, GAP)
    writeFileSync('bridge.json', JSON.stringify({ length: Math.max(bridgeLength(), to) }))
    return `Laid bricks ${from}-${to}. The bridge is ${bridgeLength()} bricks long.`
  },
})

const writeProgress = tool({
  name: 'write_progress',
  description: 'Overwrite PROGRESS.md with where the bridge stands now, for whoever comes next.',
  schema: z.object({ text: z.string() }),
  execute: async ({ text }) => {
    writeFileSync('PROGRESS.md', `# Progress\n${text}\n`)
    return 'Saved PROGRESS.md.'
  },
})

const result = await runGoalLoop({
  goal: 'Build the bridge to the exit: 36 bricks. Read PROGRESS.md first, lay at most 12 bricks, then update PROGRESS.md.',
  // A NEW agent every lap: empty history, fresh context window. Same tools, same folder.
  createIterationAgent: () =>
    createLocalAgent({
      provider: new OpenAIProvider({ ...LLM, model: 'your-model' }), // e.g. 'llama3.1', 'gpt-4o-mini'
      tools: [readProgress, layBricks, writeProgress],
      maxTurns: 8,
    }),
  // Your code decides when the job is done, by checking the work itself. Not the model's word.
  isDone: () => bridgeLength() >= GAP,
  onIteration: ({ iteration, lastText }) => console.log(`lap ${iteration}: ${lastText}`),
  maxIterations: 5, // the fuse: a goal that never checks out can't run forever
})

console.log(result) // { iterations: 3, done: true, stopReason: 'done', lastText: '…' }
```

**TypeScript**

```ts
// Fresh laps, from scratch. Plain fetch and node:fs, no SDK.
import { existsSync, readFileSync, writeFileSync } from 'node:fs'

// Any OpenAI-compatible endpoint: OpenAI, Ollama, LM Studio, vLLM, a proxy…
const LLM = {
  baseURL: 'http://localhost:11434/v1', // e.g. Ollama's default address
  model: 'your-model', // e.g. 'llama3.1', 'gpt-4o-mini'
  apiKey: 'YOUR_API_KEY', // local servers usually ignore it
}

// 1. The state lives on disk: the bridge, and a progress note for the next lap.
const GAP = 36
const bridgeLength = (): number => (existsSync('bridge.json') ? JSON.parse(readFileSync('bridge.json', 'utf8')).length : 0)

type ToolFn = (args: Record<string, string | number>) => string
const tools: Record<string, ToolFn> = {
  read_progress: () => (existsSync('PROGRESS.md') ? readFileSync('PROGRESS.md', 'utf8') : 'Nothing built yet.'),
  lay_bricks: ({ from, count }) => {
    const to = Math.min(Number(from) + Math.min(Number(count), 12) - 1, GAP)
    writeFileSync('bridge.json', JSON.stringify({ length: Math.max(bridgeLength(), to) }))
    return `Laid bricks ${from}-${to}. The bridge is ${bridgeLength()} bricks long.`
  },
  write_progress: ({ text }) => {
    writeFileSync('PROGRESS.md', `# Progress\n${text}\n`)
    return 'Saved PROGRESS.md.'
  },
}
const toolSchemas = [/* one JSON Schema per tool: read_progress(), lay_bricks(from, count), write_progress(text) */]

type ToolCall = { id: string; function: { name: string; arguments: string } }
type Message =
  | { role: 'user'; content: string }
  | { role: 'assistant'; content: string | null; tool_calls?: ToolCall[] }
  | { role: 'tool'; tool_call_id: string; content: string }

// 2. The loop from level 2, unchanged. `messages` is born and dies inside each call.
async function runAgent(prompt: string, maxTurns = 8): Promise<string> {
  const messages: Message[] = [{ role: 'user', content: prompt }]
  for (let turn = 1; turn <= maxTurns; turn++) {
    const res = await fetch(`${LLM.baseURL}/chat/completions`, {
      method: 'POST',
      headers: { 'content-type': 'application/json', authorization: `Bearer ${LLM.apiKey}` },
      body: JSON.stringify({ model: LLM.model, messages, tools: toolSchemas }),
    })
    const [choice] = (await res.json()).choices
    const reply: Message = choice.message
    messages.push(reply)
    if (choice.finish_reason !== 'tool_calls') return reply.content ?? ''

    for (const call of reply.tool_calls ?? []) {
      const run = tools[call.function.name]
      let output = `Unknown tool: ${call.function.name}`
      try {
        if (run) output = run(JSON.parse(call.function.arguments))
      } catch (err) {
        output = `Error: ${err instanceof Error ? err.message : err}`
      }
      messages.push({ role: 'tool', tool_call_id: call.id, content: output })
    }
  }
  throw new Error(`No answer after ${maxTurns} turns`)
}

// 3. The goal loop: a fresh run per lap, then YOUR check of the work on disk.
const GOAL = 'Build the bridge to the exit: 36 bricks. Read PROGRESS.md first, lay at most 12 bricks, then update PROGRESS.md.'
const MAX_LAPS = 5 // the fuse

for (let lap = 1; lap <= MAX_LAPS; lap++) {
  console.log(`lap ${lap}:`, await runAgent(GOAL))
  if (bridgeLength() >= GAP) {
    console.log(`Done after ${lap} laps.`)
    break
  }
  if (lap === MAX_LAPS) throw new Error(`Bridge unfinished after ${MAX_LAPS} laps: ${bridgeLength()}/${GAP}`)
}
```

**Python**

```python
# Fresh laps, from scratch. Standard library only, no SDK.
import json
import urllib.request
from pathlib import Path

# Any OpenAI-compatible endpoint: OpenAI, Ollama, LM Studio, vLLM, a proxy...
LLM = {
    "base_url": "http://localhost:11434/v1",  # e.g. Ollama's default address
    "model": "your-model",  # e.g. "llama3.1", "gpt-4o-mini"
    "api_key": "YOUR_API_KEY",  # local servers usually ignore it
}

def post(path, payload):
    request = urllib.request.Request(
        f"{LLM['base_url']}{path}",
        data=json.dumps(payload).encode(),
        headers={"Content-Type": "application/json", "Authorization": f"Bearer {LLM['api_key']}"},
    )
    with urllib.request.urlopen(request) as response:
        return json.load(response)

# 1. The state lives on disk: the bridge, and a progress note for the next lap.
GAP = 36
BRIDGE = Path("bridge.json")
PROGRESS = Path("PROGRESS.md")

def bridge_length():
    return json.loads(BRIDGE.read_text())["length"] if BRIDGE.exists() else 0

def read_progress():
    return PROGRESS.read_text() if PROGRESS.exists() else "Nothing built yet."

def lay_bricks(start, count):
    end = min(start + min(count, 12) - 1, GAP)
    BRIDGE.write_text(json.dumps({"length": max(bridge_length(), end)}))
    return f"Laid bricks {start}-{end}. The bridge is {bridge_length()} bricks long."

def write_progress(text):
    PROGRESS.write_text(f"# Progress\n{text}\n")
    return "Saved PROGRESS.md."

TOOLS = {
    "read_progress": read_progress,
    "lay_bricks": lambda **args: lay_bricks(args["from"], args["count"]),  # "from" is a Python keyword
    "write_progress": write_progress,
}
TOOL_SCHEMAS = [...]  # one JSON Schema per tool: read_progress(), lay_bricks(from, count), write_progress(text)

# 2. The loop from level 2, unchanged. `messages` is born and dies inside each call.
def run_agent(prompt, max_turns=8):
    messages = [{"role": "user", "content": prompt}]

    for _ in range(max_turns):
        choice = post("/chat/completions", {"model": LLM["model"], "messages": messages, "tools": TOOL_SCHEMAS})["choices"][0]
        reply = choice["message"]
        messages.append(reply)
        if choice["finish_reason"] != "tool_calls":
            return reply.get("content") or ""

        for call in reply.get("tool_calls", []):
            try:
                output = TOOLS[call["function"]["name"]](**json.loads(call["function"]["arguments"]))
            except Exception as err:
                output = f"Error: {err}"
            messages.append({"role": "tool", "tool_call_id": call["id"], "content": output})

    raise RuntimeError(f"No answer after {max_turns} turns")

# 3. The goal loop: a fresh run per lap, then YOUR check of the work on disk.
GOAL = "Build the bridge to the exit: 36 bricks. Read PROGRESS.md first, lay at most 12 bricks, then update PROGRESS.md."
MAX_LAPS = 5  # the fuse

for lap in range(1, MAX_LAPS + 1):
    print(f"lap {lap}:", run_agent(GOAL))
    if bridge_length() >= GAP:
        print(f"Done after {lap} laps.")
        break
else:
    raise RuntimeError(f"Bridge unfinished after {MAX_LAPS} laps: {bridge_length()}/{GAP}")
```

## O que observar

- **Confira o trabalho, não a resposta.** Um “Pronto!” do modelo não prova nada. O `isDone` deve olhar o resultado em si: rodar os testes, contar as linhas, medir a ponte. Mantenha-o barato e determinístico, porque ele roda depois de cada volta.
- **Sempre coloque o fusível.** Uma checagem que nunca pode passar, ou um agente que vive desfazendo o próprio trabalho, fica dando voltas até a sua fatura pará-lo. `maxIterations`, e uma olhada no motivo de ele ter se esgotado.
- **O arquivo de progresso é a única passagem de bastão.** O que ele deixar de fora, a próxima volta não sabe. Diga ao agente exatamente o que escrever ali: o que está feito, o que vem a seguir, o que ele tentou e falhou.
- **Torne cada passo seguro de repetir.** Uma volta pode morrer no meio, depois do trabalho mas antes do recado. A próxima volta vai fazer aquela fatia de novo, então fazê-la duas vezes não pode quebrar nada.
- **Mantenha as fatias pequenas.** Uma volta deveria caber numa execução curta. Se uma única fatia já precisa de compactação, as fatias estão grandes demais.

## Padrões relacionados

- [4 · Quando parar](https://harnesspatterns.dev/pt/patterns/when-to-stop.md)
- [7 · A mochila enche](https://harnesspatterns.dev/pt/patterns/compaction.md)
- [9 · Memória](https://harnesspatterns.dev/pt/patterns/memory.md)
- [12 · Planejar e refletir](https://harnesspatterns.dev/pt/patterns/plan-and-reflect.md)
- [16 · Agentes proativos](https://harnesspatterns.dev/pt/patterns/proactive-agents.md)