dmux-workflows
affaan-m/ECC
Coordina sesiones paralelas de agentes de IA mediante dmux, un gestor de paneles de tmux para entornos de agentes como Claude Code y Codex.
...Expandir todoFlujos de trabajo de dmux
Coordina sesiones paralelas de agentes de IA utilizando dmux, un gestor de paneles de tmux para entornos de pruebas de agentes.
Cuándo activarlo
- Cuando se ejecutan varias sesiones de agentes en paralelo
- Coordinar el trabajo entre Claude Code, Codex y otros entornos de pruebas
- Tareas complejas que se benefician del paralelismo de «divide y vencerás»
- El usuario dice «ejecutar en paralelo», «dividir este trabajo», «usar dmux» o «multiagente»
¿Qué es dmux?
dmux es una herramienta de orquestación basada en tmux que gestiona paneles de agentes de IA:
- Pulsa
«n»para crear un nuevo panel con un indicador - Pulsa
mpara fusionar la salida del panel con la sesión principal - Compatible con: Claude Code, Codex, OpenCode, Cline, Gemini y Qwen
Instalación: Instala dmux desde su repositorio tras revisar el paquete. Consulta github.com/standardagents/dmux
Inicio rápido
# Iniciar una sesión de dmux
dmux
# Crear paneles de agente (pulsa «n» en dmux y, a continuación, escribe el indicador de comandos)
# Panel 1: «Implementar el middleware de autenticación en src/auth/»
# Panel 2: «Escribir pruebas para el servicio de usuario»
# Panel 3: «Actualizar la documentación de la API»
# Cada panel ejecuta su propia sesión de agente
# Pulsa «m» para fusionar los resultados de nuevo
Patrones de flujo de trabajo
Patrón 1: Investigación + Implementación
Dividir la investigación y la implementación en vías paralelas:
Panel 1 (Investigación): «Investiga las mejores prácticas para la limitación de tasa en Node.js.
Revisa las bibliotecas actuales, compara enfoques y escribe los resultados en
/tmp/rate-limit-research.md»
Panel 2 (Implementación): «Implementa un middleware de limitación de tasa para nuestra API de Express.
Empieza con un token bucket básico; lo perfeccionaremos una vez finalizada la investigación».
# Una vez completado el Panel 1, fusiona los resultados en el contexto del Panel 2
Patrón 2: Funcionalidad de múltiples archivos
Paralelizar el trabajo en archivos independientes:
Panel 1: «Crea el esquema de la base de datos y las migraciones para la función de facturación»
Panel 2: «Crea los puntos finales de la API de facturación en src/api/billing/»
Panel 3: «Crea los componentes de la interfaz de usuario del panel de control de facturación»
# Fusiona todo y, a continuación, realiza la integración en el panel principal
Patrón 3: Bucle de prueba + corrección
Ejecutar pruebas en un panel, corregir en otro:
Panel 1 (Vigilante): «Ejecuta el conjunto de pruebas en modo de vigilancia. Cuando las pruebas fallen,
resume los fallos».
Panel 2 (Corregidor): «Corrige las pruebas fallidas basándote en los mensajes de error del panel 1»
Patrón 4: Harness cruzado
Utilizar diferentes herramientas de IA para diferentes tareas:
Panel 1 (Claude Code): «Revisa la seguridad del módulo de autenticación»
Panel 2 (Codex): «Reestructura las funciones de utilidad para mejorar el rendimiento»
Panel 3 (Claude Code): «Escribe pruebas de extremo a extremo para el flujo de pago»
Patrón 5: Pipeline de revisión de código
Perspectivas de revisión paralelas:
Panel 1: «Revisar src/api/ en busca de vulnerabilidades de seguridad»
Panel 2: «Revisar src/api/ en busca de problemas de rendimiento»
Panel 3: «Revisar src/api/ en busca de lagunas en la cobertura de pruebas»
# Fusionar todas las revisiones en un único informe
Buenas prácticas
- Solo tareas independientes. No paralelices tareas que dependan de los resultados de otras.
- Límites claros. Cada panel debe trabajar con archivos o aspectos distintos.
- Combina de forma estratégica. Revisa los resultados de cada panel antes de fusionarlos para evitar conflictos.
- Utiliza árboles de trabajo de Git. Para trabajos propensos a conflictos de archivos, utiliza árboles de trabajo separados por panel.
- Ten en cuenta los recursos. Cada panel utiliza tokens de API; mantén el número total de paneles por debajo de 5-6.
Integración de Git Worktree
Para tareas que afectan a archivos que se solapan:
# Crea árboles de trabajo para aislarlos
git worktree add -b feat/auth ../feature-auth HEAD
git worktree add -b feat/billing ../feature-billing HEAD
# Ejecuta los agentes en árboles de trabajo independientes
# Panel 1: cd ../feature-auth && claude
# Panel 2: cd ../feature-billing && claude
# Fusiona las ramas cuando hayas terminado
git merge feat/auth
git merge feat/billing
Herramientas complementarias
| Herramienta | Para qué sirve | Cuándo utilizarla |
|---|---|---|
| dmux | Gestión de paneles de tmux para agentes | Sesiones paralelas de agentes |
| Superset | IDE de terminal para más de 10 agentes en paralelo | Orquestación a gran escala |
| Herramienta Claude Code Task | Generación de subagentes dentro del proceso | Paralelismo programático dentro de una sesión |
| Codex multiagente | Roles de agente integrados | Trabajo paralelo específico de Codex |
Asistente de ECC
ECC incluye ahora una herramienta auxiliar para la orquestación de paneles tmux externos con árboles de trabajo de Git independientes:
script de Node «scripts/orchestrate-worktrees.js plan.json --execute»
Ejemplo de plan.json:
{
"sessionName": "skill-audit",
"baseRef": "HEAD",
"launcherCommand": "codex exec --cwd {worktree_path} --task-file {task_file}",
"workers": [
{ "name": "docs-a", "task": "Corregir las habilidades 1-4 y redactar notas de traspaso." },
{ "name": "docs-b", "task": "Corregir las habilidades 5-8 y redactar notas de traspaso." }
]
}
El ayudante:
- Crea un árbol de trabajo de Git respaldado por una rama por cada trabajador
- Opcionalmente, superpone
las rutas seedPathsseleccionadas del checkout principal en cada árbol de trabajo de cada trabajador - Escribe los archivos
task.md,handoff.mdystatus.mdespecíficos de cada trabajador en la carpeta.orchestration// - Inicia una sesión de tmux con un panel por cada trabajador
- Ejecuta cada comando de trabajador en su propio panel
- Deja el panel principal libre para el orquestador
Utiliza seedPaths cuando los trabajadores necesiten acceder a archivos locales modificados o no controlados que aún no formen parte de HEAD, como scripts de orquestación locales, borradores de planes o documentación:
{
"sessionName": "workflow-e2e",
"seedPaths": [
"scripts/orchestrate-worktrees.js",
"scripts/lib/tmux-worktree-orchestrator.js",
".claude/plan/workflow-e2e-test.json"
],
"launcherCommand": "bash {repo_root}/scripts/orchestrate-codex-worker.sh {task_file} {handoff_file} {status_file}",
"workers": [
{ "name": "seed-check", "task": "Comprobar que los archivos de inicialización estén presentes antes de comenzar el trabajo." }
]
}
Solución de problemas
- El panel no responde: Cambia directamente a ese panel o inspecciónalo con `
tmux capture-pane -pt.:0`. - Conflictos de fusión: utiliza git worktrees para aislar los cambios en los archivos por panel.
- Alto consumo de tokens: Reduce el número de paneles en paralelo. Cada panel es una sesión completa del agente.
- No se encuentra tmux: Instálalo con
`brew install tmux` (macOS) o`apt install tmux` (Linux).
---
name: dmux-workflows
description: Orchestrate parallel AI agent sessions using dmux, a tmux pane manager for agent harnesses like Claude Code and Codex.
---
# dmux Workflows
Orchestrate parallel AI agent sessions using dmux, a tmux pane manager for agent harnesses.
## When to Activate
- Running multiple agent sessions in parallel
- Coordinating work across Claude Code, Codex, and other harnesses
- Complex tasks that benefit from divide-and-conquer parallelism
- User says "run in parallel", "split this work", "use dmux", or "multi-agent"
## What is dmux
dmux is a tmux-based orchestration tool that manages AI agent panes:
- Press `n` to create a new pane with a prompt
- Press `m` to merge pane output back to the main session
- Supports: Claude Code, Codex, OpenCode, Cline, Gemini, Qwen
**Install:** Install dmux from its repository after reviewing the package. See [github.com/standardagents/dmux](https://github.com/standardagents/dmux)
## Quick Start
```bash
# Start dmux session
dmux
# Create agent panes (press 'n' in dmux, then type prompt)
# Pane 1: "Implement the auth middleware in src/auth/"
# Pane 2: "Write tests for the user service"
# Pane 3: "Update API documentation"
# Each pane runs its own agent session
# Press 'm' to merge results back
```
## Workflow Patterns
### Pattern 1: Research + Implement
Split research and implementation into parallel tracks:
```
Pane 1 (Research): "Research best practices for rate limiting in Node.js.
Check current libraries, compare approaches, and write findings to
/tmp/rate-limit-research.md"
Pane 2 (Implement): "Implement rate limiting middleware for our Express API.
Start with a basic token bucket, we'll refine after research completes."
# After Pane 1 completes, merge findings into Pane 2's context
```
### Pattern 2: Multi-File Feature
Parallelize work across independent files:
```
Pane 1: "Create the database schema and migrations for the billing feature"
Pane 2: "Build the billing API endpoints in src/api/billing/"
Pane 3: "Create the billing dashboard UI components"
# Merge all, then do integration in main pane
```
### Pattern 3: Test + Fix Loop
Run tests in one pane, fix in another:
```
Pane 1 (Watcher): "Run the test suite in watch mode. When tests fail,
summarize the failures."
Pane 2 (Fixer): "Fix failing tests based on the error output from pane 1"
```
### Pattern 4: Cross-Harness
Use different AI tools for different tasks:
```
Pane 1 (Claude Code): "Review the security of the auth module"
Pane 2 (Codex): "Refactor the utility functions for performance"
Pane 3 (Claude Code): "Write E2E tests for the checkout flow"
```
### Pattern 5: Code Review Pipeline
Parallel review perspectives:
```
Pane 1: "Review src/api/ for security vulnerabilities"
Pane 2: "Review src/api/ for performance issues"
Pane 3: "Review src/api/ for test coverage gaps"
# Merge all reviews into a single report
```
## Best Practices
1. **Independent tasks only.** Don't parallelize tasks that depend on each other's output.
2. **Clear boundaries.** Each pane should work on distinct files or concerns.
3. **Merge strategically.** Review pane output before merging to avoid conflicts.
4. **Use git worktrees.** For file-conflict-prone work, use separate worktrees per pane.
5. **Resource awareness.** Each pane uses API tokens — keep total panes under 5-6.
## Git Worktree Integration
For tasks that touch overlapping files:
```bash
# Create worktrees for isolation
git worktree add -b feat/auth ../feature-auth HEAD
git worktree add -b feat/billing ../feature-billing HEAD
# Run agents in separate worktrees
# Pane 1: cd ../feature-auth && claude
# Pane 2: cd ../feature-billing && claude
# Merge branches when done
git merge feat/auth
git merge feat/billing
```
## Complementary Tools
| Tool | What It Does | When to Use |
|------|-------------|-------------|
| **dmux** | tmux pane management for agents | Parallel agent sessions |
| **Superset** | Terminal IDE for 10+ parallel agents | Large-scale orchestration |
| **Claude Code Task tool** | In-process subagent spawning | Programmatic parallelism within a session |
| **Codex multi-agent** | Built-in agent roles | Codex-specific parallel work |
## ECC Helper
ECC now includes a helper for external tmux-pane orchestration with separate git worktrees:
```bash
node scripts/orchestrate-worktrees.js plan.json --execute
```
Example `plan.json`:
```json
{
"sessionName": "skill-audit",
"baseRef": "HEAD",
"launcherCommand": "codex exec --cwd {worktree_path} --task-file {task_file}",
"workers": [
{ "name": "docs-a", "task": "Fix skills 1-4 and write handoff notes." },
{ "name": "docs-b", "task": "Fix skills 5-8 and write handoff notes." }
]
}
```
The helper:
- Creates one branch-backed git worktree per worker
- Optionally overlays selected `seedPaths` from the main checkout into each worker worktree
- Writes per-worker `task.md`, `handoff.md`, and `status.md` files under `.orchestration/<session>/`
- Starts a tmux session with one pane per worker
- Launches each worker command in its own pane
- Leaves the main pane free for the orchestrator
Use `seedPaths` when workers need access to dirty or untracked local files that are not yet part of `HEAD`, such as local orchestration scripts, draft plans, or docs:
```json
{
"sessionName": "workflow-e2e",
"seedPaths": [
"scripts/orchestrate-worktrees.js",
"scripts/lib/tmux-worktree-orchestrator.js",
".claude/plan/workflow-e2e-test.json"
],
"launcherCommand": "bash {repo_root}/scripts/orchestrate-codex-worker.sh {task_file} {handoff_file} {status_file}",
"workers": [
{ "name": "seed-check", "task": "Verify seeded files are present before starting work." }
]
}
```
## Troubleshooting
- **Pane not responding:** Switch to the pane directly or inspect it with `tmux capture-pane -pt <session>:0.<pane-index>`.
- **Merge conflicts:** Use git worktrees to isolate file changes per pane.
- **High token usage:** Reduce number of parallel panes. Each pane is a full agent session.
- **tmux not found:** Install with `brew install tmux` (macOS) or `apt install tmux` (Linux).
Todos los archivos
1 archivosInstalar dmux-workflows
Descarga y descomprime los archivos de habilidades en tu directorio .claude/skills/.
Descargar ZIPClona el repositorio y copia los archivos de la habilidad a tu proyecto.
git clone https://github.com/affaan-m/ECC/tree/main/skills/dmux-workflows # Copy SKILL.md to your .claude/skills/ directory
Copiar





Hogar
