Cuándo un agente es el diseño equivocado
Unos 20 minutos de lectura, con 2 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 tomar cualquier tarea del caso, clasificarla como un pipeline fijo, una única llamada a un modelo o un agente con puertas de control, y explicar qué muestran las ejecuciones registradas para ella. El caso ofrece la primera prueba. La tarea T-02 es una corrección de una línea en unitcraft, la biblioteca cuyas tareas este capítulo clasifica según su diseño: los importes negativos pierden el separador de miles, de modo que -1234.5 m debería imprimirse como -1,234.50 m. La ejecución registrada con el conjunto de herramientas v1 del capítulo 3, el conjunto con el que se hizo la grabación de la tarea, nunca la terminó. Usó los 16 pasos y nunca llamó a finish. El cambio consiste en una sola sustitución en una sola función, así que la pregunta es si un agente fue alguna vez el diseño adecuado para ella.
Empieza con la canalización fija
La primera pregunta para T-02 es qué pasos necesita cuando nada en la ejecución tiene que decidirse. Lee el módulo de formato, reemplaza la línea que construye el texto del número para que los valores negativos conserven el separador, ejecuta las pruebas visibles y termina con una frase que describa el cambio. Ninguno de esos pasos espera a lo que un modelo piense del archivo, así que ninguno necesita un modelo. Una canalización fija es esa lista, escrita como código antes de que empiece la ejecución.
La entrada de ingeniería de Anthropic sobre la construcción de agentes traza una línea parecida. Llama flujo de trabajo a un sistema en el que los LLM y las herramientas se orquestan mediante rutas de código predefinidas, y agente a aquel en el que un LLM dirige dinámicamente sus propios procesos y el uso de herramientas (Anthropic, "Building effective agents", publicado el 19 de diciembre de 2024). Un flujo de trabajo en ese sentido sigue ejecutando un modelo en sus pasos. La canalización de este capítulo va un paso más allá, porque ninguno de sus pasos necesita un modelo. La misma entrada recomienda encontrar la solución más sencilla posible y añadir complejidad solo cuando haga falta. La regla que este capítulo toma de ese consejo es una regla práctica, no una medición: si los pasos pueden escribirse antes de la ejecución, escríbelos primero.
Cada canalización es una lista de ediciones exactas y un resumen, guardados en lib/pipeline.py. Una edición nombra el texto que reemplaza y el texto que lo reemplaza, y falla cuando el texto antiguo no aparece exactamente una vez en el archivo. La canalización ejecuta su lista con el conjunto de herramientas v1, de modo que cada llamada se comporta como lo hace para el agente, y puntúa el resultado con la misma regla de finalización. Solo se escriben tres canalizaciones, para T-02, T-04 y T-05. El ejemplo las ejecuta y muestra cada una junto a la ejecución almacenada del agente en la misma tarea.
1"""The fixed pipeline on the tasks where one known edit works (T-02, T-04, T-05), with no model, beside the recorded2agent's run on the same task. The point rests on two lines per run: the pipeline's actions and its model calls (0), and3the agent's steps, which are its model calls. The edits are written by a person; the scoring is the same for both."""4from lib.case import load_tasks5from lib.models import load_recording6from lib.pipeline import PIPELINES, Edit, Pipeline, agent_edit_results, run_pipeline7from lib.tasks import score89manifest, _ = load_recording("task-set")10stored = {row["task"]: row for row in manifest["tasks"]}11for task in load_tasks(only=sorted(PIPELINES)):12 run = run_pipeline(task, PIPELINES[task.id])13 done = score(task, run)14 run.close()15 agent = stored[task.id]16 print(f"{task.id} pipeline ended: {run.ended}")17 print(f"{task.id} pipeline done: {'yes' if done else 'no'}")18 print(f"{task.id} pipeline actions: {run.tool_calls}")19 print(f"{task.id} pipeline model calls: {run.steps}")20 print(f"{task.id} pipeline prompt tokens: {run.prompt_tokens}")21 print(f"{task.id} agent ended: {agent['ended']}")22 print(f"{task.id} agent done: {'yes' if agent['done'] else 'no'}")23 print(f"{task.id} agent steps: {agent['steps']}")24 print(f"{task.id} agent tool calls: {agent['tool_calls']}")25 print(f"{task.id} agent prompt tokens: {agent['prompt_tokens']}")26 assert done and run.steps == 0 and run.tool_calls < agent["tool_calls"], task.id2728# The agent's T-02 run, replayed from the recording: the result the tools gave each of its edits and test runs.29edits, tests = agent_edit_results("T-02")30print(f"T-02 agent edits failed: {sum(e.startswith('error') for e in edits)} of {len(edits)}")31print(f"T-02 agent test runs: {len(tests)}")32print(f"T-02 agent first edit result: {edits[0]}")33assert all(e.startswith("error") for e in edits) and not tests3435# The pipeline's own failure: its one edit names text the file does not hold, so the run stops at that step.36task = load_tasks(only=["T-04"])[0]37run = run_pipeline(task, Pipeline((Edit("unitcraft/units.py", "no such line", "x"),), "not run"))38print(f"T-04 missing anchor ended: {run.ended}")39print(f"T-04 missing anchor actions: {run.tool_calls}")40print(f"T-04 missing anchor done: {'yes' if score(task, run) else 'no'}")41print(f"T-04 missing anchor result: {run.stop_detail}")42run.close()43assert run.ended == "pipeline_stop" and run.tool_calls == 2
python fixed-pipeline-same-task.pyT-02 pipeline ended: finish
T-02 pipeline done: yes
T-02 pipeline actions: 4
T-02 pipeline model calls: 0
T-02 pipeline prompt tokens: 0
T-02 agent ended: step_cap
T-02 agent done: no
T-02 agent steps: 16
T-02 agent tool calls: 16
T-02 agent prompt tokens: 43904
T-04 pipeline ended: finish
T-04 pipeline done: yes
T-04 pipeline actions: 4
T-04 pipeline model calls: 0
T-04 pipeline prompt tokens: 0
T-04 agent ended: finish
T-04 agent done: yes
T-04 agent steps: 5
T-04 agent tool calls: 5
T-04 agent prompt tokens: 8809
T-05 pipeline ended: finish
T-05 pipeline done: yes
T-05 pipeline actions: 4
T-05 pipeline model calls: 0
T-05 pipeline prompt tokens: 0
T-05 agent ended: finish
T-05 agent done: yes
T-05 agent steps: 5
T-05 agent tool calls: 5
T-05 agent prompt tokens: 8494
T-02 agent edits failed: 9 of 9
T-02 agent test runs: 0
T-02 agent first edit result: error: old text not found in unitcraft/format.py
T-04 missing anchor ended: pipeline_stop
T-04 missing anchor actions: 2
T-04 missing anchor done: no
T-04 missing anchor result: error: old text not found in unitcraft/units.py
La canalización termina las tres tareas y no hace ninguna llamada a un modelo. En este capítulo un paso es una llamada a un modelo, como lo es en todo el libro, así que la canalización no tiene pasos. Tiene acciones, que son sus llamadas a herramientas, y la línea que las cuenta es 4 para T-02. El agente registrado en T-02 hizo 16 llamadas a modelos, una por cada paso, y sus tokens de prompt suman 43904. La canalización no envió ningún prompt. En T-04 y T-05, donde el agente terminó, el agente aun así hizo más llamadas a modelos que acciones tuvo la canalización, y el ejemplo imprime ambos recuentos para cada una. El capítulo 11 explica por qué el libro cuenta llamadas y tokens en lugar de dinero (el coste como recuentos).
Reproducir la ejecución de T-02 del agente a partir de la grabación muestra el resultado de cada llamada. Sus ediciones fallaron, 9 of 9, cada una con el mismo mensaje: error: old text not found in unitcraft/format.py. El agente volvió a leer el archivo e intentó de nuevo, con el mismo error, y nunca ejecutó las pruebas: su recuento de ejecuciones de prueba es 0. El límite de pasos detuvo una ejecución que no podía hacer coincidir su cambio con el archivo. Nada en la ejecución comprobó si un cambio había funcionado, así que el recuento indica cuánto tiempo estuvo atascado el agente, pero nada sobre por qué.
La canalización también falla a su manera. Su última ejecución le da una edición para T-04 cuyo texto antiguo no aparece en el archivo, que es lo que ocurre cuando un archivo cambia bajo una lista fija. La ejecución termina en ese paso, después de 2 acciones, con el mensaje propio de la herramienta: error: old text not found in unitcraft/units.py. La canalización no prueba otra ancla, no vuelve a leer el archivo ni pregunta a nadie. Para una edición que escribió una persona, detenerse es la respuesta correcta, porque el archivo ha cambiado y una persona debe revisarlo.
La parada, aun así, tiene que ir a algún sitio, y una canalización no puede entregarla a un hijo, porque no tiene ninguno. Puede entregarla a una persona, que lee el paso fallido y decide qué hacer. O puede entregar la tarea a un agente, dándole el paso que falló y el archivo tal como está ahora. El híbrido, una canalización primero y un agente solo ante un pipeline_stop, es el natural. La canalización hace los pasos que no necesitan juicio, y el agente ve solo la parte que se rompió. Arranca el agente desde un estado parcial, así que su ejecución necesita las mismas puertas de control que cualquier otra. Recomendamos una persona cuando el paso roto toca una decisión que el caso asigna a una persona. Recomendamos el agente cuando el paso es una edición conocida que se detuvo por un ancla cambiada. Este capítulo no mide el híbrido.
Tres cosas limitan lo que muestra la canalización. Una persona escribió cada edición, así que la comparación mide lo que cuesta el diseño, no lo que una canalización podría encontrar por sí sola. Las tres tareas son aquellas cuyas ediciones podían nombrarse antes de la ejecución, y nada aquí muestra cómo les irían las demás. La canalización también compara los identificadores de pruebas fallidas antes y después de su edición, porque el conjunto visible ya falla antes de cualquier edición.
Regla práctica: Antes de dar a un modelo el bucle, escribe los pasos con la comprobación que sigue a cada uno. Si todos los pasos son conocidos y una comprobación decide el resultado sin un modelo, construye la canalización y mídela. Decide adónde va su parada antes de la primera ejecución: a una persona, o a un agente al que se le da el paso fallido.
Cuándo ayuda dividir el trabajo
Cuando un agente tiene dificultades, lo siguiente que la gente suele hacer es añadir un segundo agente. Dividir el trabajo puede parecer más cuidadoso, así que la pregunta útil es cuándo realmente ayuda. Dos estudios ofrecen condiciones, no un veredicto.
Tran y Kiela compararon un agente con varios en razonamiento de múltiples saltos, manteniendo iguales los tokens de razonamiento (Tran and Kiela, arXiv:2604.02460). El agente único igualó o superó a los sistemas multiagente. Su resumen predice que los sistemas multiagente se vuelven competitivos bajo dos condiciones: cuando el uso efectivo del contexto de un agente único se degrada, y cuando se gasta más cómputo.
Kim et al. realizaron una comparación controlada en 260 configuraciones y seis benchmarks agénticos (Kim et al., arXiv:2512.08296). Su resumen dice que la alineación entre arquitectura y tarea determina el éxito colaborativo, y que la coordinación no alineada degrada el rendimiento. La lectura útil es condicional: un patrón de coordinación que ayuda en una tarea puede perjudicar en otra. Ambos estudios son artículos individuales. Su alcance es el razonamiento y los benchmarks, no una biblioteca de mantenimiento, así que léelos como razones para probar un diseño y no como resultados definitivos.
El caso puede verificarse frente a la primera condición, un contexto que el agente único no puede contener. La ventana de contexto de la grabación es de 8192 tokens. Su solicitud individual más grande contenía 6556 tokens de prompt, lo que deja margen dentro de la ventana y dentro del presupuesto de prompt que el capítulo 5 establece para ella. Ninguna solicitud del conjunto llegó a la ventana, así que ninguna tarea del caso tiene un contexto que obligue a dividir. El capítulo 8 compara dos tipos de división, y señala que este libro no mide una división frente a un único bucle. Por tanto, el caso tampoco ofrece ningún número para una división. La tabla de decisión siguiente toma la primera condición como prueba para dividir, y ninguna fila la cumple.
Regla práctica: Divide una tarea solo cuando puedas nombrar la condición que hace que dividir ayude, como un contexto que el agente único no puede contener, y cuando cada parte tenga una comprobación que no dependa de las demás. En caso contrario, mantén un solo agente, o ninguno.
Qué sale mal cuando sí usas un agente
Un agente añade lugares donde una ejecución puede fallar, y la mayoría solo se ve en el registro de la ejecución.
Cemri et al. construyeron su taxonomía a partir de 150 trazas que anotadores expertos leyeron con atención. Luego usaron una canalización de LLM-como-juez, contrastada con esos anotadores, para etiquetar las más de 1,600 trazas de su conjunto de datos, procedentes de siete frameworks multiagente (Cemri et al., arXiv:2503.13657, v3). El resultado son 14 modos de fallo en tres categorías: problemas de diseño del sistema, desalineación entre agentes y verificación de tareas. La taxonomía es para sistemas multiagente, así que se ajusta solo de forma aproximada a un único agente. Este capítulo no asigna ninguno de sus modos al caso. Las llamadas a herramientas malformadas de la ejecución reproducida en el capítulo 1 son fallos en lo que el modelo envía a una herramienta, y son visibles en el registro de esa ejecución.
La ejecución de T-02 falló por repetición. Sus 16 pasos fueron un listado y una serie de ediciones, la mayoría después de leer el mismo archivo, y cada edición devolvió el mismo error, porque el texto antiguo que citaba no estaba en el archivo. El límite de pasos terminó la ejecución, que es para lo que sirve el presupuesto del capítulo 2, pero el límite solo detuvo la ejecución. El registro muestra por qué nunca terminó: el agente nunca hizo un cambio que coincidiera, y nunca comprobó un cambio que no había hecho.
Las tareas de parada fallan de otra manera. En T-17 y T-19 el agente hizo una pregunta a una persona, y ninguna de las dos ejecuciones se contó como terminada. El evaluador solo cuenta un ask_user cuando su pregunta nombra el motivo para detenerse, y busca palabras como half o truncat en T-17, y dimension, length o mass en T-19. T-17 pregunta cuál es el redondeo correcto para el dinero, y su pregunta final propone un cambio en el redondeo basado en coma flotante y pregunta si debe seguir adelante. T-19 pide convertir metros en kilogramos, y su pregunta final ofrece un caso especial que supone una densidad de 1 y pregunta qué enfoque prefiere la persona. Ninguna de las dos preguntas nombra el motivo que busca el evaluador. Ambas ejecuciones también intentaron editar antes de preguntar. Cada edición devolvió un error, porque su texto antiguo no estaba en el archivo, y una escritura sobre el archivo existente fue rechazada, así que las copias nunca cambiaron. El registro muestra que las preguntas no nombraron el motivo y que las ediciones fallaron primero. No muestra qué habría respondido una persona, y este capítulo no lo supone.
T-18 es la otra tarea de parada, y su registro es una advertencia sobre el evaluador. El evaluador cuenta su ejecución como terminada a través de una palabra dentro de una ruta de archivo, y el capítulo 10 explica cómo. Este libro deja el evaluador tal como está, y presenta T-18 como un límite del evaluador, no como un buen traspaso.
La fiabilidad es el fallo que una sola ejecución oculta. tau-bench define pass^k como la probabilidad de que las k pruebas independientes de una tarea tengan éxito, promediada entre tareas (Yao et al., arXiv:2406.12045). En su configuración de 2024, los agentes con llamadas a funciones, entre ellos gpt-4o, tuvieron éxito en menos de la mitad de sus tareas, y pass^8 en su dominio de retail se mantuvo por debajo del 25 %. Una ejecución exitosa es una sola prueba. Este libro ejecuta cada tarea una vez, así que no puede informar de pass^k, y el capítulo 10 describe lo que informa en su lugar.
Regla práctica: Antes de confiar en el diseño de un agente, clasifica sus ejecuciones detenidas según cómo terminaron y lee el registro de cada tipo. Un recuento de fallos sin sus tipos no indica qué parte corregir, y una sola ejecución exitosa no predice la siguiente.
La verificación queda fuera del agente
Una ejecución que el agente juzga terminada todavía no es una tarea terminada.
Kim et al. encontraron que las arquitecturas sin verificación centralizada tienden a propagar más errores que las que cuentan con coordinación centralizada. En la propia medición del artículo, los agentes independientes amplificaron los errores a nivel de traza 17.2 veces, y un orquestador centralizado limitó esa cifra a 4.4 veces (Kim et al., sección 1 y tabla 5). El artículo trata de varios agentes. La lógica se traslada a uno solo: quien decide que el trabajo es correcto no debería ser la parte que lo hizo.
El caso aplica esa lógica a su propia puntuación. Para una corrección, la verificación oculta se ejecuta después de que termina la ejecución, en una copia que el agente nunca ve. El agente no puede editar una prueba para hacerla pasar; el capítulo 10 describe la verificación oculta.
La verificación de parada es más débil. Una tarea de parada se puntúa a partir de la pregunta que escribió el agente, así que las propias palabras del agente deciden si la ejecución cuenta. T-18 muestra lo poco que vale eso (capítulo 10). Una verificación que lee el relato que el agente hace de su trabajo es una verificación con la que el agente puede discutir. Una prueba visible que el agente puede editar te dice lo que el agente piensa de su cambio, no lo que hace el código.
Regla práctica: Coloca la verificación que decide el resultado de una tarea donde el agente no pueda editarla ni verla antes de que termine la ejecución. Si una finalización o una parada depende del relato que el agente hace de su trabajo, añade una verificación que el agente no escribió.
La tabla de decisión
La tabla clasifica cada tarea según tres criterios: si sus pasos se conocen antes de la ejecución, si una comprobación puede decidir el resultado sin una persona y si una persona tiene que decir que sí. Antes que los tres hay un cuarto asunto, que es si el arnés rechaza el cambio sin más. Estos criterios son el juicio del autor sobre cada tarea, no mediciones, y las reglas son reglas prácticas. Cada fila se sitúa junto al final registrado de la ejecución de esa tarea, y no se llama a ningún modelo.
Las reglas se aplican en un orden, y el orden es lo importante. Primero, un cambio que el arnés prohíbe no es una cuestión de diseño. La compuerta del capítulo 6 rechaza cualquier cambio bajo .github/, y rechaza un cambio de nombre que elimina un nombre público, porque ningún sí puede levantar una regla de ese tipo (cambios de clase nunca). Segundo, la aprobación de una persona significa un agente tras una compuerta, porque la compuerta debe preguntar antes de aplicar un cambio. Tercero, los pasos conocidos significan una canalización cuando una comprobación decide el resultado, y una sola llamada al modelo cuando ninguna comprobación lo hace. Los pasos abiertos significan un agente. El orden importa en T-16, que la segunda regla por sí sola enviaría a una compuerta, y que la primera regla rechaza.
1"""The decision table for chapter 12: every task in the set, with the author's readings (judgement, not measured), the2design the rules give, and how the task's recorded run ended. The counts at the end are the ones the chapter quotes.3No model is called."""4import json56from lib.models import RECORDED, load_recording7from lib.pipeline import ONE_CALL_SHAPE, REFUSED, TASK_SHAPES, design89yes_no = {True: "yes", False: "no"}10manifest, _ = load_recording("task-set")11stored = {row["task"]: row for row in manifest["tasks"]}12replies = [json.loads(line) for line in13 (RECORDED / "task-set" / "replies.jsonl").read_text(encoding="utf-8").splitlines() if line.strip()]1415print("task | steps known | exploration | wrong change | auto check | person | design | recorded ended | recorded done")16for task_id, s in TASK_SHAPES.items():17 rec = stored[task_id]18 print(f"{task_id} | {yes_no[s.steps_known]} | {yes_no[s.exploration]} | {s.wrong_change} | "19 f"{yes_no[s.auto_check]} | {yes_no[s.person]} | {design(s)} | {rec['ended']} | {yes_no[rec['done']]}")2021pipelines = [t for t, s in TASK_SHAPES.items() if design(s) == "fixed pipeline"]22agents = [t for t, s in TASK_SHAPES.items() if design(s) == "agent with gates"]23refused = [t for t, s in TASK_SHAPES.items() if design(s) == REFUSED]24print(f"rows with design 'fixed pipeline': {len(pipelines)}")25print(f"rows with design 'agent with gates': {len(agents)}")26print(f"rows with design 'one model call': {sum(design(s) == 'one model call' for s in TASK_SHAPES.values())}")27print(f"rows the harness refuses: {len(refused)}")28print(f"pipeline rows the recorded agent finished and passed: "29 f"{sum(stored[t]['ended'] == 'finish' and stored[t]['done'] for t in pipelines)}")30print(f"agent rows the recorded agent finished and passed: "31 f"{sum(stored[t]['ended'] == 'finish' and stored[t]['done'] for t in agents)}")32print(f"rows done in the recording: {sum(stored[t]['done'] for t in TASK_SHAPES)}")33print(f"one-call shape, not in the set: {design(ONE_CALL_SHAPE)}")34print(f"largest request in the recording, prompt tokens: {max(r['prompt_tokens'] for r in replies)}")35print(f"context window in the recording, tokens: {manifest['n_ctx']}")3637assert pipelines == ["T-01", "T-02", "T-03", "T-04", "T-05", "T-10", "T-12", "T-14", "T-20"]38assert design(ONE_CALL_SHAPE) == "one model call"39assert refused == ["T-16", "T-18"]40assert max(r["prompt_tokens"] for r in replies) < manifest["n_ctx"]
python decision-table.pytask | steps known | exploration | wrong change | auto check | person | design | recorded ended | recorded done
T-01 | yes | no | low | yes | no | fixed pipeline | step_cap | no
T-02 | yes | no | low | yes | no | fixed pipeline | step_cap | no
T-03 | yes | no | low | yes | no | fixed pipeline | ask_user | no
T-04 | yes | no | low | yes | no | fixed pipeline | finish | yes
T-05 | yes | no | low | yes | no | fixed pipeline | finish | yes
T-06 | no | yes | low | yes | no | agent with gates | step_cap | no
T-07 | no | yes | low | yes | no | agent with gates | finish | no
T-08 | no | yes | low | yes | no | agent with gates | finish | no
T-09 | no | yes | low | yes | no | agent with gates | finish | yes
T-10 | yes | no | low | yes | no | fixed pipeline | step_cap | no
T-11 | no | yes | high | yes | no | agent with gates | step_cap | no
T-12 | yes | no | low | yes | no | fixed pipeline | ask_user | no
T-13 | no | yes | low | yes | no | agent with gates | step_cap | no
T-14 | yes | no | low | yes | no | fixed pipeline | finish | yes
T-15 | no | yes | low | yes | no | agent with gates | ask_user | no
T-16 | yes | no | high | yes | yes | not a design choice: the harness refuses | step_cap | no
T-17 | no | no | high | no | yes | agent with gates | ask_user | no
T-18 | yes | no | high | yes | no | not a design choice: the harness refuses | ask_user | yes
T-19 | no | no | high | no | yes | agent with gates | ask_user | no
T-20 | yes | no | low | yes | no | fixed pipeline | ask_user | no
rows with design 'fixed pipeline': 9
rows with design 'agent with gates': 9
rows with design 'one model call': 0
rows the harness refuses: 2
pipeline rows the recorded agent finished and passed: 3
agent rows the recorded agent finished and passed: 1
rows done in the recording: 5
one-call shape, not in the set: one model call
largest request in the recording, prompt tokens: 6556
context window in the recording, tokens: 8192
Las reglas dan 9 canalizaciones fijas, 9 agentes con compuertas y 2 rechazos. Las canalizaciones son T-01 a T-05, T-10, T-12, T-14 y T-20: las ediciones que una persona podría escribir antes de la ejecución, donde una prueba decide luego el resultado. Los agentes son las correcciones abiertas y las funciones nuevas, T-06 a T-09, T-11, T-13 y T-15, y las dos tareas de parada T-17 y T-19, donde los pasos no se conocen y una persona debe decidir. La tabla predice dónde mirar, no cómo terminará una ejecución.
El agente registrado lo confirma solo en parte. De las nueve filas de canalización, terminó y superó 3 de ellas: T-04, T-05 y T-14. Las otras seis alcanzaron el límite de pasos o se detuvieron con una pregunta. De las nueve filas de agente, terminó y superó 1, T-09. En total, 5 de las veinte ejecuciones se completaron. La regla indica una canalización para las nueve filas, pero la canalización solo se ha construido y ejecutado en tres de ellas. Las otras seis son predicciones, y el registro no ofrece ningún resultado de canalización con el que compararlas.
T-16 es la fila que muestra qué sale mal cuando se ignora el orden. Su tarea renombra parse_quantity a parse y elimina el nombre antiguo. La compuerta del capítulo 6 rechaza ese cambio, porque eliminar un nombre público nunca le corresponde decidirlo al agente, y la compuerta lo rechazaría al leer el diff en finish. El agente registrado nunca preguntó. Probó ediciones y escrituras hasta el límite de pasos, y todas fallaron. Un agente tras una compuerta gastaría todo su presupuesto en un cambio que el arnés no aplicará. Por tanto, T-16 es un rechazo como T-18, y su final correcto es una pregunta al responsable del mantenimiento que le pida tratar el cambio de nombre como una decisión aparte. Esa es la pregunta que busca la palabra de parada del evaluador, approv. Si se pone T-16 entre las filas de agente, la tabla es correcta sobre el papel y errónea en la ejecución.
T-18 es el rechazo visto desde el otro lado. Su edición está bajo .github/, que la compuerta rechaza sin preguntar, así que el arnés decide y el diseño no. La fila registra la decisión del arnés, y el recuento del evaluador para esta ejecución es un límite (capítulo 10), no un buen final.
La fila de una sola llamada al modelo necesita un caso, y el conjunto no tiene ninguno. Una sola llamada al modelo encaja en un paso que requiere el juicio de un modelo, sin herramienta ni bucle, y cuya salida una persona lee después. Aquí hay un caso que no está en el conjunto: un resumen del cambio de T-02 para la solicitud de incorporación, escrito a partir del diff. Sus pasos son conocidos, ya que entra el diff y sale un párrafo. Ninguna comprobación decide si el párrafo es bueno, y no hace falta ningún sí, porque el responsable del mantenimiento lo lee después del cambio. Una canalización no puede escribirlo, porque la redacción es un juicio que toma una persona. Un agente añadiría pasos que no comprueban nada. El artículo de Anthropic señala algo relacionado: «For many applications, however, optimizing single LLM calls with retrieval and in-context examples is usually enough» (Anthropic, «Building effective agents»). Las reglas dan one model call para ese resumen, y el ejemplo lo comprueba con una aserción. Ninguna tarea del conjunto llega a esa fila, y la razón es que cada tarea tiene una comprobación que la decide, una aprobación de una persona que la envía a una compuerta, o pasos que nadie puede nombrar de antemano. Cada fila del conjunto cae en una de esas tres, así que el recuento es 0. Este capítulo no tiene una respuesta única registrada para la fila, y no ejecuta ningún modelo nuevo para generarla.
Regla práctica: Clasifica cada tarea en este orden antes de elegir un diseño: un rechazo es una pregunta a una persona, no un diseño; la aprobación de una persona es un agente tras una compuerta; los pasos conocidos con una comprobación son una canalización; los pasos conocidos sin comprobación son una sola llamada cuya salida una persona lee. Los pasos abiertos son un agente, y entonces cuentas sus paradas por tipo, como hace el capítulo 10, antes de creer que el diseño funciona.
Decisiones que tomó este capítulo
- El valor por defecto para los pasos conocidos que tienen una comprobación es una canalización, construida y medida antes que cualquier agente. Esto sigue el consejo de empezar por el diseño más simple. Es una regla práctica.
- Las acciones de la canalización y las llamadas a modelo del agente se cuentan por separado y nunca se valoran en dinero, por la razón expuesta en el capítulo 11.
- Una negativa va antes que el sí de una persona, porque un sí no puede levantar un cambio prohibido. El capítulo 6 da la razón.
- Las lecturas son el juicio del autor. Un lector que no esté de acuerdo puede cambiar una lectura en el ejemplo y volver a ejecutarlo, y las reglas se mantienen como están.
- Las ejecuciones registradas se informan tal como terminaron, y el registro de T-02 es un fallo repetido, no un caso cercano.
- No se recomienda ninguna división para este caso. Ninguna tarea alcanza la condición de contexto, y el libro no mide una división frente a un único bucle.
- El diseño de una sola llamada tiene un caso, pero no está en el conjunto, y su salida no está comprobada por ninguna prueba. Solo se muestra la regla.
Lo que se aprendió es más limitado de lo que sugieren las reglas. La mayoría de las tareas de pasos conocidos del conjunto son canalizaciones sobre el papel, y solo tres se han ejecutado como tal. Las tareas de parada se juzgaron por sus preguntas, y el evaluador que hizo ese juicio es la parte más débil del caso.
Regla práctica: Trata la canalización de una regla como una predicción hasta que una ejecución la haya medido, y anota dónde va su parada antes de construirla.
Este capítulo, en esta edición
Edición 2026.11.2Ejemplos verificados el 20 de nov de 2026Superan la prueba 2 de 2 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.2.