Detén el bucle cuando termine o se atasque
Unos 19 minutos de lectura, con 4 ejemplos en 6 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.2. Lee el original
Al final de este capítulo podrás decir por qué se detuvo cualquier ejecución, a partir de la única palabra que el arnés registra para ello, y añadir las dos reglas que terminan una ejecución que dejó de avanzar.
Capítulo 1 construyó un bucle que termina una ejecución de una de tres maneras: el modelo llama a finish, la ejecución alcanza su límite de 8 pasos o el modelo no hace ninguna llamada en dos ocasiones seguidas. Eso cubre un modelo que termina. No cubre un modelo que sigue enviando la misma edición, que es lo que invita una edición que no encuentra su texto. Las herramientas del capítulo 1 no tienen edición, así que ese caso proviene del conjunto de tareas: las 20 tareas que evaluar el agente puntúa, ejecutadas con el conjunto de herramientas v1, cuyas herramientas incluyen ediciones. En el caso que seguimos a lo largo del libro, unitcraft, una pequeña biblioteca de unidades cuya suite visible da un recuento después de cada cambio, una ejecución atascada de ese tipo llega al límite, y lo único que queda registrado de su final es que el límite la terminó. Cada paso perdido es una llamada al modelo y una línea en la transcripción que un revisor tiene que leer. Este capítulo nombra las formas en que el bucle termina una ejecución, añade dos reglas que terminan antes una ejecución atascada y mide lo que hacen en el conjunto de tareas.
Formas en que termina una ejecución
Cada ejecución termina por una razón declarada, y el arnés escribe esa razón en el campo ended de la ejecución. Dos de las razones son decisión del modelo: llama a finish para terminar la ejecución, o llama a ask_user con una pregunta para la persona. Tres son límites que fija el arnés: el presupuesto de pasos, la regla de llamada repetida y la regla de falta de progreso. La sexta, no_tool_call, la fija un modelo que no hace ninguna llamada. El bucle fija estas seis, y puertas de permiso añade una séptima en el capítulo 6. La tabla muestra las seis.
ended |
Se establece cuando | Se muestra en |
|---|---|---|
finish |
el modelo llama a finish, lo que termina la ejecución |
los recuentos del conjunto de tareas |
ask_user |
el modelo llama a ask_user con una pregunta, y no se hace ningún cambio |
los recuentos del conjunto de tareas |
step_cap |
la ejecución alcanza su presupuesto de pasos | budget-stops-a-loop |
repeated_call |
la misma llamada aparece tres veces seguidas | repeated-call-stops |
no_progress |
dos ediciones seguidas dejan los recuentos de pruebas donde estaban | no-progress-stops |
no_tool_call |
el modelo no hace ninguna llamada dos veces seguidas | los recuentos del conjunto de tareas, donde vale 0 |
Los recuentos del conjunto de tareas son las líneas que imprime el último ejemplo de preguntar, detenerse y contar. En el conjunto de herramientas v1, que usa el conjunto de tareas, finish solo recibe un resumen: termina la ejecución con un resumen de las ediciones que la ejecución ya hizo en su copia de trabajo, y no escribe ningún archivo. El finish del capítulo 1 también escribió un archivo antes de terminar la ejecución. Los conjuntos de herramientas que mide este capítulo no lo hacen.
Cuando más de un final se aplica en el mismo paso, el bucle los revisa en un orden fijo. Primero se atiende una llamada finish o ask_user, luego la regla de llamada repetida y después la regla de falta de progreso. El presupuesto se aplica cuando el bucle se queda sin pasos, así que se revisa al final. El orden importa solo en el paso en que dos finales coinciden, y el resto del capítulo se ciñe al caso único.
Una respuesta sin llamada tiene un reintento. Una segunda respuesta sin llamada seguida termina la ejecución como no_tool_call. Ningún ejemplo de este capítulo llega a ese caso, así que nada de lo que sigue depende de él.
Cada final es un valor, no una frase en la última respuesta, de modo que un informe puede decir cuál ocurrió sin leer esa respuesta. En producción, la diferencia entre estos finales es difícil de ver desde fuera. Una ejecución que termina en step_cap parece una ejecución lenta que no acabó, y un revisor que lea solo el mensaje final no puede distinguirla de una que estaba a punto de terminar. El valor ended es lo que muestra la diferencia en un informe, y es lo primero que conviene revisar cuando una ejecución cuesta más de lo que merece su tarea.
Los nombres importan más allá de este capítulo. Puertas de permiso es el lugar donde el cambio que propone una llamada finish espera hasta que una persona diga que sí. Subagentes y traspasos convierte una detención en una pregunta para una persona, y probar el agente cuenta los finales. Cada uno lee estos valores, así que cambiar un nombre aquí lo cambiaría también allí.
Enumeramos los finales que el arnés puede observar, no todas las razones por las que una ejecución puede fallar. Un modelo que da una respuesta errónea y llama a finish termina como finish, y solo la comprobación, la prueba oculta que puntúa la copia final, muestra que falló. Por eso el recuento de ejecuciones terminadas con éxito sale de la comprobación y no del valor ended, un punto al que vuelve la regla práctica de abajo. La documentación del Agent SDK, Cómo funciona el bucle del agente, describe sus finales de la misma manera: una ejecución que alcanza su límite de turnos termina con un resultado cuyo subtipo es error_max_turns y sin respuesta final. En ese SDK un turno es una pasada por su bucle, una respuesta del modelo con sus llamadas a herramientas, y max_turns cuenta esas pasadas más una para la respuesta final de solo texto. Aquí esa pasada es un paso. Este libro reserva "turno" para un intercambio con la persona que dio la tarea. La misma página advierte que un bucle sin límite puede durar mucho tiempo con indicaciones abiertas. El libro no usa el SDK, así que citamos esa página por su diseño, no por ningún código.
Regla práctica: Registra un valor ended con cada ejecución, y nunca informes el resultado de una ejecución sin él. Cuenta una ejecución como exitosa según la regla de la puntuación, nunca solo por su valor ended.
El presupuesto cuenta pasos
Un modelo que nunca llama a finish no da al bucle ninguna razón para detenerse, así que el bucle necesita un conteo que sí la dé. Un paso es una llamada al modelo y la respuesta que devuelve. El presupuesto de pasos es el mayor número de pasos que puede dar una ejecución, y el bucle se detiene al llegar a ese número. Los pasos se cuentan, no se miden en tiempo: el bucle no lee ningún reloj.
El conjunto de tareas, las 20 tareas que cuenta el último ejemplo de este capítulo, se ejecuta con el conjunto de herramientas v1 y un presupuesto de 16 pasos. El capítulo 1 usa un presupuesto menor, 8.
La grabación de T-01 del capítulo 1 muestra el presupuesto en acción. El modelo, Qwen3-4B-Instruct-2507, es un modelo abierto, y sus respuestas se grabaron y se reproducen aquí, así que cada ejecución de este capítulo obtiene la misma salida en cualquier máquina. En esa grabación el modelo no terminó dentro de ocho pasos. Su último paso fue una llamada a herramienta mal formada, que el arnés rechazó. Vuelve a ejecutar la tarea bajo el presupuesto, sin ninguna otra regla, y la salida muestra dónde la corta el límite:
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
La ejecución termina como step_cap tras 8 pasos, con 8 llamadas a herramientas, frente a un presupuesto de 8. Los dos conteos coinciden porque cada paso hizo una solicitud. La línea que hay que retener es la última. La respuesta final del modelo fue una llamada que el arnés no pudo analizar, y el presupuesto fue lo único que terminó la ejecución. Nada en el registro dice que el modelo hubiera terminado.
Un presupuesto de pasos no limita el tiempo, y tampoco limita los tokens. Una herramienta que se cuelga mantiene abierto su paso hasta que responde, así que el tiempo de espera pertenece al entorno aislado, en entorno aislado y secretos. Una respuesta larga usa más tokens dentro de un solo paso, y contar tokens es el trabajo de presupuestos de contexto. El presupuesto limita solo las llamadas al modelo, así que una ejecución que llega al límite ha agotado sus llamadas, y no se sabe nada más sobre el motivo.
Las respuestas mal formadas también cuentan. Una respuesta que el arnés no puede analizar sigue siendo una llamada al modelo, así que gasta un paso, y el presupuesto la cuenta. Un modelo que sigue produciendo llamadas que el arnés no puede leer llega al presupuesto igual que uno que repite una llamada correcta. Ambos terminan como step_cap, así que solo los últimos pasos muestran cuál de las dos cosas ocurrió: una llamada correcta repetida, o llamadas que el arnés no pudo leer.
Regla práctica: Fija el presupuesto de pasos a partir de ejecuciones con tus propias tareas, no a partir de una suposición. Toma el mayor número de pasos que necesitó una ejecución correcta, deja margen por encima y escribe en el código para qué sirve ese margen.
La misma llamada, otra vez
Un modelo que ha visto fallar una herramienta puede volver a enviar la misma llamada una y otra vez, y el bucle ejecutará cada una hasta que el presupuesto termine la ejecución. Es tentador pensar que el modelo notará que está en un bucle. El artículo de ReAct, de Yao y colaboradores (2022, publicado en ICLR 2023), informa de la repetición como un patrón de error frecuente: en sus ejecuciones de respuesta a preguntas, el modelo generaba repetidamente pensamientos y acciones que ya había producido. Las tareas del artículo son la respuesta a preguntas y la toma de decisiones, no código, así que nos da una razón para vigilar la repetición y no una tasa para medirla. ReAct: Synergizing Reasoning and Acting in Language Models es la fuente. El arnés tiene que detectar la repetición por sí mismo.
La regla que usa el libro es sencilla. Tres llamadas idénticas seguidas terminan la ejecución como repeated_call. Una llamada es idéntica cuando tiene el mismo nombre de herramienta y los mismos argumentos, comparados con las claves ordenadas. El orden de las claves importa. Dos respuestas pueden llevar los mismos argumentos con las claves en un orden distinto, y entonces el texto bruto difiere aunque la llamada no. En la versión de Python fijada por el libro, 3.12.15, json.dumps da dos cadenas distintas para las mismas dos claves en dos órdenes, plain dumps equal: False, y una sola cadena cuando las claves se ordenan, sort_keys dumps equal: True. Esto es una prueba que ejecutamos, no un ejemplo de este libro, así que léela como una comprobación que puedes repetir.
Tres es el umbral de este libro, no uno fijo. Es un juicio, y la regla práctica de más abajo indica cuándo cambiarlo. Una llamada analizada que difiere de la anterior reinicia el recuento, y también lo hace una respuesta con un bloque de llamada mal formado, que no tiene una llamada analizada con la que comparar. Una respuesta cortada en el límite de tokens, o una respuesta sin llamada, deja la racha como estaba. El bucle omite la comprobación de la racha en esas respuestas, así que las llamadas idénticas a ambos lados de una de ellas siguen contando juntas.
T-01 nunca envía la misma llamada tres veces seguidas, así que este ejemplo reproduce T-02, donde el modelo sí lo hace:
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
Sin la regla, la ejecución termina como step_cap at step 16. Con ella, termina como repeated_call at step 13. El punto está en los últimos pasos: la misma llamada edit_file, enviada de nuevo, falla cada vez con old text not found in unitcraft/format.py. La primera de las llamadas idénticas llegó en step 11, y el recuento llegó a 3 seguidas antes de que la regla terminara la ejecución. El ejemplo afirma el final y el paso en el que se detiene, de modo que un cambio que mueva la parada hace fallar la ejecución en lugar de cambiar en silencio la salida impresa.
Un modelo que alterna una lectura con una edición nunca activa esta regla, porque cada lectura rompe la racha. La siguiente regla es para ese caso.
La regla trata de que la misma llamada bien formada regrese sin cambios. Una respuesta rota es un fallo distinto, y los esquemas de herramientas es donde una llamada incorrecta regresa como un error tipado que el modelo puede leer.
Regla práctica: Compara las llamadas por nombre de herramienta y argumentos ordenados, y termina la ejecución a la tercera llamada idéntica seguida. Sube el umbral solo después de que tus propias trazas muestren tres llamadas idénticas seguidas que estaban avanzando. Entonces mide el número más alto en tu conjunto de tareas antes de quedarte con él.
Sin progreso entre ediciones
Un modelo que alterna lecturas con ediciones nunca envía la misma llamada tres veces seguidas, así que la regla de llamada repetida no tiene nada que contar, incluso cuando la ejecución no avanza. La señal que encaja en ese caso son los conteos de pruebas. Después de cada edición, el arnés ejecuta las pruebas visibles, la propia suite de pruebas del caso, sobre la copia de trabajo y conserva la línea de conteos del resumen que construye, como 8 failed, 22 passed. El modelo nunca ve esa ejecución. El arnés la guarda para su propia decisión.
Este es el tipo de señal que pide la guía de Building effective agents. Dice que es crucial que un agente obtenga información de verdad del entorno en cada paso, y un conteo de pruebas es información de verdad de ese tipo. La guía es una opinión de un artículo de diciembre de 2024, no una medición.
La regla lleva la cuenta de las ediciones seguidas que dejan los conteos sin cambios. La primera edición se compara con los conteos de antes de hacer cualquier edición. Una edición que mueve los conteos reinicia la cuenta a cero. Una lectura no la toca. Dos seguidas terminan la ejecución con no_progress. Una edición fallida deja el archivo como estaba, así que sus conteos siguen igual, y la regla la cuenta como falta de progreso.
Ejecuta T-01 del registro del conjunto de tareas, que usa el conjunto de herramientas v1 y cuyas ediciones fallan, dos veces: una sin reglas y otra con la regla de falta de progreso fijada en dos ediciones. Lee dónde termina cada ejecución:
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
Sin la regla, la ejecución termina con step_cap at step 16. Con ella, la ejecución termina con no_progress at step 5, en la segunda de dos ediciones que dejaron los conteos sin cambios. Esas ediciones están en 3 and 5. Las dos fallaron con old text not found, así que ninguna movió los conteos, que se quedaron en 8 failed, 22 passed. Los dos últimos pasos de la salida son una lectura y esa segunda edición fallida. La lectura está entre las dos ediciones y no reinicia la cuenta, por eso la regla puede activarse con ediciones que no están juntas en la transcripción.
La regla lee una línea del resumen de pruebas: la línea de conteos, como 8 failed, 22 passed. No lee qué prueba falló. Una edición que arregla una prueba y rompe otra, con el mismo conteo, por tanto parece falta de progreso. Comparar el archivo tampoco ayuda. Una edición fallida deja el archivo sin cambios, pero una edición que sí lo cambia puede dejar igual los conteos. Conservamos los conteos porque el arnés puede compararlos sin leer nombres de pruebas. Comprueba esa elección en tus propias ejecuciones, donde un cambio de un fallo por otro aparecería como una parada.
Dos ediciones fallidas bastan para detener esta ejecución, aunque una tercera edición podría haber funcionado. Elegimos dos, y el libro no afirma con qué frecuencia una ejecución que se detiene así habría llegado a tener éxito. En el conjunto de tareas, 11 ejecuciones terminaron de esta manera, y ninguna está hecha, según la regla de la puntuación.
La edición fallida es el fallo que atiende los esquemas de herramientas. El capítulo 3 cambia lo que devuelve una edición que no encuentra su texto: las líneas más cercanas del archivo, para que el modelo corrija su texto en lugar de volver a enviarlo, como muestra errores de edición que nombran las líneas más cercanas.
Regla práctica: Vigila los conteos que el arnés obtiene de las pruebas después de cada edición, no lo que dice el modelo que cambió. Detén una ejecución después de dos ediciones seguidas que dejen los conteos sin cambios. Regístrala como no_progress, y guarda junto a la ejecución los conteos con los que se detuvo.
Preguntar, detenerse y contar los finales
Una vez que una regla termina una ejecución, nada en el bucle le pregunta a la persona que dio la tarea qué hacer después.
Solo ask_user pregunta. El modelo lo llama con una pregunta, el arnés devuelve la pregunta y no se hace ningún cambio. Las reglas de parada funcionan de otra manera. Una parada por repeated_call o por no_progress registra la regla que se disparó y la llamada o los conteos en los que se detuvo, y la ejecución termina. Convertir una parada así en una pregunta para una persona es el traspaso de subagentes y traspasos. Lo que un cambio puede hacer sin el sí de una persona es la compuerta de compuertas de permiso.
La última comprobación de este capítulo ejecuta las 20 tareas dos veces, una tal como se registraron y otra con ambas reglas, llamadas repetidas y sin progreso. Imprime solo conteos:
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
Las reglas cortan las ejecuciones atascadas sin perder una tarea terminada. Sin ellas, el presupuesto termina 7 de las 20 ejecuciones; con ellas, solo 1 todavía lo alcanza.
Con las reglas activadas, el final más común fue no_progress, en 11 ejecuciones, y finish vino después, en 6 ejecuciones.
Cada tarea terminada sigue superando la prueba con las reglas activadas, y el ejemplo lo comprueba. De las 5 ejecuciones terminadas, 4 terminan con finish y superan su prueba, y 1 termina con el ask_user en T-18, que es el quinto. Las otras 2 ejecuciones finish fallan su prueba, así que no están terminadas.
Sin las reglas, 6 ejecuciones hicieron una pregunta y no quedaron terminadas. Con las reglas, 6 de esas ejecuciones terminaron antes y ninguna de ellas preguntó. La única ask_user que queda con las reglas activadas es la de T-18, que el evaluador cuenta como terminada; el capítulo 10 muestra que solo cuenta por una palabra en una ruta. Una parada que termina una ejecución antes no hace que la ejecución sea correcta. Termina la ejecución antes de que se haga la pregunta equivocada, y esa ejecución sigue sin estar terminada. Las reglas recortan el desperdicio; no pueden distinguir una pregunta acertada de una equivocada.
Puedes revisar el resultado tú mismo. Los seis finales con las reglas activadas suman el número de ejecuciones, como muestran las líneas del resultado, y el conteo de terminadas es el mismo con las reglas y sin ellas. Si el conteo de terminadas alguna vez cambia, una regla ha cortado una ejecución que iba a superar la prueba, y la regla es lo que hay que cambiar. Si en tu propio trabajo una ejecución termina atascada, léela en este orden: el valor ended, luego los últimos pasos y después el primer paso en el que una llamada empezó a repetirse. Esas lecturas toman menos tiempo que leer la transcripción completa.
Regla práctica: Cuenta cada ejecución por el valor ended que registró, y reporta los conteos con las reglas activadas y desactivadas, junto al conteo de terminadas. Una parada solo puede convertir una ejecución en una que no está terminada, nunca al revés, así que, cuando cambies una regla, comprueba que el conteo de terminadas se mantenga antes de conservar el cambio.
Decisiones en este capítulo
Cada una de estas es un valor por defecto que el libro eligió, y ninguna es una ley. Las reglas prácticas indican cuándo conviene cambiar una, y el cambio debe probarse primero en tu propio conjunto de tareas, donde puedes contar qué efecto tuvo sobre las tareas terminadas antes de que alguien más dependa de él.
- Las reglas de parada son opcionales y están desactivadas por defecto en el bucle. Una ejecución sin ellas hace las mismas requests que el bucle del capítulo 1.
- Una llamada repetida es tres llamadas idénticas seguidas, comparadas por nombre de herramienta y argumentos ordenados.
- No hay progreso cuando dos ediciones seguidas dejan sin cambios los recuentos de pruebas del arnés. La primera edición se compara con los recuentos antes de cualquier edición.
- Una parada termina la ejecución como resultado. Ninguna regla de parada pide intervención de una persona, y el traspaso espera a subagentes y traspasos.
- El presupuesto de pasos cuenta las llamadas al modelo, incluidas las respuestas mal formadas. Este capítulo no lo considera un límite de tiempo ni de tokens.
- Los nombres de los seis finales se mantienen fijos. La compuerta añade uno, en el capítulo 6.
- Una parada que indica su regla y sus recuentos es una que el lector puede comprobar, mientras que una parada que solo nombra el presupuesto obliga al lector a repasar cada paso.
Este capítulo, en esta edición
Edición 2026.11.2Ejemplos verificados el 20 de nov de 2026Superan la prueba 4 de 4 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.2.