Maison

Skill

DevOps et CI/CD

dmux-workflows

affaan-m/ECC

Orchestrez des sessions parallèles d'agents IA à l'aide de dmux, un gestionnaire de volets tmux destiné aux environnements d'agents tels que Claude Code et Codex.

...Développer tout

Heure mise à jour 2 octobre 2026

# tmux # orchestration # parallel agents # multi agent # git worktree # dmux

Workflows dmux

Orchestrez des sessions parallèles d'agents IA à l'aide de dmux, un gestionnaire de volets tmux destiné aux harnais d'agents.

Quand l'activer

Exécution de plusieurs sessions d'agents en parallèle
Coordonner le travail entre Claude Code, Codex et d’autres harnais
Tâches complexes bénéficiant du parallélisme de type « diviser pour régner »
L'utilisateur dit « exécuter en parallèle », « répartir ce travail », « utiliser dmux » ou « multi-agent »

Qu'est-ce que dmux ?

dmux est un outil d’orchestration basé sur tmux qui gère les volets des agents IA :

Appuyez sur n pour créer un nouveau volet avec une invite
Appuyez sur « m » pour fusionner la sortie du volet avec la session principale
Prend en charge : Claude Code, Codex, OpenCode, Cline, Gemini, Qwen

Installation : installez dmux à partir de son dépôt après avoir pris connaissance de la description du paquet. Voir github.com/standardagents/dmux

Démarrage rapide

# Démarrer une session dmux
dmux

# Créer des volets d'agent (appuyez sur « n » dans dmux, puis saisissez l'invite)
# Volet 1 : « Implémenter le middleware d'authentification dans src/auth/ »
# Volet 2 : « Écrire des tests pour le service utilisateur »
# Volet 3 : « Mettre à jour la documentation de l'API »

# Chaque volet exécute sa propre session d'agent
# Appuyez sur « m » pour fusionner les résultats

Modèles de workflow

Modèle 1 : Recherche + Mise en œuvre

Séparer la recherche et la mise en œuvre en deux volets parallèles :

Volet 1 (Recherche) : « Rechercher les meilleures pratiques en matière de limitation de débit dans Node.js.
  Passer en revue les bibliothèques existantes, comparer les approches et consigner les conclusions dans
  /tmp/rate-limit-research.md »

Panneau 2 (Mise en œuvre) : « Mettre en œuvre un middleware de limitation de débit pour notre API Express.
  Commencer par un token bucket basique, que nous affinerons une fois la recherche terminée. »

# Une fois le panneau 1 terminé, fusionner les conclusions dans le contexte du panneau 2

Modèle 2 : fonctionnalité multi-fichiers

Paralléliser le travail entre des fichiers indépendants :

Volet 1 : « Créer le schéma de base de données et les migrations pour la fonctionnalité de facturation »
Volet 2 : « Créer les points de terminaison de l’API de facturation dans src/api/billing/ »
Volet 3 : « Créer les composants de l’interface utilisateur du tableau de bord de facturation »

# Fusionner le tout, puis effectuer l’intégration dans le volet principal

Modèle 3 : Boucle « Test + Correction »

Exécuter les tests dans un volet, corriger les erreurs dans un autre :

Volet 1 (Surveillance) : « Exécutez la suite de tests en mode surveillance. Lorsque les tests échouent,
  résumez les échecs. »

Volet 2 (Correction) : « Corrigez les tests ayant échoué en vous basant sur les messages d'erreur du volet 1 »

Modèle 4 : Harness croisé

Utiliser différents outils d’IA pour différentes tâches :

Volet 1 (Claude Code) : « Vérifier la sécurité du module d’authentification »
Volet 2 (Codex) : « Refactoriser les fonctions utilitaires pour améliorer les performances »
Volet 3 (Claude Code) : « Écrire des tests de bout en bout pour le processus de paiement »

Modèle 5 : Pipeline de révision du code

Perspectives de révision parallèles :

Panneau 1 : « Vérifier src/api/ à la recherche de failles de sécurité »
Panneau 2 : « Vérifier src/api/ à la recherche de problèmes de performances »
Panneau 3 : « Vérifier src/api/ à la recherche de lacunes dans la couverture des tests »

# Fusionner toutes les revues en un seul rapport

Meilleures pratiques

Tâches indépendantes uniquement. Ne mettez pas en parallèle des tâches qui dépendent des résultats les unes des autres.
Définissezdes limites claires. Chaque volet doit porter sur des fichiers ou des aspects distincts.
Fusionnez de manière stratégique. Vérifiez les résultats de chaque volet avant la fusion pour éviter les conflits.
Utilisez des arborescences de travail Git. Pour les travaux susceptibles de générer des conflits de fichiers, utilisez des arborescences de travail distinctes par volet.
Gestion des ressources. Chaque volet utilise des jetons API — limitez le nombre total de volets à 5 ou 6.

Intégration des arborescences de travail Git

Pour les tâches impliquant des fichiers qui se chevauchent :

# Créez des arborescences de travail pour l’isolation
git worktree add -b feat/auth ../feature-auth HEAD
git worktree add -b feat/billing ../feature-billing HEAD

# Exécutez les agents dans des arborescences de travail distinctes
# Volet 1 : cd ../feature-auth && claude
# Volet 2 : cd ../feature-billing && claude

# Fusionnez les branches une fois l’opération terminée
git merge feat/auth
git merge feat/billing

Outils complémentaires

Outil	Fonction	Quand l'utiliser
dmux	Gestion des volets tmux pour les agents	Sessions d'agents parallèles
Superset	IDE de terminal pour plus de 10 agents parallèles	Orchestration à grande échelle
Outil Claude Code Task	Création de sous-agents en cours de traitement	Parallélisme programmatique au sein d’une session
Codex multi-agents	Rôles d'agents intégrés	Tâches parallèles spécifiques à Codex

Aide ECC

ECC inclut désormais un assistant pour l'orchestration externe des volets tmux avec des arborescences Git distinctes :

node scripts/orchestrate-worktrees.js plan.json --execute

Exemple de fichier plan.json:

{
  "sessionName": "skill-audit",
  "baseRef": "HEAD",
  "launcherCommand": "codex exec --cwd {worktree_path} --task-file {task_file}",
  "workers": [
    { "name": "docs-a", "task": "Corriger les compétences 1 à 4 et rédiger des notes de transfert." },
    { "name": "docs-b", "task": "Corriger les compétences 5 à 8 et rédiger des notes de transfert." }
  ]
}

L'assistant :

Crée un arborescence de travail Git adossée à une branche par travailleur
Superpose éventuellement les seedPaths sélectionnés du checkout principal dans chaque arborescence de travail de chaque travailleur
Écrit les fichiers task.md, handoff.md et status.md propres à chaque travailleur dans le répertoire .orchestration//
Lance une session tmux avec un volet par travailleur
Lance la commande de chaque travailleur dans son propre volet
Laisse le volet principal libre pour l’orchestrateur

Utilisez les seedPaths lorsque les workers ont besoin d’accéder à des fichiers locaux modifiés ou non suivis qui ne font pas encore partie de HEAD, tels que des scripts d’orchestration locaux, des ébauches de plans ou des documents :

{
  "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" : "Vérifier que les fichiers de départ sont bien présents avant de commencer le travail." }
  ]
}

Dépannage

Le volet ne répond pas : basculez directement vers le volet ou inspectez-le avec la commande tmux capture-pane -pt :0..
Conflits de fusion : utilisez les arborescences de travail Git pour isoler les modifications de fichiers par volet.
Utilisation élevée de jetons : réduisez le nombre de volets parallèles. Chaque volet correspond à une session d'agent complète.
tmux introuvable : installez-le avec `brew install tmux ` (macOS) ou ` apt install tmux ` (Linux).

Voir sur 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).