A medida que los agentes asumen tareas más ambiciosas, tienen dificultades para:
- Completar trabajo de manera confiable a escala
- Gestionar su propio contexto
Hemos estado experimentando con cómo manejar estos desafíos en forma de lo que llamamos subagentes dinámicos: en lugar de emitir tareas de subagentes a través de llamadas genéricas a herramientas, el agente escribe un script corto que impulsa la ejecución del subagente. Esto significa que los modelos pueden confiar en patrones de código en los que son buenos (como bucles, bifurcaciones o concurrencia) para escribir lógica de orquestación adaptada a la tarea.
¿Por qué subagentes dinámicos?
Deep Agents ya admite subagentes. Aíslan el contexto, permiten que el agente principal delegue unidades discretas de trabajo y mantienen los resultados intermedios fuera de la ventana de contexto principal. Entonces, ¿por qué necesitamos subagentes dinámicos?
Con los subagentes normales, se llaman uno a la vez, invocándolos directamente el modelo principal. Eso funciona a pequeña escala. Se rompe cuando necesitas generar cientos de subagentes, o cuando la lógica de orquestación es condicional o multifase.
Los subagentes dinámicos resuelven esto con orquestación programática. En lugar de hacer llamadas a herramientas turno por turno, el agente escribe un script corto que orquesta y llama a subagentes, y lo ejecuta en un intérprete ligero.
El ejemplo canónico: un subagente por cada página de un documento de 300 páginas. En lugar de llamar a la herramienta de subagente 300 veces, el agente escribe un bucle:
1const results = await Promise.all(pages.map(page =>2 task({ description: `Summarize page ${page.number}`, subagentType: "summarizer" })3));
Esto desbloquea dos cosas que la orquestación basada en llamadas a herramientas no puede ofrecer de manera confiable:
Cobertura determinista a escala. Sin estructura, los agentes toman decisiones subjetivas sobre el alcance, revisando 75 de 500 ítems y dando por terminado. Un bucle de envío no lo hace. La cobertura se convierte en una garantía estructural, no en un problema de ingeniería de prompts.
Orquestación compleja confiable. Escribir la orquestación como código es más confiable que hacer que el modelo la reproduzca como una secuencia de llamadas a herramientas, especialmente para expansión + síntesis, tuberías multifase o bifurcación condicional.
Esta es la misma idea detrás de los flujos de trabajo en Claude Code y los Modelos de Lenguaje Recursivos (RLMs): un modelo escribe código, y ese código envía más agentes.
Inicio rápido
Los subagentes dinámicos requieren dos cosas: subagentes a los que enviar trabajo, y un intérprete de código: un entorno de ejecución seguro y ligero donde el modelo escribe y ejecuta código de orquestación. Deep Agents incluye un intérprete de código opcional basado en QuickJS. Para usarlo, instala el paquete middleware de QuickJS, luego pasa CodeInterpreterMiddleware a través del argumento middleware en create_deep_agent.
1pip install -U "deepagents[quickjs]"
1from deepagents import create_deep_agent2from langchain_quickjs import CodeInterpreterMiddleware34agent = create_deep_agent(5 model="openai:gpt-5.5",6 middleware=[CodeInterpreterMiddleware()],7)
Deep Agents viene con un subagente de propósito general integrado, por lo que ya existe un perfil de subagente general que se puede usar en flujos de trabajo. Para flujos de trabajo especializados, configura subagentes personalizados con sus propios nombres, descripciones y prompts de sistema: los nombres y las descripciones son cómo el agente sabe qué rol usar.
Para activar subagentes dinámicos, indícale a tu agente la palabra "workflow", así:
1result = await agent.ainvoke({2 "messages": [{"role": "user", "content": "Run a workflow that reviews every file in src/routes/ and summarizes the top risks."}]3})
Uso con un agente de código
La forma más rápida de probar subagentes dinámicos es con dcode, nuestro agente de código de terminal construido con Deep Agent. Viene con el intérprete de código habilitado, así que no hay nada que configurar: los subagentes dinámicos funcionan de inmediato.
Instala
1curl -LsSf https://langch.in/dcode | bash
Ejecuta
1dcode
Para activar subagentes dinámicos, solo pide un “workflow”. En lugar de hacer el trabajo directamente o intentar gestionar expansiones de subagentes con su herramienta de tarea nativa, el agente escribe un script de orquestación que llama al global task() incorporado y lo ejecuta en el intérprete de código. Por ejemplo: “ejecuta un workflow para revisar cada archivo en src/ en busca de inyección SQL.”
A medida que se generan subagentes, dcode los muestra en vivo en el panel de subagentes dinámicos agrupados en fases por envío.
Puedes probar esto más rápido con dcode, pero también puedes usarlo en tu herramienta preferida a través de ACP (como Zed)
Cómo funciona
Al agente se le proporciona una herramienta eval. Escribe JavaScript que se ejecuta de forma segura dentro del intérprete. Cuando se configuran subagentes, el intérprete expone un global task() incorporado que los envía desde el código. Según la tarea en cuestión, el modelo escribe diferentes códigos — un bucle, una bifurcación, un Promise.all — y el intérprete lo ejecuta de manera determinista.
task() toma una descripción, un subagentType y un responseSchema opcional — cuando se proporciona, el resultado ya es un objeto tipado, listo para filtrar o pasar al siguiente paso.
1const result = await task({2 description: "Revisa src/auth/login.ts por problemas de seguridad.",3 subagentType: "reviewer",4 responseSchema: {5 type: "object",6 properties: {7 severity: { type: "string", enum: ["high", "medium", "low"] },8 issues: { type: "array", items: { type: "string" } },9 },10 },11});1213const critical = result.severity === "high" ? result.issues : [];14critical; // el modelo ve la última línea
Para más información, consulta Subagentes programáticos e Intérpretes en la documentación.
Patrones comunes de orquestación
Los flujos de trabajo dinámicos de Anthropic popularizaron un conjunto de patrones de orquestación para el trabajo paralelo de agentes. No son características que se activan. Son formas que surgen naturalmente del trabajo, y el agente se adapta a una diferente a medida que la tarea cambia. La tabla a continuación mapea cada forma al tipo de trabajo que encaja.
A continuación, profundizaremos en cómo funciona cada uno en Deep Agents, con trazas en vivo. También preparamos un video explicando estos seis patrones, que puedes ver aquí.
Clasificar y actuar
Los ítems se clasifican primero, luego cada ítem es manejado por un subagente especializado según su clasificación. Esto permite procesar entradas mixtas donde diferentes ítems necesitan diferentes conocimientos.
Casos de uso: Triaje de tickets de soporte, registros de errores, comentarios de usuarios, o cualquier lote de ítems que necesiten un manejo diferente según su tipo.
Ejemplo: triaje de un backlog de tickets de soporte. El agente lee los tickets y clasifica cada uno como error, solicitud de funcionalidad o pregunta. Los errores van a un investigador de errores, las solicitudes de funcionalidad a un analista de funcionalidades, y las preguntas a un respondedor de soporte. El resultado es un resumen agrupado por categoría.
Ver la traza aquí.
Expansión y síntesis
El agente envía el mismo tipo de trabajo a muchos ítems en paralelo, luego combina los resultados.
Casos de uso: Revisión de código en un directorio, análisis de un lote de documentos, procesamiento de archivos de registro, ejecución de la misma verificación en muchos servicios.
Ejemplo: una revisión de seguridad por archivo en un árbol de fuente. El agente descubre cada archivo TypeScript en src/ y envía un revisor de seguridad por archivo en paralelo. Luego fusiona los resultados en un solo informe priorizado con calificaciones de gravedad y las líneas que deben cambiar.
Ver la traza aquí.
Verificación adversarial
Un patrón de dos pasadas. La primera pasada produce hallazgos. La segunda pasada envía cada hallazgo a verificadores independientes, y solo se conservan los hallazgos que sobreviven al acuerdo. Esto reduce falsos positivos cuando la confianza importa más que la velocidad.
Casos de uso: Auditorías de seguridad donde los falsos positivos son costosos, verificaciones de cumplimiento, cualquier revisión donde necesites alta confianza en los hallazgos.
Ejemplo: una auditoría de seguridad donde los falsos positivos son inaceptables. Un auditor lanza una red amplia en busca de vulnerabilidades potenciales, luego cada hallazgo se entrega a un verificador independiente que lee el código de nuevo y devuelve un veredicto de CONFIRMADO o REFUTADO. Solo los hallazgos confirmados sobreviven al informe final.
Ver la traza aquí.
Generar y filtrar
Múltiples subagentes generan soluciones independientes al mismo problema. El agente compara, puntúa y filtra los resultados en código, conservando solo los mejores.
Casos de uso: Propuestas de arquitectura, estrategias de refactorización, variaciones de contenido, cualquier tarea donde explorar múltiples opciones antes de comprometerse produzca un mejor resultado.
Ejemplo: rediseños competitivos de rate-limiter, clasificados. El agente tiene un arquitecto para producir varios rediseños independientes de rate-limiter.ts, cada uno escrito en su propio archivo para que no se sobrescriban entre sí. Luego los puntúa según corrección bajo ráfagas, soporte multi-instancia y complejidad. El más fuerte gana, con una justificación de por qué.
Ver la traza aquí.
Torneo
Las variaciones se comparan cara a cara por un subagente juez, y los ganadores avanzan a través de rondas eliminatorias.
Casos de uso: Optimización bajo criterios subjetivos, selección de estilo, elección entre implementaciones competidoras.
Ejemplo: un bracket por pares sobre reescrituras de un manejador createOrder desordenado. Varios escritores producen cada uno una reescritura candidata con diferentes prioridades, luego un juez las compara cara a cara, avanzando ganadores ronda por ronda hasta que un campeón se destaca. Vuelve con el razonamiento del juez.
Ver la traza aquí.
Bucle hasta terminar
El agente ejecuta un bucle de descubrimiento, deduplicando contra lo que ya ha encontrado, hasta que no aparezcan nuevos resultados. Útil cuando el alcance del trabajo no se conoce de antemano.
Casos de uso: Búsqueda exhaustiva, detección de código muerto, auditorías de dependencias, cualquier barrido donde quieras completitud en lugar de un número fijo de resultados.
Ejemplo: un barrido de seguridad basado en pasadas. El agente ejecuta una pasada de escaneo, inspecciona lo que encontró en el código, y solo inicia otra pasada si la anterior generó nuevos problemas. Se detiene cuando una pasada no encuentra nada nuevo. Reporta los hallazgos consolidados y cuántas pasadas tomó.
Ver la traza aquí.
Conclusión
Los subagentes dinámicos son cómo le das a los agentes más autonomía y mayor confiabilidad. El código maneja la cobertura y el contexto intermedio, y el modelo sigue haciendo el trabajo pesado de juicio. Los patrones anteriores son un punto de partida. En la práctica, los agentes los componen y mezclan según lo que demande la tarea.
Esta es la idea del Modelo de Lenguaje Recursivo en su forma más simple. Un agente que escribe código, y ese código envía más agentes. Es un agente llamándose a sí mismo recursivamente y no está limitado por una ventana de contexto ni encajonado en un flujo de trabajo fijo. Un agente puede descomponer el problema tanto como sea necesario y reensamblar las piezas en la forma que mejor se ajuste. Los patrones de orquestación destacados anteriormente son vislumbres tempranos de lo que es posible, pero el techo solo seguirá elevándose a medida que los modelos mejoren en escribir código.
Subagentes dinámicos es cómo Deep Agents pone esto en tus manos hoy. Comienza agregando un intérprete de código a tu agente, o recurre a dcode donde los subagentes dinámicos funcionan de inmediato.
Agradecimientos
Coescrito por @colifran_ y @huntlovell. Gracias a @hwchase17, @masondrxy y @chester_curme por su cuidadosa revisión.
