Entregar una subtarea a un hijo y devolver una parada
Unos 22 minutos de lectura, con 4 ejemplos en 7 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 terminar este capítulo podrás entregar una subtarea a un bucle hijo con un presupuesto de pasos propio, y recibir un resumen y un motivo de parada en lugar de toda la transcripción del hijo. También harás que una parada llegue a una persona: una ejecución que las reglas de parada dan por atascada pasa a un padre, que plantea la pregunta de la parada al mantenedor que abrió la incidencia.
Tomemos la tarea T-02 del caso: en unitcraft, una pequeña biblioteca de unidades, un importe negativo pierde su separador de miles, y el agente de mantenimiento tiene que corregirlo. La ejecución lee unitcraft/format.py y hace dos ediciones en él. Ambas fallan, porque el texto antiguo que nombran no está en el archivo tal como aparece, así que el resultado de las pruebas se mantiene igual. El capítulo 2 termina una ejecución así una vez que las reglas no ven progreso. El arnés v1 ejecutó T-02 hasta su tope de pasos en la grabación task-set. Repetida con las dos reglas de parada del capítulo 2, las mismas respuestas terminan esta ejecución como no_progress at step 5 of 16. La parada cumple su función, pero deja al mantenedor con un registro y sin una explicación de lo que intentaba el agente. Alguien tiene que leer el registro para averiguarlo.
El tamaño es el segundo problema. Encontrar dónde vive una regla de redondeo obliga a leer varios archivos, y cada archivo que el agente lee permanece en el contexto que lleva su siguiente paso. Una tarea secundaria como esa se hace mejor en un contexto propio, que devuelve solo lo que necesita el padre. La documentación de subagentes de Anthropic describe esa separación para su producto: el subagente hace el trabajo en su propio contexto y devuelve solo el resumen.
Este capítulo construye el hijo para ese caso. Un hijo es el mismo bucle, con un presupuesto propio. En este libro, un traspaso es el final de una ejecución con una pregunta dirigida a una persona, en lugar de un cierre: ya sea la llamada ask_user del propio modelo, o el traspaso estructurado del arnés tras una parada, que lleva el motivo de la parada, lo que la ejecución intentó y una pregunta. Un hijo devuelve su traspaso a su padre: cómo terminó, qué intentó, qué archivos leyó y cambió, y o bien su resumen o bien la pregunta en la que se detuvo. Nunca devuelve su transcripción. Una parada que termina a un hijo llega al mantenedor como una pregunta.
Un hijo es un bucle con su propio presupuesto
Una tarea secundaria en el caso, como encontrar dónde vive una regla de redondeo, puede dar pasos que el presupuesto del padre no debería pagar. Un hijo es el bucle del capítulo 1, iniciado por un padre en mitad de su propia ejecución. Tiene las mismas herramientas y las mismas reglas de parada, y lleva una transcripción propia. Lo que cambia es el conteo. El presupuesto del hijo cuenta sus propias llamadas al modelo, desde la primera, de modo que los pasos del padre no pagan por el trabajo del hijo, y un hijo que entra en bucle agota su propio presupuesto. Es el conteo que el capítulo 5 prometió a un hijo: sus propios pasos, no los del padre. El run_tests de un hijo pasa por el mismo ejecutor de pruebas en sandbox que el de su padre, con los límites, el entorno limpio y la ausencia de archivos conftest que describe el capítulo 7, porque al hijo se le da el mismo conjunto de herramientas. La ruta es run_tests en lib/tools.py, luego run_pytest y run_command allí, y después run_sandboxed en lib/sandbox.py. Ningún ejemplo ejecuta el comando de un hijo de otra manera.
Dale al hijo 4 pasos y ejecútalo en T-01. Los primeros pasos de la grabación task-set, del modelo del capítulo 1, se reproducen para él, de modo que el hijo hace al principio lo que hizo la ejecución grabada.
1"""A child loop on T-01 with a budget of 4 steps. The budget counts the child's own model calls, and it ends the child2as step_cap with no finish. The child's requests match the recording's first four steps, so they replay."""3from lib.case import load_tasks4from lib.models import ReplayModel5from lib.subagents import run_child6from lib.tools import V17from lib.trace import IdCounter89BUDGET = 410task = load_tasks(only=["T-01"])[0]11child = run_child(ReplayModel("task-set", "T-01"), task, V1, budget=BUDGET, ids=IdCounter())12print("child budget, steps:", BUDGET)13print("child steps:", child.handoff.steps)14print("child result:", child.handoff.ended)15print("child tools:", ", ".join(child.tool_names))16print("child steps, in order:", *child.trace, sep="\n ")17child.run.close()18assert child.handoff.ended == "step_cap" and child.handoff.steps == BUDGET
python child-with-budget.pychild budget, steps: 4
child steps: 4
child result: step_cap
child tools: list_files, read_file, run_tests, write_file, edit_file, ask_user, finish
child steps, in order:
step 1: list_files: 25 files
step 2: read_file: 23 lines
step 3: edit_file: error: old text not found in unitcraft/format.py
step 4: read_file: 23 lines
Fue el presupuesto, no las herramientas, lo que terminó con este hijo: usó todos sus pasos y nunca llamó a finish. Su presupuesto cuenta llamadas al modelo, 4 de ellas aquí frente a un presupuesto de 4, y el arnés termina al hijo como step_cap. Sus herramientas son el conjunto completo de herramientas v1, list_files, read_file, run_tests, write_file, edit_file, ask_user, finish, así que es el presupuesto lo que contiene al hijo, no un conjunto de herramientas más pequeño.
Esos 4 pasos son toda la ejecución del hijo. Lista los archivos, lee uno, intenta una edición que falla porque el texto antiguo no está en el archivo tal como se escribió, y vuelve a leer el archivo. Al presupuesto no le importa cuál de esos pasos fue útil. Los cuenta.
Un padre puede iniciar él mismo al mismo hijo, mediante una herramienta. En el siguiente ejemplo el padre es un bucle con dos herramientas, start_child y ask_user. Inicia el hijo en T-02 bajo ambas reglas de parada, lee el traspaso del hijo como resultado de la herramienta y hace a la persona la pregunta que trae el traspaso.
1"""A parent loop starts the child on T-02 through a tool, reads the child's handoff and asks the person the child's2question. The output counts the parent's steps apart from the child's, and shows that the child's file text stays out of3the parent's context."""4from lib.case import load_tasks5from lib.loop import Stops, run_task6from lib.models import ReplayModel7from lib.subagents import ParentReadsHandoff, characters, start_child_tools8from lib.tools import V19from lib.trace import IdCounter1011RULES = Stops(repeat_limit=3, no_progress_limit=2)12task = load_tasks(only=["T-02"])[0]13child_ids = IdCounter()14child_ids.next("run") # the recording numbers its runs in task order, so T-02 is run-0002: skip T-01's number15children = []16tools = start_child_tools(task, lambda: ReplayModel("task-set", task.id), ids=child_ids, stops=RULES, children=children)17parent_model = ParentReadsHandoff(task.id)18parent = run_task(parent_model, task, tools, max_steps=tools.step_cap, ids=IdCounter())19child = children[0]20h = child.handoff21# the child's longest tool result is its read of the library file, the text a parent must not receive22file_text = max((m["content"] for m in child.transcript if m["role"] == "tool"), key=len)23parent_text = "\n".join(m["content"] for m in parent_model.messages)24print("child budget, steps:", V1.step_cap)25print("child steps:", h.steps)26print("child result:", h.ended)27print("parent steps:", parent.steps)28print("parent result:", parent.ended)29print("parent tools:", ", ".join(t.name for t in tools.tools))30print("question asked matches the handoff:", "yes" if parent.question == h.question else "no")31print("child transcript, characters:", characters(child.transcript))32print("handoff in parent context, characters:", len(h.text))33print("parent context at last step, characters:", characters(parent_model.messages))34print("child file text in parent context:", "yes" if file_text in parent_text else "no")35print("parent steps, in order:", *parent.trace.lines(), sep="\n ")36assert h.ended == "no_progress" and parent.ended == "ask_user" and parent.steps == 237assert parent.question == h.question and file_text not in parent_text38parent.close()
python parent-starts-child.pychild budget, steps: 16
child steps: 5
child result: no_progress
parent steps: 2
parent result: ask_user
parent tools: start_child, ask_user
question asked matches the handoff: yes
child transcript, characters: 5408
handoff in parent context, characters: 436
parent context at last step, characters: 1041
child file text in parent context: no
parent steps, in order:
step 1: start_child: child no_progress at step 5
step 2: ask_user: ask_user
La pregunta del padre es la del hijo, palabra por palabra, y el texto del archivo del hijo no está en el contexto del padre. El hijo consume 5 pasos de su propio presupuesto, y el padre consume 2, uno para iniciar al hijo y otro para preguntar. El padre recibe un traspaso de 436 caracteres, mientras que la transcripción del hijo contiene 5408.
El final es una parada como cualquier otra. Un hijo que alcanza su presupuesto termina sin llamar a finish, y el traspaso de la sección sobre las paradas lleva ese final al padre, que es donde se toma la siguiente decisión.
Regla práctica: Da a cada hijo un presupuesto propio, contado en sus propias llamadas al modelo y nunca compartido con el padre. Fíjalo a partir de ejecuciones que terminaron en el conjunto de tareas, no a partir de una suposición. Un presupuesto inferior a lo que necesitan las ejecuciones terminadas convierte el trabajo terminado en paradas.
Un encargo con cuatro partes
El informe es el trabajo tal como lo recibe el hijo. Aquí el hijo solo recibe el texto de la incidencia: el hijo T-02 de summary-to-parent parte de la propia incidencia de la tarea, y no de nada que haya escrito el padre. El relato de Anthropic sobre su sistema de investigación multiagente nombra cuatro partes que necesita el informe de cada subagente: un objetivo, un formato de salida, orientación sobre las herramientas y fuentes que debe usar, y límites claros de la tarea. Escrito con esas cuatro partes, un informe para un hijo T-02 podría leerse así:
Objective: find out why the two edits to unitcraft/format.py left the test result where it was.
Output format: a short summary, then the files read and the files edited.
Tools and sources: read_file and run_tests on the scratch copy; edit_file only on unitcraft/format.py.
Boundaries: do not change a test or any file other than unitcraft/format.py. If the fix needs a public name changed, call ask_user instead of editing.
Cada parte protege contra un fallo que el caso T-02 hace probable. El objetivo mantiene al hijo en las dos ediciones, y lejos del resto de la biblioteca. El formato de salida permite al padre leer el resultado de una sola pasada, con los archivos al final, que es donde los busca. La línea de herramientas y fuentes indica en qué archivo puede editar el hijo. El hijo de estos ejemplos tiene el conjunto completo de herramientas v1, incluida write_file, así que esa línea es texto que escribe el padre y nada de lo que hay aquí la hace cumplir. La línea files changed del traspaso muestra después qué archivos cambió el hijo, y su línea edits failed cuántas ediciones no se aplicaron. Los límites son la parte que un responsable revisa primero, porque las pruebas visibles son la comprobación, y una edición a una prueba pasaría sin arreglar nada.
El informe es un texto que escribe el padre, y este capítulo no lo mide. El mismo relato señala, como observación y no como medición, que los subagentes a los que se les daban tareas vagas a veces duplicaban las búsquedas de los demás, y que un informe explícito fue la solución del proveedor. Ningún ejemplo aquí prueba un informe vago. Lo que sí hace comprobable el informe es el límite. El traspaso de la sección sobre lo que regresa enumera los archivos que el hijo leyó y cambió, y esos pueden contrastarse con los límites línea por línea.
Regla práctica: Escribe las cuatro partes en un informe antes de que empiece un hijo, y escribe los límites como archivos y herramientas, no como intenciones. Un informe que no pueda decir cuándo termina el hijo, ni qué archivos puede editar, no está listo para enviarse.
Qué vuelve
La ejecución de T-02 deja una transcripción de cada archivo que leyó, cada edición fallida y cada ejecución de pruebas, y eso es mucho más de lo que su padre necesita de vuelta. El padre necesita el resultado del hijo y suficiente del camino del hijo para juzgar ese resultado. No necesita las lecturas. Un hijo detenido necesita el mismo tratamiento, con un motivo de detención y una pregunta añadidos.
Ejecuta T-02 como hijo bajo ambas reglas de parada, con el límite de pasos del conjunto de tareas, e imprime lo que recibe el padre junto con el tamaño de la transcripción del hijo.
1"""T-02's recorded run as a child, with both stop rules and the task set's step cap. The parent gets the2handoff's fields and not the child's transcript; the example prints the size of each."""3from lib.case import load_tasks4from lib.loop import Stops5from lib.models import ReplayModel6from lib.subagents import characters, run_child, tokens7from lib.tools import V18from lib.trace import IdCounter910RULES = Stops(repeat_limit=3, no_progress_limit=2)11task = load_tasks(only=["T-02"])[0]12ids = IdCounter()13ids.next("run") # the recording numbers its runs in task order, so T-02 is run-0002: skip T-01's number14child = run_child(ReplayModel("task-set", "T-02"), task, V1, budget=V1.step_cap, ids=ids, stops=RULES)15h = child.handoff16print("child result:", h.ended, "at step", h.steps, "of", h.budget)17print("transcript messages:", len(child.transcript))18print("child transcript, characters:", characters(child.transcript))19print("child transcript, estimated tokens:", tokens(characters(child.transcript)))20print("parent receives, characters:", len(h.text))21print("parent receives, estimated tokens:", tokens(len(h.text)))22print("saved by the handoff, characters:", characters(child.transcript) - len(h.text))23print("what the parent receives:")24print(h.text)25child.run.close()26assert task.issue not in h.text and len(h.text) < characters(child.transcript)
python summary-to-parent.pychild result: no_progress at step 5 of 16
transcript messages: 12
child transcript, characters: 5408
child transcript, estimated tokens: 1803
parent receives, characters: 436
parent receives, estimated tokens: 146
saved by the handoff, characters: 4972
what the parent receives:
child: child-0001
ended: no_progress
steps: 5 of 16
tried: edit_file 2, list_files 1, read_file 2
files read: unitcraft/format.py
files changed: none
edits failed: 2
stop: no_progress (edit_file, 2 edits in a row left the test result unchanged: 8 failed, 22 passed)
question: The last 2 edits left the test result unchanged (last result: 8 failed, 22 passed). Should a person look at unitcraft/format.py, or should the agent keep going?
El padre recibe el traspaso, y nada más. El hijo terminó como no_progress at step 5 of 16, y la transcripción que conservó suma 5408 caracteres. El traspaso que lee el padre ocupa 436 caracteres.
La línea de archivos modificados del traspaso dice none, y la línea de ediciones fallidas dice 2. Ambas ediciones nombraban unitcraft/format.py, pero los bytes del archivo no cambiaron, así que la línea de modificados lo omite y el recuento de fallidas indica que las ediciones no se aplicaron.
En tokens, la misma diferencia se lee 1803 frente a 146. Son estimaciones hechas con la regla del capítulo 5, no recuentos del tokenizador del modelo, y este capítulo solo las usa para comparar tamaños.
Las líneas del traspaso aparecen en un orden fijo: el ID del hijo, cómo terminó, sus pasos frente a su presupuesto, las herramientas que probó y con qué frecuencia, los archivos que leyó, los archivos que modificó, el número de ediciones fallidas, y después el motivo de detención y la pregunta. Un hijo que termina da su resumen en lugar de la detención y la pregunta. Los hijos terminados se cuentan, pero sus resúmenes no se imprimen, así que esa línea no aparece en ninguna salida. El ejemplo comprueba que el texto del problema no aparece literalmente en el traspaso, de modo que el padre trabaja con lo que hizo el hijo, no con la redacción de la tarea.
Lo que el padre hace con el traspaso es decisión del padre, y este capítulo no la programa. El código de este capítulo construye una elección: el padre plantea la pregunta al mantenedor. La misma conexión podría lanzar un segundo hijo con un encargo más estrecho que nombre un archivo que el traspaso lista, o responder solo con los campos. Ningún ejemplo construye ninguna de esas opciones. Cada una deja fuera del contexto del padre la transcripción del hijo, que es precisamente la razón del traspaso.
El registro propio del hijo se conserva, y es lo que rastrea el capítulo 11. El padre no lo abre.
Regla práctica: Devuelve al padre el ID de un hijo, cómo terminó, sus recuentos, sus archivos y su detención o su resumen, y nada más. Conserva la transcripción en el registro propio del hijo, donde una traza puede leerla.
Una parada devuelta
La ejecución de T-02 termina atascada, y una parada por sí sola no le dice al mantenedor qué decidir. El capítulo 2 dio a cada parada un nombre y una razón, pero alguien todavía tiene que elegir entre quitarle la tarea al agente, darle más pasos o probar otro enfoque. Ese alguien es el mantenedor que abrió el issue. Por eso, una parada que el harness no puede resolver se convierte en una entrega a un padre, y el padre le pregunta al mantenedor.
La alternativa es registrar la parada y descartar la ejecución. Eso mantiene pequeño el contexto del padre, pero deja la decisión sin dueño. La entrega conserva la decisión en manos del mantenedor, y le cuesta al padre un paso corto en las ejecuciones que siguen.
Para las tres paradas que dejan atascado a un hijo, step_cap, repeated_call y no_progress, el harness construye la entrega a partir del registro propio de la ejecución: su traza, su racha de llamadas repetidas y sus conteos de pruebas. La razón de la parada, los conteos y la pregunta provienen de ese registro. Ningún modelo los escribe, así que una ejecución reproducida da siempre la misma entrega. El padre es un bucle propio, con un presupuesto pequeño de pasos y dos herramientas, ask_user y finish. En un diseño real el padre sería un modelo que formula la pregunta al mantenedor. Aquí un padre programado transmite la pregunta exactamente como la entrega la da, de modo que la ejecución muestra el cableado y no el juicio de un modelo.
Un hijo que termina de otra forma no se devuelve. Una ejecución que termina como no_tool_call, por ejemplo, produce una entrega sin razón de parada y sin pregunta, así que el padre no tiene nada que plantearle a la persona. Ninguna ejecución de aquí terminó de esa forma (0 de las ejecuciones), así que ningún ejemplo lo muestra.
Ejecuta cada ejecución del conjunto de tareas como hijo bajo ambas reglas de parada. Cada hijo que termina atascado pasa a un padre, que le hace a la persona su pregunta.
1"""The 20 task-set runs as children, with both stop rules. Each child that ended stuck is handed to a parent, which2puts the stop's question to the person with ask_user. Counts only: how the children ended, and what the parents got."""3from collections import Counter45from lib.loop import Stops6from lib.models import ScriptedModel7from lib.subagents import STUCK, asks, characters, hand_to_parent, task_set_children8from lib.trace import IdCounter910RULES = Stops(repeat_limit=3, no_progress_limit=2)11ENDS = ("finish", "ask_user", "step_cap", "repeated_call", "no_progress", "no_tool_call")12children = task_set_children(RULES)13stuck = [(task, h, transcript) for task, h, _, transcript in children if h.stuck]14ends = Counter(h.ended for _, h, _, _ in children)15print("child runs:", len(children))16for ended in ENDS:17 print(f" {ended}: {ends[ended]}")18print("done with the rules:", sum(1 for _, _, ok, _ in children if ok))19print("ended with finish or ask_user:", sum(1 for _, h, _, _ in children if h.ended in ("finish", "ask_user")))20print("done among the handed back:", sum(1 for _, h, ok, _ in children if h.stuck and ok))21print("handed back to a parent:", len(stuck))22handed = Counter(h.ended for _, h, _ in stuck)23for ended in STUCK:24 print(f" {ended}: {handed[ended]}")25print("handed back, tasks:", ", ".join(task.id for task, _, _ in stuck))2627parent_ids = IdCounter() # the parents number their runs apart, so the children's run IDs stay the recording's28parents = [(h, hand_to_parent(ScriptedModel([asks(h.question)]), h, parent_ids)) for _, h, _ in stuck]29print("parent asked the person, with the handoff's question:",30 sum(1 for h, r in parents if r.ended == "ask_user" and r.question == h.question))31print("child steps, all handed back:", sum(h.steps for _, h, _ in stuck))32print("parent steps, all handed back:", sum(r.steps for _, r in parents))33print("child transcripts, characters:", sum(characters(t) for _, _, t in stuck))34print("handoffs the parents read, characters:", sum(len(h.text) for _, h, _ in stuck))35print("saved by the handoffs, characters:",36 sum(characters(t) for _, _, t in stuck) - sum(len(h.text) for _, h, _ in stuck))37assert all(h.stop and h.question for _, h, _ in stuck), "every stuck child gives a stop reason and a question"38assert not any(ok for _, h, ok, _ in children if h.stuck), "a done task must not be handed back"
python handoff-on-stuck.pychild runs: 20
finish: 6
ask_user: 1
step_cap: 1
repeated_call: 1
no_progress: 11
no_tool_call: 0
done with the rules: 5
ended with finish or ask_user: 7
done among the handed back: 0
handed back to a parent: 13
step_cap: 1
repeated_call: 1
no_progress: 11
handed back, tasks: T-01, T-02, T-03, T-06, T-10, T-11, T-12, T-13, T-15, T-16, T-17, T-19, T-20
parent asked the person, with the handoff's question: 13
child steps, all handed back: 83
parent steps, all handed back: 13
child transcripts, characters: 95252
handoffs the parents read, characters: 5874
saved by the handoffs, characters: 89378
Ninguna de las ejecuciones que una parada devolvió está hecha. Las reglas devuelven 13 de las 20 ejecuciones, y ninguna de ellas está hecha. Cada una llega a un padre, y los padres plantean la pregunta a la persona 13 veces, una por cada una. La parada que más aparece es no_progress, la misma en la que terminó T-02.
Las reglas de parada no cuestan trabajo terminado. 7 ejecuciones terminaron con finish (6) o con ask_user (1), y todas las 5 ejecuciones completadas están entre ellas, porque ninguna de las ejecuciones devueltas estaba hecha. Las demás ejecuciones de ese grupo no están hechas, y ninguna terminó por una regla de parada, así que ninguna entrega las cubre. Una ejecución que termina con finish o ask_user nunca llega a un padre bajo estas reglas, esté o no bien que terminara ahí.
Las ejecuciones devueltas son T-01, T-02, T-03, T-06, T-10, T-11, T-12, T-13, T-15, T-16, T-17, T-19, T-20. Entre ellas, sus hijos dieron 83 pasos, y sus padres dieron 13 pasos, uno cada uno, la llamada que le pregunta a la persona.
Las transcripciones de los hijos tenían 95252 caracteres, y los padres leyeron 5874 caracteres de entrega entre ellos. Se comprueba que cada hijo devuelto dé una razón de parada y una pregunta. Eso verifica la forma de la entrega, pero no que la pregunta sea la correcta.
La pregunta de la ejecución T-02 termina así: "¿Debe revisar una persona unitcraft/format.py, o debe el agente seguir intentándolo?" Nombra el archivo que mencionaban las dos ediciones fallidas, así que el mantenedor sabe dónde mirar sin abrir la transcripción. La línea de archivos cambiados de la entrega dice que no cambió ningún archivo, así que la pregunta apunta a un archivo que las ediciones nombraron pero nunca modificaron.
Una advertencia, dicha una sola vez: una entrega dice que una ejecución se detuvo y por qué. No dice que la tarea no se pudo terminar. Este libro cuenta una ejecución devuelta como no completada, tal como lo hace el ejemplo.
Regla práctica: Entrega a una persona, como pregunta, cada parada atascada (step_cap, repeated_call, no_progress), con su razón de parada, sus conteos y sus archivos. Un padre trabaja a partir de la entrega. El registro del hijo se queda con el hijo, donde una traza puede leerlo.
Dos diseños, y de quién son las cifras
Qué diseño debe usar una división depende de lo que el padre tenga que hacer con el resultado del hijo. Se usan mucho dos diseños, y difieren en lo que ocurre con la conversación. En el diseño de este capítulo, el hijo devuelve un resultado y se detiene. En un traspaso del SDK, la conversación pasa a otro agente. El SDK usa la palabra traspaso (handoff) para el segundo diseño, que no es el significado que tiene en este capítulo. Nada de esta sección se ejecutó aquí, y sus cifras pertenecen a sus fuentes.
La documentación de traspasos (handoffs) del SDK de OpenAI Agents, para el SDK 0.24.0 tal como se consultó en noviembre de 2026, describe el segundo. Un traspaso es una herramienta que el modelo llama, con el nombre de su destino; su ejemplo es transfer_to_refund_agent. El agente receptor ve toda la conversación anterior, salvo que un filtro de entrada cambie lo que ve. Para un especialista que debe devolver un resultado sin tomar la conversación, la misma página recomienda envolver el agente como herramienta, con Agent.as_tool. Su historial anidado, que resume la conversación anterior, es una beta que hay que activar expresamente y está desactivada por defecto.
La documentación de subagentes de Claude Code, tal como se consultó en noviembre de 2026, describe el primer tipo. Un subagente tiene un límite de turnos agénticos, que este libro llamaría pasos, configurado como maxTurns. Cuando un subagente alcanza el límite, su salida regresa marcada como parcial, y el padre puede reanudarlo. La página dice que la marca parcial "requiere Claude Code v2.1.246 o posterior"; nada de esto se ejecutó con esa versión. Los subagentes integrados heredan las reglas de permisos del padre, y la mayoría funciona con un conjunto restringido de herramientas. Un subagente personalizado tiene sus propias herramientas y permisos independientes. La forma coincide con el presupuesto de este capítulo, con el traspaso desempeñando el papel del resultado parcial.
La medición que cita esta sección proviene de la empresa que construyó el sistema que mide. En junio de 2025, el relato de Anthropic sobre su sistema de investigación informó que "un sistema multiagente con Claude Opus 4 como agente principal y subagentes Claude Sonnet 4 superó en un 90.2% a un Claude Opus 4 de agente único en nuestra evaluación interna de investigación". Esa comparación enfrenta un sistema multiagente con un agente único, con un modelo distinto en los subagentes, en una evaluación cuya métrica la entrada no nombra. La entrada dice que sus evaluaciones favorecen consultas de amplitud, donde se pueden seguir muchas direcciones independientes a la vez.
La misma entrada da una segunda medición, sobre la evaluación BrowseComp: "el uso de tokens por sí solo explica el 80% de la varianza". Dice que los sistemas multiagente funcionan principalmente porque gastan suficientes tokens para resolver el problema. Sus propios datos sitúan a los agentes en unas cuatro veces los tokens de un chat, y a los sistemas multiagente en unas quince veces. También dice que algunos dominios, donde los agentes deben compartir un mismo contexto o depender unos de otros de muchas formas, no encajan bien, y que su agente principal ejecutaba los subagentes por lotes, esperando a que terminara cada conjunto. Una división no es paralela por tener varios agentes.
Un argumento muy leído contra dividir proviene del ensayo "Don't Build Multi-Agents" de Walden Yan, publicado por Cognition en 2025. Su primer principio es "Comparte el contexto, y comparte las trazas completas de los agentes, no solo mensajes individuales". El traspaso lo incumple: pasa los campos del hijo y su resumen o su parada, y nunca su traza completa. El segundo principio del ensayo es que las acciones llevan decisiones implícitas, así que los agentes que trabajan por separado pueden actuar según decisiones contradictorias. Es un ensayo, el juicio de un profesional.
La forma más sencilla que propone el ensayo para seguir sus principios es un agente lineal único con un contexto continuo. Para tareas muy largas propone un modelo que comprime el historial en detalles clave, eventos y decisiones, y dice que esto es difícil de hacer bien. Eso se parece a la compactación del capítulo 5 y a este traspaso. El ensayo también acepta un subagente que responde a una pregunta bien definida, normalmente sin escribir código.
El hijo de ejemplo de este capítulo sí escribe código: el hijo de T-02 edita unitcraft/format.py, que es el caso contra el que argumenta el ensayo. Aquí un hijo edita y el padre no edita ese archivo, así que el conflicto que describe el segundo principio no surge en estos ejemplos. Las razones de las ediciones del hijo siguen sin llegar al padre, y la objeción del ensayo a eso sigue en pie. El libro construye al hijo de todos modos, porque el caso de T-02 necesita un hijo que pueda cambiar la biblioteca. La división compensa cuando un resultado puede usarse sin las razones que lo sustentan, que es el caso que describe la documentación del producto.
Recomendamos un hijo para una tarea secundaria cuyo resultado se sostiene por sí solo, y un único bucle para el trabajo en el que el padre y el hijo editarían los mismos archivos.
Regla práctica: Usa un hijo cuando su resultado pueda usarse sin sus razones: un hecho, una lista de archivos, o una parada con su pregunta. Mantén un solo bucle cuando el padre deba actuar sobre los archivos que editaría el hijo. Este libro no mide una división frente a un solo bucle, así que la regla se apoya en el argumento anterior, no en una medición.
Qué sale mal en producción
Dividir el trabajo trae fallos que un bucle único no tiene. El primero es un presupuesto medido en la unidad equivocada. Un presupuesto contado en segundos detiene a un hijo por una ejecución lenta de pruebas tanto como por un bucle, y una repetición no puede reproducirlo, porque la misma ejecución tarda un tiempo distinto cada vez. Por eso este capítulo cuenta llamadas al modelo y no tiempo.
El segundo es un padre que decide por la persona. El padre de handoff-on-stuck tiene entre sus herramientas tanto finish como ask_user, así que un modelo que cree saber la respuesta puede terminar una ejecución atascada sin preguntarle a nadie. En producción, a un padre que recibe una detención solo se le deben dar los medios para preguntar, y una detención que llega a él siempre debe terminar con una pregunta al responsable del mantenimiento.
El tercero es una división que el padre no puede conciliar. Dos hijos que editan el mismo archivo pueden devolver cada uno un resumen limpio, y el padre tiene entonces que abrir ambos registros para ver que sus ediciones no coinciden. El traspaso no muestra por sí solo esa discrepancia, que es precisamente el punto de la visión contraria.
El cuarto es un coste que no se ve. Los tokens de un hijo son suyos, y la cifra del proveedor sitúa un sistema multiagente en unas quince veces los tokens de un chat. Registra los tokens de cada hijo en su propio registro, como hace el capítulo 11, o el coste de una división nunca llega al recuento del padre.
Regla práctica: Cuenta el presupuesto de un hijo en llamadas al modelo, da a su padre solo los medios para preguntar y comprueba las ediciones de cada división frente a los archivos que cambiaron los otros hijos antes de fusionarlas. Registra los tokens de cada hijo en su propio registro, para que el coste de una división se cuente donde se gasta.
Decisiones que tomó este capítulo
Para el mantenedor, el cambio es que la parada T-02 ahora llega como una pregunta sobre un solo archivo. Antes terminaba en un registro que el mantenedor tenía que leer, sin ninguna decisión asociada. Con este diseño llega al mantenedor con sus archivos y con una pregunta que indica qué archivo revisar. Cada elección que sigue puede cambiarse, y cada una modifica lo que el mantenedor ve cuando una ejecución sale mal. Las tres primeras deciden qué puede gastar un hijo, qué devuelve y de dónde sale el motivo de una parada. Las tres últimas deciden cuándo vale la pena separar un hijo y quién responde cuando no puede terminar.
- El presupuesto de un hijo cuenta sus propias llamadas al modelo, y el recuento del padre no las incluye.
- Un hijo devuelve campos y su resumen o su parada, nunca su transcripción. La transcripción permanece en su propio registro.
- El motivo de una parada, los recuentos y la pregunta provienen del registro de la ejecución, construido por código, de modo que una repetición produce el mismo traspaso.
- Un hijo atascado pasa a un padre con un presupuesto de pasos reducido; este pregunta al mantenedor que registró el issue mediante
ask_user. - Un hijo sirve para una tarea secundaria cuyo resultado se sostiene por sí mismo. El trabajo en el que el padre y el hijo editan los mismos archivos se mantiene en un solo bucle.
- Una parada que llega a una persona como pregunta resulta más útil que una parada que termina en un registro. El capítulo 12 aborda el caso en que ninguna división, ni ningún agente, vale su costo.
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.