dispatching-parallel-agents

Überblick

Was diese Skill macht

dispatching-parallel-agents zeigt dir, wie du mehrere unabhängige Aufgaben an jeweils separate, spezialisierte Agenten delegierst und sie parallel laufen lässt. Jeder Agent erhält seinen eigenen, eng gefassten Kontext, eigene Anweisungen und ein eigenes Ziel – ohne den Verlauf oder Zustand deiner Hauptsession zu erben.

Die Kernidee ist einfach: Wenn du mit mehreren nicht zusammenhängenden Problemen konfrontiert bist, leitest du nicht alles durch einen überlasteten Agenten. Stattdessen:

• identifizierst du unabhängige Problembereiche
• startest du pro Bereich genau einen Agenten
• gibst du jedem Agent nur den Kontext, den er braucht
• lässt du sie parallel arbeiten, während du koordinierst

Dieses Orchestrierungsmuster hilft dir, mehr Arbeit in weniger Echtzeit zu erledigen – insbesondere beim Untersuchen unabhängiger Testfehler, beim Debuggen getrennter Subsysteme oder beim Ausloten verschiedener Lösungsoptionen.

Für wen diese Skill gedacht ist

Diese Skill passt gut, wenn du:

• Multi-Agent-Systeme oder agentische Workflows entwickelst oder betreibst
• KI-unterstütztes Debugging, Testing oder Analysen auf großen Codebasen durchführst
• Mehrere Fehler oder Incidents parallel triagieren musst
• Wert auf Kontextisolation legst und verhindern willst, dass irrelevante Historie zwischen Aufgaben durchleckt

Besonders hilfreich ist sie für Entwickler:innen, SREs, QA-Engineers und Workflow-Designer, die bereits Agenten für komplexe Arbeiten einsetzen, aber ein systematischeres, reproduzierbares Muster für mehrere unabhängige Tasks gleichzeitig suchen.

Welche Probleme sie löst

Nutze dispatching-parallel-agents, wenn du 2 oder mehr Aufgaben hast, die keinen Zustand teilen und nicht voneinander abhängen. Typische Beispiele:

• Mehrere fehlschlagende Testdateien, die unterschiedliche Subsysteme betreffen
• Diverse voneinander unabhängige Bugs aus verschiedenen User-Reports
• Parallele Codebase-Analysen (z. B. hier Security-Scan, dort Performance-Review)

Anstatt:

• jedes Problem nacheinander zu untersuchen oder
• einen einzelnen Agenten alle Fehler gleichzeitig jonglieren zu lassen,

gehst du so vor:

• Du erstellst separate Agenten für jedes Problem
• Du gibst jedem seinen eigenen, kuratierten Kontext
• Du lässt sie parallel laufen und konsolidierst anschließend die Ergebnisse

Das führt zu besserem Fokus pro Agent, weniger Kontextrauschen und schnelleren End-to-End-Untersuchungen.

Wann diese Skill nicht gut passt

dispatching-parallel-agents ist nicht ideal, wenn:

• Tasks kritischen Zustand teilen, der über alle Schritte hinweg konsistent bleiben muss
• die Arbeit in einer strikten Reihenfolge erfolgen muss (Schritt B hängt von Schritt A ab)
• alle Agenten in Echtzeit denselben, sich entwickelnden Kontext sehen müssen

In diesen Fällen solltest du eher einen einzelnen Agenten mit sorgfältig gepflegtem Kontext oder ein sequenzielles Workflow-Muster statt paralleler Verteilung verwenden.

Verwendung

1. Skill installieren

Um die dispatching-parallel-agents Skill aus dem obra/superpowers Repository hinzuzufügen, verwende:

npx skills add https://github.com/obra/superpowers --skill dispatching-parallel-agents

Dadurch werden die Skill-Definition und begleitende Inhalte aus folgendem Pfad geladen:

• Repository: https://github.com/obra/superpowers
• Skill-Pfad: skills/dispatching-parallel-agents

Nach der Installation findest du die Skill-Dateien in deinem Skills-Verzeichnis (der genaue Ort hängt von deinem Skills-Runner bzw. deinen Tools ab).

2. Das Kernmuster verstehen

Der Kern von dispatching-parallel-agents ist ein Entscheidungsmodell dafür, wann Agenten parallel dispatcht werden sollten. Die Upstream-Skill beschreibt dies mit einem einfachen Ablauf:

• Mehrere Fehler?
  • Wenn nein, reicht vermutlich ein einzelner Agent.
• Sind sie unabhängig?
  • Wenn nein – verwandt, nutze einen Agenten, damit er das Gesamtbild sieht.
  • Wenn ja, geht es weiter.
• Können sie parallel arbeiten? (kein geteilter Zustand, keine gemeinsamen Ressourcen, die serialisiert werden müssen)
  • Wenn ja, nutze parallel dispatch.
  • Wenn nein – geteilter Zustand, nutze sequenzielle Agenten.

Diese Logik solltest du jedes Mal anwenden, wenn du entscheidest, ob du mehrere Agenten anlegst oder bei einem bleibst.

3. Mit der SKILL-Datei starten

Öffne nach der Installation:

• SKILL.md

Diese Datei enthält die kanonische Beschreibung des dispatching-parallel-agents Musters, inklusive:

• Wann du diese Skill einsetzen solltest
• Den konzeptionellen Überblick
• Empfehlungen, wie du Agenten nach Problembereichen strukturierst

Lies sie einmal komplett durch; sie ist deine zentrale Referenz, wie die Skill gedacht ist.

4. Unabhängige Problembereiche identifizieren

Bevor du Agenten dispatcht, trenne deine Tasks klar voneinander:

1. Liste alle aktuellen Issues oder Ziele auf (z. B. fehlschlagende Tests, Bug-Reports, Analyseaufgaben).
2. Fasse sie zu Domains zusammen, die weder Zustand noch Logik überlappen. Zum Beispiel:
   • Domain A: Frontend-Testfehler in ui/ Komponenten
   • Domain B: Backend-Fehler in api/ Services
   • Domain C: Sporadische Fehler im jobs/ Scheduler
3. Prüfe die Unabhängigkeit:
   • Unterschiedliche Codepfade oder Subsysteme
   • Kein geteilter veränderlicher Zustand oder eng gekoppelte Logik

Nur wenn du sicher bist, dass sie unabhängig sind, solltest du sie parallel ausführen.

5. Einen Agenten pro Domain mit isoliertem Kontext anlegen

Für jede unabhängige Domain:

1. Erstelle einen frischen Agenten (je nach Framework z. B. eine neue Agent-Konfiguration oder eine neue Conversation/Session).
2. Nutze nicht den Kontext deiner Hauptsession erneut. Stelle stattdessen explizit bereit:
   • Relevante Dateien, Logs oder Konfigurationsausschnitte
   • Eine prägnante Problembeschreibung für diese Domain
   • Alle Constraints oder Ziele, die spezifisch für diese Domain sind
3. Halte das Prompt fokussiert. Zum Beispiel:

"You are an agent focused only on debugging front-end tests under ui/. Ignore other systems. Here are the failures and relevant files…"

Die Skill weist ausdrücklich darauf hin, dass Agenten niemals den Kontext oder die Historie deiner Session erben sollten. So bleiben sie bei der Sache und vermeiden Kontamination zwischen unterschiedlichen Analysen.

6. Agenten parallel ausführen und Ergebnisse koordinieren

Sobald die domain-spezifischen Agenten eingerichtet sind:

1. Dispatch sie parallel über deinen Orchestrator oder deine Skripte.
2. Lass jeden Agenten unabhängig arbeiten, bis ein klarer Zwischenstand erreicht ist (z. B. vermutete Root-Cause, ein Patch oder eine Liste offener Fragen).
3. Übernimm in der Rolle des Koordinators (Mensch oder übergeordneter Agent):
   • Sammle die Ausgaben aller Agenten
   • Vergleiche, validiere und mergen ihre Ergebnisse
   • Entscheide, welche Empfehlungen du umsetzt

Die Orchestrierungsebene (nicht Teil dieser Skill) ist dafür zuständig, Agenten wirklich parallel laufen zu lassen – diese Skill konzentriert sich auf das Wann und Wie der Strukturierung paralleler Arbeit, nicht auf eine spezielle Runtime.

7. Anpassen, wenn sich Tasks als verwandt herausstellen

Manchmal stellt sich mitten in der Untersuchung heraus, dass zwei vermeintlich "unabhängige" Probleme doch zusammenhängen:

• Gemeinsame Root-Cause
• Gemeinsamer Konfigurationsfehler
• Versteckte Kopplung zwischen Systemen

In diesem Fall solltest du:

• Sie nicht länger als separate Domains behandeln
• Den Kontext in einem einzelnen Agenten oder einer neuen gemeinsamen Session zusammenführen
• Diesen Agenten über den vereinten Problemraum nachdenken lassen

Das Muster dispatching-parallel-agents ist bewusst flexibel: Es ermutigt zu paralleler Arbeit, wenn sie sicher ist, und zum Zurückführen auf einen gemeinsamen Kontext, wenn Abhängigkeiten sichtbar werden.

8. Das Muster auf deinen Stack übertragen

Auch wenn das Repository den Fokus auf das konzeptionelle Muster legt, kannst du es in vielen Umgebungen umsetzen:

• Agent-Frameworks: Nutze deren Primitiven, um mehrere Agenten mit separatem Memory oder separaten Context Stores zu starten.
• Custom Scripts: Sprich deinen LLM-Provider direkt an – mit unterschiedlichen Prompts und Input-Bundles je Domain.
• CI/CD- oder Automations-Pipelines: Trigger separate Jobs oder Stages, die von domain-spezifischen Agenten parallel gesteuert werden.

Entscheidend ist nicht das Tool, sondern die Disziplin:

• Klare Domain-Grenzen
• Isolierter Kontext pro Agent
• Koordinierte Konsolidierung der Ergebnisse

FAQ

Was ist dispatching-parallel-agents praktisch gesehen?

dispatching-parallel-agents ist eine Skill, die dir beibringt, Multi-Agent-Workflows so zu strukturieren, dass jede unabhängige Aufgabe ihren eigenen Agenten, Kontext und eigene Anweisungen erhält. Statt einen Generalisten-Agenten alles erledigen zu lassen, startest du mehrere fokussierte Agenten und lässt sie parallel laufen, wenn Tasks unabhängig sind und keinen Zustand teilen.

Wann sollte ich dispatching-parallel-agents einsetzen?

Nutze diese Skill, wenn du 2 oder mehr unabhängige Tasks hast, die:

• nicht von den Ergebnissen der jeweils anderen abhängen
• keinen gemeinsamen, veränderlichen Zustand benötigen
• gefahrlos gleichzeitig laufen können

Typische Szenarien sind mehrere voneinander unabhängige Testfehler, separate Bug-Reports oder eigenständige Analysen über verschiedene Subsysteme.

Wann sollte ich dieses Muster vermeiden?

Vermeide dispatching-parallel-agents, wenn:

• die Tasks kritischen Zustand teilen und synchron bleiben müssen
• der Workflow inhärent sequenziell ist (spätere Schritte brauchen vorherige Ergebnisse)
• du eine durchgängige, gemeinsame Historie oder narrative Sicht auf die Gesamtaufgabe brauchst

In solchen Fällen solltest du stattdessen einen einzelnen Agenten oder einen streng geordneten Multi-Step-Workflow nutzen, nicht parallelen Dispatch.

Wie installiere ich dispatching-parallel-agents?

Installiere die Skill aus dem obra/superpowers Repository mit:

npx skills add https://github.com/obra/superpowers --skill dispatching-parallel-agents

Öffne nach der Installation SKILL.md im dispatching-parallel-agents Verzeichnis, um die vollständige konzeptionelle Anleitung zu lesen.

Enthält diese Skill ausführbaren Code oder nur Guidance?

Die Upstream-Skill ist in erster Linie eine konzeptionelle und instruktive Anleitung, definiert in SKILL.md. Sie erklärt das Muster und die Entscheidungslogik für das Dispatchen paralleler Agenten. Du setzt dieses Muster dann mit deinem eigenen Agent-Framework, deinen Skripten oder Orchestrierungs-Tools um.

Wie hilft das bei mehreren fehlschlagenden Tests oder Bugs?

Anstatt eine lange Liste nicht zusammenhängender Fehler an einen einzelnen Agenten zu schicken, empfiehlt dispatching-parallel-agents:

• Fehler nach Subsystem oder Domain zu gruppieren
• Für jede Gruppe einen dedizierten Agenten mit den relevanten Testergebnissen und dem zugehörigen Code anzulegen
• Diese Agenten parallel laufen zu lassen

So reduzierst du Rauschen pro Agent und verkürzt die Diagnosezeit über alle Fehler hinweg.

Kann ich das mit anderen Workflow- oder Orchestrierungs-Skills kombinieren?

Ja. dispatching-parallel-agents passt gut zu anderen Mustern der Agent-Orchestrierung und Workflow-Automatisierung. Du kannst z. B. eine andere Skill nutzen, um sequenzielle Schritte innerhalb einer Domain zu steuern, und dispatching-parallel-agents darüberlagert einsetzen, um Domains auf mehrere parallel laufende Agenten zu verteilen.

Welche Dateien sollte ich nach der Installation zuerst lesen?

Starte mit:

• SKILL.md – der Hauptbeschreibung des dispatching-parallel-agents Musters

Nutze diese Datei als primäre Referenz, um zu entscheiden, wann du Agenten parallel dispatchst und wie du ihren Kontext strukturierst. Übertrage die Ideen anschließend auf deine eigene Codebasis, CI-Pipeline oder dein Agent-Framework.