dmux-workflows
affaan-m/ECC
Koordinieren Sie parallele KI-Agenten-Sitzungen mit dmux, einem tmux-Fenstermanager für Agenten-Harnesses wie Claude Code und Codex.
...Alle erweiterndmux-Workflows
Koordinieren Sie parallele KI-Agenten-Sitzungen mit dmux, einem tmux-Fenstermanager für Agenten-Harnesses.
Wann aktivieren?
- Wenn mehrere Agent-Sitzungen parallel ausgeführt werden
- Koordination der Arbeit zwischen Claude Code, Codex und anderen Harnesses
- Komplexe Aufgaben, die von einer Parallelisierung nach dem „Teile und herrsche“-Prinzip profitieren
- Der Benutzer sagt „parallel ausführen“, „diese Arbeit aufteilen“, „dmux verwenden“ oder „Multi-Agent“
Was ist dmux?
dmux ist ein auf tmux basierendes Orchestrierungstool, das KI-Agenten-Fenster verwaltet:
- Drücke
n, um einen neuen Bereich mit einer Eingabeaufforderung zu erstellen - Drücke
m, um die Ausgabe des Fensters wieder in die Hauptsitzung zu integrieren - Unterstützt: Claude Code, Codex, OpenCode, Cline, Gemini, Qwen
Installation: Installieren Sie dmux aus dem Repository, nachdem Sie das Paket geprüft haben. Siehe github.com/standardagents/dmux
Schnellstart
# dmux-Sitzung starten
dmux
# Agent-Fenster erstellen (in dmux die Taste „n“ drücken, dann die Eingabeaufforderung eingeben)
# Fenster 1: „Implementiere die Authentifizierungs-Middleware in src/auth/“
# Fenster 2: „Schreibe Tests für den Benutzerservice“
# Fenster 3: „Aktualisiere die API-Dokumentation“
# Jedes Fenster führt eine eigene Agent-Sitzung aus
# Drücke „m“, um die Ergebnisse wieder zusammenzuführen
Workflow-Muster
Muster 1: Recherche + Implementierung
Recherche und Implementierung in parallele Arbeitsstränge aufteilen:
Fenster 1 (Recherche): „Recherchiere Best Practices für die Ratenbegrenzung in Node.js.
Überprüfe aktuelle Bibliotheken, vergleiche Ansätze und schreibe die Ergebnisse in
/tmp/rate-limit-research.md“
Fenster 2 (Implementierung): „Implementiere Middleware zur Ratenbegrenzung für unsere Express-API.
Beginne mit einem einfachen Token-Bucket, den wir nach Abschluss der Recherche verfeinern werden.“
# Nachdem Fenster 1 abgeschlossen ist, füge die Ergebnisse in den Kontext von Fenster 2 ein
Muster 2: Funktion mit mehreren Dateien
Parallelisierung der Arbeit über unabhängige Dateien hinweg:
Bereich 1: „Erstelle das Datenbankschema und die Migrationen für die Abrechnungsfunktion“
Bereich 2: „Erstelle die Endpunkte der Abrechnungs-API in src/api/billing/“
Bereich 3: „Erstelle die UI-Komponenten für das Abrechnungs-Dashboard“
# Füge alles zusammen und führe anschließend die Integration im Hauptbereich durch
Muster 3: Test- und Korrekturzyklus
Tests in einem Fenster ausführen, Fehlerbehebung in einem anderen:
Fenster 1 (Watcher): „Führe die Testsuite im Überwachungsmodus aus. Wenn Tests fehlschlagen,
fasse die Fehler zusammen.“
Fenster 2 (Fixer): „Behebe fehlgeschlagene Tests anhand der Fehlerausgabe aus Fenster 1“
Muster 4: Cross-Harness
Verschiedene KI-Tools für unterschiedliche Aufgaben einsetzen:
Fenster 1 (Claude Code): „Überprüfe die Sicherheit des Authentifizierungsmoduls“
Fenster 2 (Codex): „Refaktoriere die Hilfsfunktionen zur Leistungsoptimierung“
Fenster 3 (Claude Code): „Schreibe E2E-Tests für den Checkout-Ablauf“
Muster 5: Code-Review-Pipeline
Parallele Überprüfungsansätze:
Fenster 1: „Überprüfe src/api/ auf Sicherheitslücken“
Fenster 2: „Überprüfe src/api/ auf Leistungsprobleme“
Fenster 3: „Überprüfe src/api/ auf Lücken in der Testabdeckung“
# Füge alle Überprüfungen zu einem einzigen Bericht zusammen
Bewährte Vorgehensweisen
- Nur unabhängige Aufgaben. Parallelisieren Sie keine Aufgaben, die von den Ergebnissen anderer Aufgaben abhängen.
- Klare Abgrenzungen. Jeder Bereich sollte sich mit unterschiedlichen Dateien oder Aspekten befassen.
- Strategisch zusammenführen. Überprüfen Sie die Ergebnisse der Überprüfungsbereiche vor dem Zusammenführen, um Konflikte zu vermeiden.
- Verwenden Sie Git-Worktrees. Verwenden Sie bei Arbeiten, bei denen es leicht zu Dateikonflikten kommen kann, separate Worktrees pro Bereich.
- Ressourcenbewusstsein. Jeder Bereich verwendet API-Token – die Gesamtzahl der Bereiche sollte unter 5–6 bleiben.
Git-Worktree-Integration
Für Aufgaben, die sich auf überlappende Dateien beziehen:
# Erstellen Sie Worktrees zur Isolierung
git worktree add -b feat/auth ../feature-auth HEAD
git worktree add -b feat/billing ../feature-billing HEAD
# Agenten in separaten Worktrees ausführen
# Fenster 1: cd ../feature-auth && claude
# Fenster 2: cd ../feature-billing && claude
# Zweige nach Abschluss zusammenführen
git merge feat/auth
git merge feat/billing
Ergänzende Tools
| Tool | Funktionsweise | Wann zu verwenden |
|---|---|---|
| dmux | tmux-Fensterverwaltung für Agenten | Parallele Agent-Sitzungen |
| Superset | Terminal-IDE für mehr als 10 parallele Agenten | Groß angelegte Orchestrierung |
| Claude Code Task-Tool | Erzeugung von Subagenten innerhalb des Prozesses | Programmatische Parallelität innerhalb einer Sitzung |
| Codex Multi-Agent | Integrierte Agentenrollen | Codex-spezifische parallele Verarbeitung |
ECC-Helfer
ECC enthält nun einen Helfer für die externe tmux-Pane-Orchestrierung mit separaten Git-Worktrees:
node scripts/orchestrate-worktrees.js plan.json --execute
Beispiel für plan.json:
{
"sessionName": "skill-audit",
"baseRef": "HEAD",
"launcherCommand": "codex exec --cwd {worktree_path} --task-file {task_file}",
"workers": [
{ "name": "docs-a", "task": "Skills 1–4 korrigieren und Übergabehinweise verfassen." },
{ "name": "docs-b", "task": "Skills 5–8 korrigieren und Übergabehinweise verfassen." }
]
}
Der Helfer:
- Erstellt pro Worker einen durch einen Branch gestützten Git-Worktree
- Überlagert optional ausgewählte
seedPathsaus dem Haupt-Checkout in den Worktree jedes Workers - Schreibt die Dateien
„task.md“,„handoff.md“und„status.md“pro Worker unter„.orchestration//“ - Startet eine tmux-Sitzung mit einem Fenster pro Worker
- Startet jeden Worker-Befehl in einem eigenen Fenster
- Hält das Hauptfenster für den Orchestrator frei
Verwenden Sie `seedPaths`, wenn Worker Zugriff auf geänderte oder nicht verfolgte lokale Dateien benötigen, die noch nicht Teil von HEAD sind, wie z. B. lokale Orchestrierungsskripte, Planentwürfe oder Dokumente:
{
"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": "Überprüfen, ob die Seed-Dateien vor Arbeitsbeginn vorhanden sind." }
]
}
Fehlerbehebung
- Fenster reagiert nicht: Wechseln Sie direkt zu dem Fenster oder überprüfen Sie es mit `
tmux capture-pane -pt.:0`. - Zusammenführungskonflikte: Verwenden Sie Git-Worktrees, um Dateiänderungen pro Fenster zu isolieren.
- Hohe Token-Auslastung: Reduzieren Sie die Anzahl der parallelen Fenster. Jedes Fenster entspricht einer vollständigen Agent-Sitzung.
- tmux nicht gefunden: Installieren Sie es mit
`brew install tmux` (macOS) oder`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).
Alle Dateien
1 Dateiendmux-workflows installieren
Laden Sie die Skill-Dateien herunter und entpacken Sie sie in Ihr Verzeichnis „.claude/skills/“.
ZIP herunterladenKlonen Sie das Repository und kopieren Sie die Skill-Dateien in Ihr Projekt.
git clone https://github.com/affaan-m/ECC/tree/main/skills/dmux-workflows # Copy SKILL.md to your .claude/skills/ directory
Kopieren





Heim
