Pare o loop quando ele terminar ou travar
Cerca de 22 minutos min de leitura, com 4 exemplos em 6 seções.
Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros
Traduzido do livro em inglês, edição 2026.11.2. Leia o original
Ao final deste capítulo, você saberá dizer por que qualquer execução parou, a partir da única palavra que o harness registra para ela, e acrescentar as duas regras que encerram uma execução que deixou de progredir.
Capítulo 1 construiu um loop que encerra uma execução de uma de três formas: o modelo chama finish, a execução atinge o limite de 8 passos, ou o modelo deixa de fazer chamadas por duas vezes. Isso cobre um modelo que termina. Não cobre um modelo que continua enviando a mesma edição, o que acontece quando uma edição não consegue encontrar o texto que procura. As ferramentas do capítulo 1 não têm edição, então esse caso vem do conjunto de tarefas: as 20 tarefas que testar o agente avalia, executadas com o conjunto de ferramentas v1, cujas ferramentas incluem edições. No caso em execução, unitcraft, uma pequena biblioteca de unidades cuja suíte visível informa uma contagem após cada alteração, uma execução travada desse tipo chega ao limite, e o único registro do seu fim é o de que o limite a encerrou. Cada passo perdido é uma chamada ao modelo e uma linha na transcrição que um revisor precisa ler. Este capítulo nomeia as formas como o loop encerra uma execução, acrescenta duas regras que encerram uma execução travada antes, e mede o que elas fazem no conjunto de tarefas.
Formas como uma execução termina
Toda execução termina por um motivo declarado, e o harness grava esse motivo no campo ended da execução. Dois dos motivos são escolha do modelo: ele chama finish para encerrar a execução, ou chama ask_user com uma pergunta para a pessoa. Três são limites definidos pelo harness: o orçamento de passos, a regra de chamada repetida e a regra de falta de progresso. O sexto, no_tool_call, é definido por um modelo que não faz chamada. O loop define esses seis, e portões de permissão acrescenta um sétimo no capítulo 6. A tabela lista os seis.
ended |
Definido quando | Exibido por |
|---|---|---|
finish |
o modelo chama finish, o que encerra a execução |
as contagens do conjunto de tarefas |
ask_user |
o modelo chama ask_user com uma pergunta, e nenhuma mudança é feita |
as contagens do conjunto de tarefas |
step_cap |
a execução atinge o seu orçamento de passos | budget-stops-a-loop |
repeated_call |
a mesma chamada aparece três vezes seguidas | repeated-call-stops |
no_progress |
duas edições seguidas deixam as contagens de testes onde estavam | no-progress-stops |
no_tool_call |
o modelo não faz chamada duas vezes seguidas | as contagens do conjunto de tarefas, onde ele é 0 |
As contagens do conjunto de tarefas são as linhas que o último exemplo de perguntar, parar e contar imprime. No conjunto de ferramentas v1, que o conjunto de tarefas usa, finish recebe apenas um resumo: encerra a execução com um resumo das edições que ela já tinha feito na sua cópia de trabalho, e não grava nenhum arquivo. O finish do capítulo 1 também gravou um arquivo antes de encerrar a execução. Os conjuntos de ferramentas que este capítulo mede não fazem isso.
Quando mais de um encerramento se aplica no mesmo passo, o loop os verifica em uma ordem fixa. Uma chamada finish ou ask_user é tratada primeiro, depois a regra de chamada repetida e, em seguida, a regra de falta de progresso. O orçamento se aplica quando o loop fica sem passos, por isso é verificado por último. A ordem importa apenas no passo em que dois encerramentos coincidem, e o restante do capítulo se limita ao caso único.
Uma resposta sem chamada recebe uma nova tentativa. Uma segunda resposta sem chamada seguida encerra a execução como no_tool_call. Nenhum exemplo deste capítulo chega a esse ponto, então nada aqui depende dele.
Cada encerramento é um valor, e não uma frase na última resposta, de modo que um relatório pode dizer qual deles aconteceu sem ler essa resposta. Em produção, a diferença entre esses encerramentos é difícil de ver de fora. Uma execução que termina em step_cap parece uma execução lenta que não concluiu, e quem revisa apenas a mensagem final não consegue distingui-la de uma execução que estava prestes a terminar. O valor ended é o que mostra a diferença em um relatório, e é a primeira coisa a verificar quando uma execução custa mais do que a sua tarefa deveria.
Os nomes importam além deste capítulo. Portões de permissão é onde a mudança proposta por uma chamada finish espera até que uma pessoa diga sim. Subagentes e repasses transforma uma parada em uma pergunta para uma pessoa, e testando o agente conta os encerramentos. Cada um deles lê esses valores, então um nome alterado aqui mudaria ali também.
Listamos os encerramentos que o harness consegue observar, e não todo motivo pelo qual uma execução pode falhar. Um modelo que dá uma resposta errada e chama finish termina como finish, e só a verificação, o teste oculto que pontua a cópia final, mostra que ele falhou. Por isso a contagem de concluídos vem da verificação, e não do valor ended, ponto que a regra prática abaixo retoma. A documentação do Agent SDK, Como o loop do agente funciona, descreve seus encerramentos da mesma forma: uma execução que atinge o limite de turnos termina com um resultado cujo subtipo é error_max_turns e sem resposta final. Nesse SDK, um turno é uma passagem pelo seu loop, isto é, uma resposta do modelo com as suas chamadas de ferramenta, e max_turns conta essas passagens mais uma para a resposta final só de texto. Aqui, essa passagem é um passo. Este livro reserva "turno" para uma troca com a pessoa que deu a tarefa. A mesma página alerta que um loop sem limite pode rodar por muito tempo em prompts abertos. O livro não usa o SDK, então citamos essa página pelo desenho, e não por algum código.
Regra prática: Registre um valor ended com cada execução, e nunca informe o resultado de uma execução sem ele. Conte uma execução como concluída pela regra em a pontuação, nunca apenas pelo seu valor ended.
O orçamento conta passos
Um modelo que nunca chama finish não dá ao laço nenhum motivo para parar, então o laço precisa de uma contagem que dê esse motivo. Um passo é uma chamada ao modelo e a resposta que ele devolve. O orçamento de passos é o máximo de passos que uma execução pode dar, e o laço para ao atingir esse número. Os passos são contados, não cronometrados: o laço não lê relógio nenhum.
O conjunto de tarefas, as 20 tarefas que o último exemplo deste capítulo conta, roda sobre o conjunto de ferramentas v1 com orçamento de 16 passos. O capítulo 1 usa um orçamento menor, 8.
A gravação da T-01 no capítulo 1 mostra o orçamento em ação. O modelo, Qwen3-4B-Instruct-2507, é um modelo aberto, e suas respostas foram gravadas e são reproduzidas aqui, de modo que toda execução deste capítulo recebe a mesma saída em qualquer máquina. Nesse registro, o modelo não terminou dentro de oito passos. Seu último passo foi uma chamada de ferramenta malformada, que o harness recusou. Reproduza a execução sob o orçamento, sem nenhuma outra regra, e a saída mostra onde o limite a encerra:
1"""The chapter 1 recorded run of T-01 under its step budget of 8. The budget ends the run as step_cap, with no finish;2the last line shows the model's final step, a call the harness refused, and the budget ended the run after it."""3from lib.case import load_tasks4from lib.loop import run_task5from lib.models import ReplayModel6from lib.tools import CH17from lib.trace import IdCounter89task = load_tasks(only=["T-01"])[0]10run = run_task(ReplayModel("chapter-1-t01", "T-01"), task, CH1, max_steps=CH1.step_cap, ids=IdCounter())11print("budget (steps):", CH1.step_cap)12print("steps:", run.steps)13print("tool calls:", run.tool_calls)14print("ended:", run.ended)15print("last step:", run.trace.lines()[-1])16assert run.ended == "step_cap" and run.steps == CH1.step_cap, "the budget should stop the run on step 8"17assert not run.summary, "a budget stop carries no summary"
python budget-stops-a-loop.pybudget (steps): 8
steps: 8
tool calls: 8
ended: step_cap
last step: step 8: malformed: error: malformed call
A execução termina como step_cap após 8 passos, com 8 chamadas de ferramenta, contra um orçamento de 8. As duas contagens coincidem porque cada passo fez uma requisição. A linha que importa é a última. A última resposta do modelo foi uma chamada que o harness não conseguiu interpretar, e o orçamento foi a única coisa que encerrou a execução. Nada no registro diz que o modelo tinha terminado.
Um orçamento de passos não limita o tempo, nem limita os tokens. Uma ferramenta que trava mantém seu passo aberto até retornar, então o tempo limite pertence ao sandbox, em sandbox e segredos. Uma resposta longa usa mais tokens dentro de um único passo, e contar tokens é trabalho de orçamentos de contexto. O orçamento limita apenas as chamadas ao modelo e nada mais, então uma execução que o atinge usou suas chamadas, e nada mais se sabe sobre o motivo.
Respostas malformadas também contam. Uma resposta que o harness não consegue interpretar ainda é uma chamada ao modelo, então gasta um passo, e o orçamento a conta. Um modelo que continua produzindo chamadas que o harness não consegue ler chega ao orçamento com a mesma certeza que um que continua repetindo uma chamada válida. Os dois terminam como step_cap, então só os últimos passos mostram qual dos dois aconteceu: uma boa chamada repetida, ou chamadas que o harness não conseguiu ler.
Regra prática: Defina o orçamento de passos a partir de execuções nas suas próprias tarefas, não a partir de um palpite. Tome o maior número de passos que uma execução bem-sucedida precisou, deixe folga acima dele e escreva no código para que serve essa folga.
A mesma chamada, de novo
Um modelo que viu uma ferramenta falhar pode enviar a mesma chamada várias vezes, e o laço executará cada uma até que o orçamento encerre a execução. É tentador pensar que o modelo vai perceber que está em loop. O artigo do ReAct, de Yao e colaboradores (2022, publicado na ICLR 2023), relata a repetição como um padrão frequente de erro: nas execuções de perguntas e respostas, o modelo gerava repetidamente pensamentos e ações que já havia produzido. As tarefas do artigo são de perguntas e respostas e de tomada de decisão, não de código; portanto, ele nos dá um motivo para observar a repetição, mas nenhuma taxa para ela. ReAct: Synergizing Reasoning and Acting in Language Models é a fonte. O harness precisa detectar a repetição por conta própria.
A regra que o livro usa é simples. Três chamadas idênticas seguidas encerram a execução com repeated_call. Uma chamada é idêntica quando tem o mesmo nome de ferramenta e os mesmos argumentos, comparados com as chaves ordenadas. A ordenação importa. Duas respostas podem trazer os mesmos argumentos com as chaves em ordem diferente, e então o texto bruto difere, mesmo que a chamada não difira. Na versão de Python que o livro fixa, 3.12.15, json.dumps produz duas strings diferentes para as mesmas duas chaves em duas ordens, plain dumps equal: False, e uma única string quando as chaves são ordenadas, sort_keys dumps equal: True. Trata-se de uma verificação que executamos, não de um exemplo deste livro; leia-a como uma checagem que você pode repetir.
Três é o limite deste livro, não um valor fixo. Trata-se de um julgamento, e a regra prática abaixo diz quando alterá-lo. Uma chamada analisada que difere da anterior reinicia a contagem, e o mesmo vale para uma resposta com um bloco de chamada malformado, que não tem chamada analisada para comparar. Uma resposta cortada no limite de tokens, ou uma resposta sem chamada, mantém a sequência como estava. O laço pula a verificação de sequência nessas respostas, de modo que chamadas idênticas de cada lado delas continuam contando juntas.
T-01 nunca envia a mesma chamada três vezes seguidas, então este exemplo reexecuta T-02, em que o modelo faz isso:
1"""The recorded run of T-02 with and without the repeated-call rule. Three identical calls in a row end the run as2repeated_call. The rule compares the name and the sorted arguments, so reordered keys still count as the same call."""3from lib.case import load_tasks4from lib.loop import Stops, run_task5from lib.models import ReplayModel6from lib.tools import V17from lib.trace import IdCounter89task = load_tasks(only=["T-02"])[0]101112def replay(stops: Stops):13 ids = IdCounter()14 ids.next("run") # the recording numbers its runs in task order, so T-02 is run-0002: skip T-01's number15 return run_task(ReplayModel("task-set", "T-02"), task, V1, max_steps=V1.step_cap, ids=ids, stops=stops)161718plain = replay(Stops())19print("without the rule, ended:", plain.ended, "at step", plain.steps)20run = replay(Stops(repeat_limit=3))21print("with the rule, ended:", run.ended, "at step", run.steps)22print("repeated call:", run.stuck_on)23print("first of the identical calls: step", run.streak_from)24print("identical calls in a row:", run.steps - run.streak_from + 1)25print("last two steps:", *run.trace.lines()[-2:], sep="\n ")26assert run.ended == "repeated_call" and run.streak_from == 11 and run.steps == 13
python repeated-call-stops.pywithout the rule, ended: step_cap at step 16
with the rule, ended: repeated_call at step 13
repeated call: edit_file
first of the identical calls: step 11
identical calls in a row: 3
last two steps:
step 12: edit_file: error: old text not found in unitcraft/format.py
step 13: edit_file: error: old text not found in unitcraft/format.py
Sem a regra, a execução termina como step_cap at step 16. Com ela, termina como repeated_call at step 13. O ponto está nos últimos passos: a mesma chamada edit_file, enviada de novo, falhando a cada vez com old text not found in unitcraft/format.py. A primeira das chamadas idênticas ocorreu em step 11, e a contagem chegou a 3 seguidas antes que a regra encerrasse a execução. O exemplo afirma o encerramento e o passo em que ele para, de modo que uma mudança que desloque a parada faz a execução falhar, em vez de alterar silenciosamente a saída impressa.
Um modelo que alterna uma leitura com uma edição nunca aciona esta regra, porque cada leitura quebra a sequência. A próxima regra é para esse caso.
A regra trata da mesma chamada bem formada voltando inalterada. Uma resposta quebrada é uma falha diferente, e esquemas de ferramentas é onde uma chamada ruim volta como um erro tipado que o modelo consegue ler.
Regra prática: Compare chamadas pelo nome da ferramenta e pelos argumentos ordenados, e encerre a execução em três chamadas idênticas seguidas. Aumente o limite somente depois que seus próprios rastros mostrarem três chamadas idênticas seguidas que estavam fazendo progresso. Então meça o número maior no seu conjunto de tarefas antes de mantê-lo.
Nenhum progresso entre edições
Um modelo que alterna leituras com edições nunca envia a mesma chamada três vezes seguidas, então a regra de chamada repetida não tem o que contar, mesmo quando a execução não avança. O sinal adequado para esse caso são as contagens de testes. Após cada edição, o harness executa os testes visíveis, a suíte de testes do próprio caso, na cópia de trabalho, e guarda a linha de contagens do resumo que ele monta, como 8 failed, 22 passed. O modelo nunca vê essa execução. O harness a mantém para a sua própria decisão.
Esse é o tipo de sinal que a orientação em Construindo agentes eficazes pede. Ela afirma ser crucial que um agente obtenha a verdade de referência do ambiente em cada etapa, e uma contagem de testes é verdade de referência desse tipo. A orientação é uma opinião de um artigo de dezembro de 2024, não uma medição.
A regra mantém uma contagem de edições seguidas que deixam as contagens inalteradas. A primeira edição é comparada com as contagens de antes de qualquer edição. Uma edição que altera as contagens zera a contagem. Uma leitura não a afeta. Duas seguidas encerram a execução como no_progress. Uma edição que falha deixa o arquivo como estava, então suas contagens permanecem iguais, e a regra a conta como falta de progresso.
Execute o T-01 da gravação do conjunto de tarefas, que usa o conjunto de ferramentas v1 e cujas edições falham, duas vezes: uma sem regras e outra com a regra de nenhum progresso definida para duas edições. Observe onde cada execução termina:
1"""The recorded run of T-01 under the no-progress rule. Two edits in a row that leave the test counts where they2were end the run as no_progress. The counts come from the harness's own run of the visible tests after each edit."""3from lib.case import load_tasks4from lib.loop import EDITS, Stops, run_task5from lib.models import ReplayModel6from lib.tools import V17from lib.trace import IdCounter89task = load_tasks(only=["T-01"])[0]101112def replay(stops: Stops):13 return run_task(ReplayModel("task-set", "T-01"), task, V1, max_steps=V1.step_cap, ids=IdCounter(), stops=stops)141516plain = replay(Stops())17print("without the rule, ended:", plain.ended, "at step", plain.steps)18run = replay(Stops(no_progress_limit=2))19print("with the rule, ended:", run.ended, "at step", run.steps)20edit_steps = [r["step"] for r in run.trace.records if r["tool"] in EDITS]21print("edits that left the counts unchanged, steps:", " and ".join(str(step) for step in edit_steps[-2:]))22print("counts after the last edit:", run.counts)23print("last two steps:", *run.trace.lines()[-2:], sep="\n ")24assert run.ended == "no_progress" and run.steps == 5
python no-progress-stops.pywithout the rule, ended: step_cap at step 16
with the rule, ended: no_progress at step 5
edits that left the counts unchanged, steps: 3 and 5
counts after the last edit: 8 failed, 22 passed
last two steps:
step 4: read_file: 23 lines
step 5: edit_file: error: old text not found in unitcraft/format.py
Sem a regra, a execução termina como step_cap at step 16. Com ela, termina como no_progress at step 5, na segunda de duas edições que deixaram as contagens inalteradas. Essas edições estão em 3 and 5. As duas falharam com old text not found, portanto nenhuma alterou as contagens, que permaneceram em 8 failed, 22 passed. As duas últimas etapas da saída são uma leitura e essa segunda edição que falhou. A leitura fica entre as duas edições e não zera a contagem, e é por isso que a regra pode disparar em edições que não estão lado a lado na transcrição.
A regra lê uma única linha do resumo dos testes: a linha de contagens, como 8 failed, 22 passed. Ela não lê qual teste falhou. Uma edição que corrige um teste e quebra outro, com a mesma contagem, parece, por isso, falta de progresso. Comparar o arquivo também não ajuda. Uma edição que falha deixa o arquivo inalterado, mas uma edição que de fato o altera ainda pode deixar as contagens iguais. Mantemos as contagens porque o harness consegue compará-las sem ler os nomes dos testes. Verifique essa escolha em suas próprias execuções, nas quais a troca de uma falha por outra apareceria como uma parada.
Duas edições que falharam bastam para parar esta execução, embora uma terceira edição pudesse ter funcionado. Escolhemos duas, e o livro não afirma com que frequência uma execução interrompida dessa forma teria prosseguido até o sucesso. No conjunto de tarefas, 11 execuções terminaram assim, e nenhuma delas está concluída, segundo a regra em a pontuação.
A edição que falha é a falha que os esquemas de ferramentas tratam. O capítulo 3 muda o que uma edição que não encontra o seu texto devolve: as linhas mais próximas do arquivo, para que o modelo possa corrigir o seu texto em vez de enviá-lo de novo, como mostra erros de edição que nomeiam as linhas mais próximas.
Regra prática: Acompanhe as contagens que o harness recebe dos testes após cada edição, e não o que o modelo diz ter alterado. Interrompa uma execução após duas edições seguidas que deixem as contagens inalteradas. Registre-a como no_progress e guarde ao lado da execução as contagens em que ela parou.
Perguntar, parar e contar os finais
Assim que uma regra encerra uma execução, nada no laço pergunta à pessoa que deu a tarefa o que fazer em seguida.
Só ask_user faz perguntas. O modelo o chama com uma pergunta, o arcabouço devolve a pergunta e nenhuma alteração é feita. As regras de parada funcionam de outra forma. Uma parada por repeated_call ou no_progress registra a regra que disparou e a chamada ou as contagens em que parou, e a execução termina. Transformar uma parada dessas em uma pergunta para uma pessoa é a transferência descrita em subagentes e transferências. O que uma alteração pode fazer sem o sim de uma pessoa é o portão descrito em portões de permissão.
A última verificação deste capítulo executa as 20 tarefas duas vezes, uma como registrado e outra com as duas regras, chamadas repetidas e sem progresso. Ela imprime apenas contagens:
1"""The task-set recording's 20 runs, replayed as recorded and again with both stop rules. Counts only: which runs hit2the step cap, which rule ended the runs that stopped early, and whether any done task is cut short."""3from collections import Counter45from lib.case import load_tasks6from lib.loop import Stops, run_task7from lib.models import ReplayModel8from lib.tasks import score9from lib.tools import V110from lib.trace import IdCounter1112RULES = Stops(repeat_limit=3, no_progress_limit=2)131415def replay(stops: Stops) -> dict:16 """Every task in file order, so the run IDs match the recording's. Maps task ID to (ended, steps, done)."""17 ids, out = IdCounter(), {}18 for task in load_tasks():19 run = run_task(ReplayModel("task-set", task.id), task, V1, max_steps=V1.step_cap, ids=ids, stops=stops)20 out[task.id] = (run.ended, run.steps, score(task, run))21 run.close()22 return out232425ENDS = ("finish", "ask_user", "step_cap", "repeated_call", "no_progress", "no_tool_call")26plain, ruled = replay(Stops()), replay(RULES)27capped = sorted(t for t, (ended, _, _) in plain.items() if ended == "step_cap")28ruled_ends = Counter(ended for ended, _, _ in ruled.values())29done = sorted(t for t, (_, _, ok) in plain.items() if ok)30print("task set step cap:", V1.step_cap)31print("runs:", len(plain))32print("step cap without the rules:", len(capped))33print("step cap without the rules, tasks:", ", ".join(capped))34print("step cap with the rules:", ruled_ends["step_cap"])35print("ended early with the rules:", len([t for t in capped if ruled[t][0] != "step_cap"]))36for ended in ENDS:37 print(f" {ended}: {ruled_ends[ended]}")38print("done without the rules:", len(done))39print("done without the rules, tasks:", ", ".join(done))40print("done with the rules:", sum(1 for _, _, ok in ruled.values() if ok))41print("done with the rules, by finish:", sum(1 for ended, _, ok in ruled.values() if ended == "finish" and ok))42print("finish but not done, with the rules:", sum(1 for ended, _, ok in ruled.values() if ended == "finish" and not ok))43print("done with the rules, by ask_user:", sum(1 for ended, _, ok in ruled.values() if ended == "ask_user" and ok))44wrong = [t for t, (ended, _, ok) in plain.items() if ended == "ask_user" and not ok]45print("ask_user but not done, without the rules:", len(wrong))46print("of those, cut early with the rules:", len([t for t in wrong if ruled[t][0] != "ask_user"]))47assert len(capped) == 7 and all(ruled[t][2] for t in done), "a done task must survive the rules"48assert sum(ruled_ends.values()) == len(plain), "every run has one ending"
python stop-rules-over-task-set.pytask set step cap: 16
runs: 20
step cap without the rules: 7
step cap without the rules, tasks: T-01, T-02, T-06, T-10, T-11, T-13, T-16
step cap with the rules: 1
ended early with the rules: 6
finish: 6
ask_user: 1
step_cap: 1
repeated_call: 1
no_progress: 11
no_tool_call: 0
done without the rules: 5
done without the rules, tasks: T-04, T-05, T-09, T-14, T-18
done with the rules: 5
done with the rules, by finish: 4
finish but not done, with the rules: 2
done with the rules, by ask_user: 1
ask_user but not done, without the rules: 6
of those, cut early with the rules: 6
As regras encurtam as execuções presas sem perder nenhuma tarefa concluída. Sem elas, o orçamento se esgota em 7 das 20 execuções; com elas, apenas 1 ainda chega até ele.
Com as regras ativadas, o fim mais comum foi no_progress, em 11 execuções, e finish veio em seguida, em 6 execuções.
Cada tarefa concluída continua passando com as regras ativadas, e o exemplo verifica isso. Das 5 execuções concluídas, 4 terminam com finish e passam na verificação, e 1 termina com o ask_user na T-18, que é o quinto. As outras 2 execuções finish falham na verificação, por isso não estão concluídas.
Sem as regras, 6 execuções fizeram uma pergunta e não estavam concluídas. Com as regras, 6 dessas execuções terminaram antes, e nenhuma delas perguntou. A única chamada de ask_user que sobra com as regras ativadas é a da T-18, que o avaliador conta como concluída; o capítulo 10 mostra que ela só conta por causa de uma palavra em um caminho. Uma parada que encerra uma execução cedo não torna a execução correta. Ela encerra a execução antes que a pergunta errada seja feita, e essa execução continua não concluída. As regras cortam o desperdício; elas não conseguem distinguir uma pergunta certa de uma errada.
Você pode conferir a saída por conta própria. Os seis finais com as regras ativadas somam o número de execuções, como mostram as linhas da saída, e a contagem de concluídas é a mesma com as regras e sem elas. Se a contagem de concluídas mudar, uma regra cortou uma execução que ia passar, e a regra é o que deve ser alterado. Se uma execução do seu próprio trabalho terminar presa, leia-a nesta ordem: o valor ended, depois os últimos passos, depois o primeiro passo em que uma chamada começou a se repetir. Essas leituras levam menos tempo do que ler a transcrição inteira.
Regra prática: Conte cada execução pelo valor ended que ela registrou, e informe as contagens com as regras ativadas e desativadas, ao lado da contagem de concluídas. Uma parada só pode transformar uma execução em uma que não está concluída; por isso, ao mudar uma regra, verifique se a contagem de concluídas se mantém antes de manter a mudança.
Decisões neste capítulo
Cada uma destas é um padrão que o livro escolheu, e nenhuma é uma lei. As regras de trabalho dizem quando mudar um deles, e a mudança deve ser feita primeiro no seu próprio conjunto de tarefas, onde você pode contar o que ela fez com as tarefas concluídas antes que outra pessoa dependa dela.
- As regras de parada são opcionais e vêm desativadas por padrão no loop. Uma execução sem elas faz as mesmas requisições que o loop do capítulo 1.
- Uma chamada repetida são três chamadas idênticas seguidas, comparadas pelo nome da ferramenta e pelos argumentos ordenados.
- Ausência de progresso são duas edições seguidas que deixam inalteradas as contagens de testes do harness. A primeira edição é comparada com as contagens feitas antes de qualquer edição.
- Uma parada encerra a execução como um resultado. Nenhuma regra de parada pergunta a uma pessoa, e a transferência aguarda subagentes e transferências.
- O orçamento de passos conta as chamadas ao modelo, inclusive as respostas malformadas. Este capítulo não o trata como um limite de tempo ou de tokens.
- Os nomes dos seis finais permanecem fixos. O gate acrescenta um, no capítulo 6.
- Uma parada que nomeia sua regra e suas contagens é uma que o leitor pode verificar, enquanto uma parada que nomeia apenas o orçamento obriga o leitor a percorrer todos os passos novamente.
Este capítulo, nesta edição
Edição 2026.11.2Exemplos aprovados em 20 de nov de 20264 de 4 exemplos exemplos deste capítulo passam
Traduzido do livro em inglês, edição 2026.11.2.