dispatching-parallel-agents

Descripción general

Qué hace esta skill

dispatching-parallel-agents te muestra cómo delegar varias tareas independientes a agentes especializados separados y ejecutarlas en paralelo. Cada agente recibe su propio contexto acotado, instrucciones y objetivo, sin heredar el historial ni el estado de tu sesión principal.

La idea central es sencilla: cuando te enfrentas a varios problemas no relacionados, no pasas todo por un único agente sobrecargado. En su lugar:

• Identificas dominios de problema independientes
• Levantas un agente por dominio
• Le das a cada agente solo el contexto que necesita
• Los dejas trabajar en paralelo mientras tú coordinas

Este patrón de orquestación te ayuda a completar más trabajo en menos tiempo de reloj, especialmente al investigar fallos de test no relacionados, depurar subsistemas distintos o explorar diferentes opciones de solución.

A quién va dirigida esta skill

Esta skill encaja bien si:

• Construyes u operas sistemas multi‑agente o flujos de trabajo agentic
• Ejecutas depuración, pruebas o análisis asistidos por IA sobre bases de código grandes
• Necesitas priorizar y gestionar múltiples fallos o incidentes en paralelo
• Te importa el aislamiento de contexto y evitar que historiales no relacionados se filtren entre tareas

Es especialmente útil para desarrolladores, SREs, ingenieros de QA y diseñadores de workflows que ya usan agentes para trabajo complejo, pero quieren un patrón más sistemático y repetible para gestionar varias tareas independientes a la vez.

Qué problemas resuelve

Usa dispatching-parallel-agents cuando tengas 2 o más tareas que no comparten estado y no dependen de los resultados de las demás. Por ejemplo:

• Varios archivos de tests fallando que afectan a subsistemas distintos
• Diversos bugs no relacionados reportados por usuarios diferentes
• Análisis en paralelo de la base de código (p. ej., revisión de seguridad por un lado y revisión de rendimiento por otro)

En lugar de:

• Investigar cada problema secuencialmente, o
• Pedir a un único agente que gestione todos los fallos a la vez

lo que haces es:

• Crear agentes distintos para cada problema
• Dar a cada uno su propio contexto curado
• Ejecutarlos en paralelo y luego consolidar sus resultados

El resultado es mejor foco por agente, menos ruido de contexto y investigaciones de extremo a extremo más rápidas.

Cuándo no es adecuada esta skill

dispatching-parallel-agents no es ideal cuando:

• Las tareas comparten estado crítico que debe mantenerse coherente en todos los pasos
• El trabajo debe ocurrir en una secuencia estricta (el paso B depende del paso A)
• El mismo contexto cambiante debe ser visible en tiempo real para todos los agentes

En esos casos, es preferible un único agente con un contexto cuidadosamente mantenido o un patrón de flujo de trabajo secuencial en lugar de una ejecución en paralelo.

Cómo usarla

1. Instalar la skill

Para añadir la skill dispatching-parallel-agents desde el repositorio obra/superpowers, utiliza:

npx skills add https://github.com/obra/superpowers --skill dispatching-parallel-agents

Este comando descarga la definición de la skill y el material de soporte desde:

• Repositorio: https://github.com/obra/superpowers
• Ruta de la skill: skills/dispatching-parallel-agents

Tras la instalación, localiza los archivos de la skill dentro de tu directorio de skills (la ubicación exacta depende de tu ejecutor de skills o tooling).

2. Entender el patrón principal

El corazón de dispatching-parallel-agents es un patrón de decisión sobre cuándo despachar agentes en paralelo. La skill original lo describe con un flujo sencillo:

• ¿Múltiples fallos?
  • Si no, probablemente solo necesitas un agente.
• ¿Son independientes?
  • Si no – relacionados, usa un único agente para que vea el panorama completo.
  • Si sí, continúa.
• ¿Pueden trabajar en paralelo? (sin estado compartido, sin recursos compartidos que deban serializarse)
  • Si sí, usa parallel dispatch.
  • Si no – shared state, usa sequential agents.

Aplicarás esta lógica cada vez que decidas si crear varios agentes o quedarte con uno solo.

3. Empezar por el archivo SKILL

Después de instalar, abre:

• SKILL.md

Este archivo contiene la descripción canónica del patrón dispatching-parallel-agents, incluyendo:

• Cuándo usar esta skill
• La visión conceptual
• Guía sobre cómo estructurar los agentes por dominio de problema

Léelo de principio a fin al menos una vez; es la referencia principal sobre cómo se espera que se use la skill.

4. Identificar dominios de problema independientes

Antes de despachar agentes, separa tus tareas con claridad:

1. Haz una lista de todos los issues o objetivos actuales (p. ej., tests fallando, informes de bugs, tareas de análisis).
2. Agrúpalos en dominios que no se solapen en estado ni en lógica. Por ejemplo:
   • Dominio A: fallos de tests de frontend en componentes ui/
   • Dominio B: errores de backend en servicios api/
   • Dominio C: fallos intermitentes en el scheduler de jobs/
3. Valida que sean independientes:
   • Rutas de código o subsistemas distintos
   • Sin estado mutable compartido ni lógica fuertemente acoplada

Solo cuando estés seguro de que son independientes deberías ejecutarlos en paralelo.

5. Crear un agente por dominio con contexto aislado

Para cada dominio independiente:

1. Construye un agente nuevo (como lo exprese tu framework, por ejemplo, una nueva configuración de agente o una conversación/sesión nueva).
2. No reutilices el contexto de tu sesión principal. En su lugar, proporciona explícitamente:
   • Los archivos, logs o fragmentos de configuración relevantes
   • Una descripción concisa del problema para ese dominio
   • Cualquier restricción u objetivo específico de ese dominio
3. Mantén el prompt enfocado. Por ejemplo:

“You are an agent focused only on debugging front-end tests under ui/. Ignore other systems. Here are the failures and relevant files…”

La guía de la skill insiste en que los agentes nunca deben heredar el contexto o historial de tu sesión. Esto los mantiene centrados en su tarea y evita contaminación cruzada entre investigaciones.

6. Ejecutar agentes en paralelo y coordinar resultados

Una vez que los agentes por dominio estén configurados:

1. Despáchalos en paralelo usando tu orquestador o scripts.
2. Deja que cada agente trabaje de forma independiente hasta alcanzar un resultado parcial claro (p. ej., causa raíz sospechada, un patch o una lista de preguntas de seguimiento).
3. Como coordinador (una persona o un agente supervisor):
   • Recopila los resultados de todos los agentes
   • Compara, valida o combina sus conclusiones
   • Decide qué recomendaciones implementar

La capa de orquestación (no incluida en esta skill) es la encargada de ejecutar realmente los agentes en paralelo; esta skill se centra en cuándo y cómo estructurar ese paralelismo, no en un runtime específico.

7. Ajustar cuando las tareas resultan estar relacionadas

A veces descubres, en plena investigación, que dos problemas "independientes" en realidad están conectados:

• Misma causa raíz
• Bug de configuración común
• Acoplamiento oculto entre sistemas

En ese caso, deberías:

• Dejar de tratarlos como dominios separados
• Consolidar el contexto en un único agente o una nueva sesión compartida
• Permitir que ese agente razone sobre el espacio de problema unificado

El patrón dispatching-parallel-agents es intencionadamente flexible: anima al trabajo en paralelo cuando es seguro, y a volver a un contexto único cuando aparecen dependencias.

8. Adaptar el patrón a tu stack

Aunque el repositorio se centra en el patrón conceptual, puedes implementarlo en muchos entornos:

• Frameworks de agentes: Usa sus primitivas para levantar múltiples agentes con memorias o stores de contexto separados.
• Scripts personalizados: Llama directamente a tu proveedor de LLM con prompts y paquetes de entrada distintos por dominio.
• Pipelines de CI/CD o automatización: Lanza jobs o etapas separadas impulsadas por agentes específicos de cada dominio en paralelo.

La clave no es la herramienta, sino la disciplina:

• Fronteras de dominio explícitas
• Contexto aislado por agente
• Consolidación coordinada de resultados

FAQ

¿Qué es dispatching-parallel-agents en términos prácticos?

dispatching-parallel-agents es una skill que te enseña a estructurar flujos de trabajo multi‑agente de forma que cada tarea independiente tenga su propio agente, contexto e instrucciones. En lugar de que un único agente generalista gestione todo, levantas varios agentes enfocados y los ejecutas en paralelo cuando las tareas no están relacionadas y no comparten estado.

¿Cuándo debería usar dispatching-parallel-agents?

Utiliza esta skill cuando tengas 2 o más tareas independientes que:

• No dependan de la salida de las otras
• No requieran un estado mutable compartido
• Puedan ejecutarse con seguridad al mismo tiempo

Los casos típicos incluyen múltiples fallos de tests no relacionados, informes de bugs separados o análisis independientes en distintos subsistemas.

¿Cuándo debería evitar este patrón?

Evita dispatching-parallel-agents cuando:

• Las tareas comparten estado crítico y deben mantenerse sincronizadas
• El flujo de trabajo es inherentemente secuencial (pasos posteriores requieren resultados anteriores)
• Necesitas una narrativa o historial único y continuo para toda la tarea

En esos escenarios, usa un único agente o un flujo de trabajo multi‑paso estrictamente ordenado en lugar de un dispatch en paralelo.

¿Cómo instalo dispatching-parallel-agents?

Instala la skill desde el repositorio obra/superpowers usando:

npx skills add https://github.com/obra/superpowers --skill dispatching-parallel-agents

Tras la instalación, abre SKILL.md dentro del directorio dispatching-parallel-agents para leer la guía conceptual completa.

¿Esta skill incluye código ejecutable o solo guía?

La skill original es principalmente una guía conceptual e instructiva definida en SKILL.md. Explica el patrón y la lógica de decisión para despachar agentes en paralelo. Se espera que apliques este patrón usando tu propio framework de agentes, scripts o herramientas de orquestación.

¿Cómo ayuda esto con múltiples tests o bugs fallando?

En lugar de enviar una lista larga de fallos no relacionados a un solo agente, dispatching-parallel-agents propone:

• Agrupar los fallos por subsistema o dominio
• Crear un agente dedicado para cada grupo con el output de tests y el código relevantes
• Ejecutar esos agentes en paralelo

Esto reduce el ruido para cada agente y acelera el tiempo de diagnóstico del conjunto completo de fallos.

¿Puedo combinar esto con otras skills de workflow u orquestación?

Sí. dispatching-parallel-agents encaja bien con otros patrones de agent‑orchestration y workflow‑automation. Por ejemplo, puedes usar otra skill para gestionar pasos secuenciales dentro de un dominio y usar dispatching-parallel-agents a un nivel superior para distribuir dominios entre varios agentes ejecutándose en paralelo.

¿Qué archivos debería leer primero después de instalar?

Empieza por:

• SKILL.md – la descripción principal del patrón dispatching-parallel-agents

Úsalo como referencia principal para decidir cuándo despachar agentes en paralelo y cómo estructurar su contexto. Después, aplica las ideas a tu propia base de código, pipeline de CI o framework de agentes.