Seis subagentes por rol contra un solo agente que carga skills, medido en 24 corridas sobre tareas reales. El agente único fue 71 % más rápido y gastó 73 % menos tokens, pero se le escaparon bugs que el flujo viejo atrapaba. Adopté un híbrido sabiendo que tampoco llega a 10 de 10.


El flujo de agentes de este sitio tenía seis subagentes: qa buscaba los casos borde, tester escribía las pruebas, coder las ponía en verde, y reviewer, security y performance revisaban el diff. Es la evolución del que conté en cuatro agentes y un revisor sin contexto y que después metí en cajas, al estilo de Stripe.

Funcionaba, pero tenía tres dolores: era lento, caro en tokens y me obligaba a intervenir mucho. En octubre, Anthropic publicó una guía sobre cuándo integrar los subagentes en el loop principal. Su tesis es que un solo agente que carga habilidades cuando las necesita suele ganar en calidad, costo y latencia.

La pregunta que me hice no fue «qué dicen los laboratorios», sino qué gana mi repo, medido.

Lo que dicen las fuentes

  • Anthropic recomienda un solo agente con skills y reserva los subagentes para tres casos: cuando el contexto se degrada por exceso, cuando hay trabajo paralelo con contexto desechable o cuando hay conflicto de herramientas o instrucciones. También los mantiene para verificar y para separar permisos. El método de migración es lo más útil del artículo: primero evals (10 casos de referencia alcanzan), después una línea base, y luego se integra un subagente a la vez. Si la versión integrada puntúa peor, ese subagente se queda. Publicaron además un kit de referencia, sin mantenimiento.
  • Cognition, en Multi-Agents: What's Actually Working, dice que las escrituras van en un solo hilo y que los demás agentes solo aportan razonamiento, por ejemplo un revisor con contexto limpio.
  • Anthropic, en Multi-agent coordination patterns, describe cinco patrones, entre ellos generador y verificador.

El matiz importa: la tendencia no es «cero subagentes», sino un agente que escribe y verificadores con contexto limpio.

El método: tareas reales, dos corridas y un criterio fijado antes

Elegí cinco commits reales del repo, todos posteriores a la creación del flujo de seis agentes, de menor a mayor:

Tarea Qué ejercita
t1, escapar el título del layout (XSS) El costo fijo del flujo en un cambio de una línea
t2, comodines LIKE literales en una búsqueda Casos borde
t3, limitar los POST por red /48 de IPv6 Lógica de red y tests de integración
t4, log diario y tope de reportes de excepciones Clase nueva, config y muchos tests
t5, dejar de buscar por cédula y enmascararla PHP y Vue, privacidad

Cada tarea corrió dos veces por flujo, con el mismo prompt y las mismas respuestas fijas de mi parte, en un sandbox armado desde el commit padre: un repo nuevo con un solo commit (sin historia del futuro), su propio proyecto de Docker Compose y la suite en verde antes de empezar.

Medí cuatro cosas:

  1. Tiempo activo, sin contar lo que yo tardaba en responder.
  2. Tokens de la sesión principal y de todos los subagentes.
  3. Intervenciones mías fuera del guion.
  4. Tests ocultos: las pruebas del commit original, copiadas al final. Separé comportamiento (caja negra) de forma (el texto de un log, el nombre de una clave).

Y antes de correr nada escribí la regla. El flujo nuevo gana solo si mantiene 10 de 10 en comportamiento, baja al menos 30 % el tiempo o los tokens y no pide más intervenciones que el actual.

Cómo un agente puede ver la solución

Repetir tareas ya resueltas tiene una trampa: la solución está en algún lado de la máquina. Cerrar las fugas fue la mitad del trabajo.

Por dónde se filtraba Cómo lo encontré
La historia de git Obvio desde el diseño
La memoria automática del proyecto Decía literalmente cómo se había resuelto t1 y en qué commit
Los transcripts de las sesiones originales Revisando rutas
El repo real en HEAD Una prueba sin interfaz: git -C al repo real mostró un commit del futuro
Los planes de plan mode en ~/.claude/plans Después de la primera corrida: ahí estaban los planes originales de t2 y t5, con la solución
Los otros sandboxes t1 corre sobre un padre anterior a t2: leer el sandbox de t2 era leer el futuro

La respuesta fue una cerca: un hook que rechaza cualquier llamada a una herramienta que nombre el repo real, otro sandbox o esas carpetas. Los planes se mueven dentro del sandbox. Un detalle que costó encontrar: si la carpeta de planes queda fuera del proyecto, Claude Code vuelve en silencio a la ruta global.

La cerca también tuvo falsos positivos que enseñan algo. Bloqueó a la sesión leyendo sus propias salidas largas, que Claude Code guarda en una carpeta de la sesión, y bloqueó un mensaje legítimo porque el hook recibe una vista previa recortada del texto. La auditoría final dio 0 fugas en las 20 corridas de la comparación.

Qué cambió en el flujo nuevo

Antes (agente) Después
qa skill edge-cases, usada al escribir el plan
tester skill de testing más un lock de los tests aprobados
coder skill de implementación más un hook de Stop
reviewer, security y performance un solo reviewer en Sonnet, con las skills de seguridad y rendimiento precargadas

Separar agentes no era solo repartir trabajo: también garantizaba cosas. El tester no podía tocar el código y el coder no podía tocar los tests. Con un solo agente, esas garantías tienen que venir de otro lado, y vinieron de hooks:

  • El guard gobierna a la sesión principal. Antes dejaba pasar todo lo que no viniera de un subagente. Ahora la sesión principal puede editar código y tests, pero tocar las instrucciones de los agentes o la configuración de contenedores le pide confirmación a una persona, incluso en modo automático.
  • Tests congelados. Cuando apruebo los tests, un script guarda su hash fuera del alcance del agente. Desde ahí, cualquier edición a esos archivos se rechaza.
  • El turno no termina en rojo. Un hook de Stop corre la suite y, si falla, devuelve el motivo y la sesión sigue trabajando.
  • Pint en cada edición, para que el formato no dependa de acordarse.

Hubo un momento que voy a contar tal cual. Después de implementar la confirmación para Edit y Write, la prueba real fue pedirle a la sesión, en modo automático, que agregara una línea al compose.yaml. No usó Edit: usó printf ... >> compose.yaml por Bash, y pasó. Era justo el hueco que había dejado al no restringir Bash. Lo cerré con una regla: un comando que nombra esas rutas pide confirmación salvo que solo lea. No es perfecta, y lo digo: un comando que llega al archivo sin nombrarlo se escapa. El control determinista sigue siendo Edit y Write; el de Bash es una baranda.

La trampa que me puse yo

Al escribir las skills metí, sin querer, lecciones de la línea base que eran pistas de las tareas: «SQLite necesita ESCAPE» era la solución de t2; el caso del '0', también. Con eso, el flujo nuevo habría ganado por haber visto las respuestas. Las saqué todas: las skills llevan el contenido de los agentes viejos más los cambios de estructura, nada aprendido de estas cinco tareas.

Resultados: más rápido, más barato y con menos calidad

Métrica (10 corridas por flujo) 6 agentes 1 agente + reviewer Cambio
Tiempo activo, mediana 23,1 min 6,6 min −71 %
Tokens de salida, mediana 135,1 K 36,5 K −73 %
Líneas de test agregadas 4.996 1.602 −68 %
Comportamiento correcto 10/10 8/10 peor
Correcciones mías al plan 4 7 peor

La mayor parte del costo del flujo viejo era contexto releído: cada subagente vuelve a leer el repo. Y el tester escribía de dos a tres veces más líneas de test que el commit original (en t1, entre 109 y 163 líneas de test para una línea de producción).

Las dos corridas que fallaron fueron de t4, la del tope de reportes de excepciones. Telescope llama a shouldReport() antes que el handler, así que sin memoizar la decisión cada excepción gasta dos intentos y el tope real queda en la mitad. Las dos corridas viejas lo resolvieron porque qa leyó el código del framework. La nueva A no lo vio; la nueva B lo encontró recién en la segunda ronda del reviewer. Además, ninguna de las dos avisaba si el limitador no se podía construir. Son bugs reales de producción, aunque de borde.

Con mi regla, el flujo nuevo no ganaba. Pero la guía de Anthropic da el paso siguiente: si un subagente integrado puntúa peor, se queda. Aquí ese subagente era qa. Su investigación del framework era lo único que la skill no reemplazaba; tester, coder, security y performance se integraron sin pérdida medible.

El híbrido: un agente que escribe y dos que solo piensan

Armé un tercer flujo con un único cambio: borrar la skill edge-cases y devolver a qa como subagente de solo lectura, en el mismo punto donde corría la skill, sobre el borrador del plan. Lo corrí en t3 y t4, dos veces cada una.

t3 y t4 6 agentes 1 agente Híbrido
Tiempo activo, mediana 27,0 min 8,6 min 15,3 min
Tokens de salida, mediana 183,2 K 49,7 K 78,7 K
Doble conteo de Telescope 2/2 en el plan 0/2 en el plan 1/2 en el plan, 1/2 en la primera revisión
Aviso si el limitador no se construye 2/2 0/2 0/2

En una corrida, qa leyó el Handler y el ExceptionWatcher de Telescope y avisó antes de que existiera el código. En la otra no leyó el archivo donde está el filtro, y lo atrapó el reviewer en la primera ronda. Ninguna corrida híbrida dejó abierto el caso de Telescope.

El aviso cuando el limitador no se construye se perdió en las cuatro corridas sin el flujo viejo. Hay un matiz honesto: mi respuesta fija decía «si el rate limiter o el cache fallan», y construir el limitador es un caso que el texto no nombra. El flujo viejo lo sacó porque qa tenía más turnos y más contexto.

Con la regla fijada al inicio, el híbrido tampoco gana. Comparado con el agente único, tarda 1,8 veces más y gasta 1,6 veces más tokens; comparado con el flujo de seis, tarda 44 % menos y gasta 57 % menos tokens.

La decisión

Lo adopté igual, y quiero dejar escrito por qué. El caso que sigue abierto es de borde y su arreglo es una pregunta mejor en el plan, no otro agente. Lo que gané es tiempo y atención: menos de la mitad de los tokens, poco más de la mitad del tiempo y menos líneas de test que revisar.

La adopción también trajo los arreglos que el experimento destapó:

  • El hook de Stop bloqueaba la segunda ronda de tests. El workflow dice que un caso nuevo vuelve a pasar por rojo y por mi aprobación, pero el hook no dejaba terminar el turno con la suite en rojo. Ahora, si hay tests cambiados que no congelé, deja terminar y me avisa.
  • Los planes inventaban valores. Proponían 20 por minuto cuando yo había dicho 10, o 5 reportes en 300 segundos en vez de 10 en 60. Ahora un valor que no di es una pregunta antes de aprobar el plan, no una cifra que el plan rellena. qa no arregló esto; lo arregla una regla.
  • Falsos positivos del guard. Contados al cierre desde los transcripts fueron 15 confirmaciones innecesarias en 7 corridas. Los cuatro que analicé durante las corridas venían de comandos del propio workflow. La lección: lo que el guard considera inofensivo tiene que salir del workflow, no de la intuición.

La primera vez fuera del experimento

La primera tarea completa con el flujo adoptado fue en este mismo blog: una página posterior a la última (?page=99, o un número que desborda) respondía 200 con una página vacía o con la primera, en vez de 404. qa armó una matriz de 19 casos y corrigió 5 criterios del borrador antes de que yo viera el plan. Hasta la pregunta del commit fueron 12,3 minutos activos y 44,1 K tokens de salida, con dos subagentes, y el diff fue de 8 líneas de producción y 160 de test.

Pero al medirla encontré algo que ninguna métrica mostraba: ninguno de mis cuatro comandos con ! se ejecutó. El hash del .env antes y después, el script que congela los tests y un git add llegaron a la sesión como mensajes de texto, no como comandos. Los tests nunca quedaron congelados, así que el hook de Stop no tenía nada que verificar. Los chequeos del .env no corrieron y el commit salió sin el test, que se agregó después con un amend. El agente tomó cada mensaje como si el comando hubiera corrido y siguió. Y yo aprobé el commit sin ver la salida que tenía que ver.

El código estaba bien y el .env no había cambiado: lo verifiqué después. Pero la corrida saltó dos puertas humanas sin que nada lo detectara. Todavía no sé por qué esos comandos llegaron como texto; la hipótesis es que los escribí mientras el agente trabajaba y quedaron en la cola, pero no la he comprobado. La lección no depende de la causa: una puerta que el agente no puede observar no es una puerta. El arreglo es que, después de cada !, el agente verifique el efecto (que el lock exista, que el hash dé OK) antes de seguir.

Lo que este experimento no prueba

  1. Dos corridas por tarea y por flujo. La varianza entre corridas (en t3 salieron diseños distintos) es del mismo tamaño que algunas diferencias.
  2. Una sola persona diseñó las tareas, el guion y los tests ocultos, corrió las sesiones y calificó.
  3. Son tareas de un solo repo. No se generaliza a otro sin correrlo ahí.
  4. Algunos fallos de los tests ocultos son de forma, no de comportamiento, y las tablas los separan.
  5. El caso que nadie fuera del flujo viejo resolvió no estaba nombrado en el texto del guion.
  6. Tokens, no dinero. No calculé el costo en dólares.

Lo que me llevo

El experimento no me dijo cuántos agentes usar. Me dijo cuál de los seis hacía un trabajo que no se veía: qa leyendo el código del framework antes del plan. Los demás se volvieron skills sin que la calidad lo notara, y las garantías que daba separarlos pasaron a hooks, que no dependen de que el modelo se acuerde de nada.

Y algo que aplica más allá de los agentes: escribir el criterio antes de correr me obligó a decir que el flujo que adopté perdió. Lo adopté igual, pero ahora sé exactamente qué cambié por qué.


Fuentes: Building agents: When to fold subagents into your main agent loop (Anthropic, octubre de 2026), single-agent-loop-kit, Multi-agent coordination patterns (Anthropic, abril de 2026) y Multi-Agents: What's Actually Working (Cognition, abril de 2026). Herramientas: Claude Code con skills, subagentes y hooks PreToolUse, PostToolUse y Stop.