Option
HeimHeim Skill DevOps und CI/CD dmux-workflows

dmux-workflows

affaan-m/ECC affaan-m/ECC

Koordinieren Sie parallele KI-Agenten-Sitzungen mit dmux, einem tmux-Fenstermanager für Agenten-Harnesses wie Claude Code und Codex.

...Alle erweitern
0
Zeit aktualisiert 2. Oktober 2026

dmux-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

  1. Nur unabhängige Aufgaben. Parallelisieren Sie keine Aufgaben, die von den Ergebnissen anderer Aufgaben abhängen.
  2. Klare Abgrenzungen. Jeder Bereich sollte sich mit unterschiedlichen Dateien oder Aspekten befassen.
  3. Strategisch zusammenführen. Überprüfen Sie die Ergebnisse der Überprüfungsbereiche vor dem Zusammenführen, um Konflikte zu vermeiden.
  4. Verwenden Sie Git-Worktrees. Verwenden Sie bei Arbeiten, bei denen es leicht zu Dateikonflikten kommen kann, separate Worktrees pro Bereich.
  5. 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 seedPaths aus 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).
Auf GitHub ansehen
---
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 Dateien

dmux-workflows installieren

Laden Sie die Skill-Dateien herunter und entpacken Sie sie in Ihr Verzeichnis „.claude/skills/“.

ZIP herunterladen

Klonen 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 Kopieren
Schnelle Einrichtung: Kopieren Sie den Skill-Ordner nach .claude/skills/ Claude erkennt den Skill automatisch und nutzt ihn.
Repository affaan-m/ECC

Ähnliche Skills

klingai-upgrade-migration
Zeit aktualisiert 3. Juli 2026
Verification &amp; Quality Assurance
Zeit aktualisiert 29. Juni 2026
base44-cli
Zeit aktualisiert 29. Juni 2026
Railway CLI Management
Zeit aktualisiert 2. Juli 2026
OR