opción
HogarHogar Skill DevOps y CI/CD dmux-workflows

dmux-workflows

affaan-m/ECC 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 todo
0
Tiempo actualizado 2 de octubre de 2026

Flujos 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 m para 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

  1. Solo tareas independientes. No paralelices tareas que dependan de los resultados de otras.
  2. Límites claros. Cada panel debe trabajar con archivos o aspectos distintos.
  3. Combina de forma estratégica. Revisa los resultados de cada panel antes de fusionarlos para evitar conflictos.
  4. Utiliza árboles de trabajo de Git. Para trabajos propensos a conflictos de archivos, utiliza árboles de trabajo separados por panel.
  5. 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 seedPaths seleccionadas del checkout principal en cada árbol de trabajo de cada trabajador
  • Escribe los archivos task.md, handoff.md y status.md especí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).
Ver en GitHub
---
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 archivos

Instalar dmux-workflows

Descarga y descomprime los archivos de habilidades en tu directorio .claude/skills/.

Descargar ZIP

Clona 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 Copiar
Configuración rápida: Copia la carpeta de la habilidad en .claude/skills/ Claude detectará y utilizará automáticamente la habilidad
Repositorio affaan-m/ECC

Habilidades relacionadas

klingai-upgrade-migration
Tiempo actualizado 3 de julio de 2026
Verification &amp; Quality Assurance
Tiempo actualizado 29 de junio de 2026
base44-cli
Tiempo actualizado 29 de junio de 2026
Railway CLI Management
Tiempo actualizado 2 de julio de 2026
OR