Agentenarmee
Ein 2-schichtiges paralleles Ausführungsframework. Der Commander ist das Top-Level-Modell – standardmäßig Fable oder Opus, wenn das das Sitzungsmodell ist – und übernimmt das Denken: Aufklärung, Komposition, Briefing, Verifikation. Er orchestriert Schwärme untergeordneter Modelle, deren Stufe der Benutzer beim Deployment wählt (siehe Power Level). Jeder Layer-1-Agent besitzt seinen eigenen, vollständigen Kontextfenster (kein Ausschnitt). Jeder erzeugt Layer-2-Subagenten unter sich. Das Ergebnis sind viele unabhängige Gehirne, die gleichzeitig arbeiten – nicht ein geteiltes Gehirn.
Commander (Sie – Fable oder Opus, das Sitzungsmodell)
|
|-- Layer 1: Team (3 bis 50+, jeder = eigener 1M Kontext, L1-Stufe aus Power Level)
| |-- Agent A (1M) -- Sub-Agent A1, A2, ... (L2-Stufe)
| |-- Agent B (1M) -- Sub-Agent B1, B2, ... (L2-Stufe)
| |-- Agent C (1M) -- Sub-Agent C1, C2, ... (L2-Stufe)
| |-- ... (keine Obergrenze)
Schwarm vs. Armee: Ein Schwarm teilt ein Kontextfenster auf mehrere Sub-Agenten auf – ein Gehirn, geteilt. Eine Armee gibt jedem Layer-1-Mitglied sein eigenes Fenster. Dieser Unterschied ist der Kern dieses Skills.
Wann verwenden
- Große Refaktorisierungen, die viele Dateien umfassen
- Dateiübergreifende Farb-/Stil-/Namens-/API-Migrationen
- Breite Codebase-Audits (Sicherheit, Barrierefreiheit, Leistung, toter Code)
- Massenhafte Inhaltsgenerierung oder -transformation
- Jede Aufgabe mit 6+ unabhängigen Arbeitseinheiten, die gleichzeitig ausgeführt werden können
Wann NICHT verwenden
- Weniger als 6 unabhängige Arbeitseinheiten – führen Sie es direkt aus
- Starke sequenzielle Abhängigkeiten, bei denen jeder Schritt die Ausgabe des vorherigen benötigt
- Einzeldateiänderungen
- Aufgaben, die eine einzige, zusammenhängende Autorenstimme über alle Ausgaben hinweg benötigen (parallele Agenten driften auseinander)
Wenn die Aufgabe nicht klar passt, sagen Sie dies und schlagen Sie vor, sie inline statt einer Armee zu erledigen.
- JEDER Layer-1-Agent MUSS 2+ Sub-Agenten erzeugen. Keine Ausnahmen. Wenn Sie im Begriff sind, einen L1-Agenten ohne Sub-Agenten bereitzustellen, HALTEN Sie an und strukturieren Sie um.
- Verkleinern Sie die Armee NIEMALS stillschweigend. Halten Sie die vom Benutzer gewählte Stufe ein. Wenn Sie abweichen müssen, sagen Sie dies laut und erklären Sie, warum.
2b. Downgraden Sie Modelle NIEMALS stillschweigend. Übergeben Sie
model:explizit bei jedem Agent-Aufruf mit der vom Benutzer gewählten Power Level. Das Weglassen erbt das Sitzungsmodell – das ist eine stille Max-Power-Abrechnung. - Sub-Agenten-Bereitstellungsanweisungen gehen INS L1-Briefing. Fehlen sie, werden die Sub-Agenten nie erstellt.
- Melden Sie, sobald Agenten fertig sind:
[Agent N/M complete] name: X Dateien geändert, Y Flags. - Zeigen Sie den Armeeplan an und durchlaufen Sie das Deployment-Gate vor dem Bereitstellen (Full Mode). Quick Mode erstellt den Plan intern, durchläuft aber trotzdem das Gate.
- Nach jeder Welle: Führen Sie den Build UND die Phantomerledigungs-Prüfung durch (siehe Verify). Ein grüner Bericht eines Agenten ist eine Behauptung, kein Beweis.
- „Weitermachen“/„nicht anhalten“ = kontinuierlicher Modus: Starten Sie einen neuen Agenten, sobald einer fertig ist. Warten Sie nicht, fragen Sie nicht erneut.
Armeegröße
Bestätigen Sie eine Stufe vor dem Start. Zeigen Sie diese Tabelle an:
| Stufe | L1-Agenten | Gesamt mit Sub-Agenten | Geschätzte Token |
|----------------|------------|------------------------|------------------|
| Konservativ | 3 | ~9 | ~200-500K |
| Standard | 5-10 | ~15-30 | ~500K-1.5M |
| Aggressiv | 10-20 | ~30-60 | ~1.5-4M |
| Maximal | 20-50+ | ~60-100+ | ~4M+ |
| Benutzerdefiniert | Sie wählen | Sie wählen | variiert |
Standardmäßig Standard auf „mach es einfach.“ Nach der Aufklärung (Schritt 3) empfehlen Sie eine spezifische Anzahl basierend auf dem, was Sie gefunden haben – z.B. „35 Dateien in 6 Bereichen → Aggressiv: 8 L1-Agenten, 2-3 Sub-Agenten pro Agent (~22 insgesamt, ~2M Token). Anpassen?“ Token-Schätzungen sind grob und skalieren mit der Aufgabenkomplexität.
Power Level
Größe bestimmt, wie viele Agenten; Power bestimmt, welche Modelle. Fragen Sie beides in einer Frage (AskUserQuestion funktioniert gut – Größe und Power als zwei Fragen in einem Aufruf). Überspringen Sie die Frage, wenn der Benutzer bereits eine Power Level oder explizite Modelle genannt hat.
| Power Level | Commander | Layer 1 | Layer 2 | Am besten geeignet für |
|---------------------|------------------------|---------|---------|-------------------------------------------------|
| Max Power | Fable/Opus (Sitzung) | Opus | Opus | Knifflige Refaktorisierungen, korrektheitskritische Migrationen|
| Heavy (empfohlen) | Fable/Opus (Sitzung) | Opus | Sonnet | Die meisten großen Aufgaben – intelligente Orchestrierung, schnelle Ausführung|
| Balanced | Fable/Opus (Sitzung) | Sonnet | Sonnet | Mechanische Migrationen mit klaren Mustern |
| Economy | Fable/Opus (Sitzung) | Sonnet | Haiku | Massenhafte, einfache Suchen/Ersetzen |
Regeln:
- Der Commander ist immer das Sitzungsmodell – Fable oder Opus, die Wahl des Benutzers – und wird nie delegiert. Wenn die Sitzung Sonnet oder Haiku ausführt, sagen Sie dem Benutzer, er soll wechseln (
/modeloderclaude --model fable), bevor er bereitstellt: Die Commander-Qualität ist die Obergrenze für die Armeequalität. - Übergeben Sie das Modell explizit bei jedem Agent-Aufruf:
model: "<L1-Stufe>"für Teammitglieder; L1-Briefings instruierenmodel: "<L2-Stufe>"für Sub-Agenten. - Hochstufung pro Agent ist auf jeder Power Level erlaubt: Eine schwere oder verworrene Datei (1000+ Zeilen, komplexe Logik) kann diesen einen Sub-Agenten um eine Stufe höher stufen. Notieren Sie Hochstufungen im Armeeplan.
- Audit-Wellen laufen auf Opus, unabhängig von der Power Level – frische, stärkere Augen auf die Arbeit der Ausführenden. Benachrichtigungswellen können auf Haiku abfallen.
Protokoll
Modus: Wenn der Umfang bereits konkret ist (Dateipfade, genaue Änderungen, Stufe), fahren Sie mit Schritt 3 fort (Quick Mode). Andernfalls beginnen Sie mit Schritt 1 (Full Mode).
Schritt 1: Erfassung (Full Mode)
Bestätigen Sie in einer Zeile, ob der Benutzer bereits Kontext gegeben hat: „Ziel: [X]. Umfang: [Y]. Stufe: [Z]. Power: [P]. Starte.“ Andernfalls fragen Sie nach: Ziel (ein Satz), Umfang (Dateien/Verzeichnisse/"alles"), Einschränkungen (X nicht anfassen, Y entsprechen), Stufe und Power Level.
Schritt 2: Git-Checkpoint
git status– warnen Sie vor nicht committeten Änderungen, bieten Sie an, zu stashen/committen.git checkout -b agent-army/checkpoint-{timestamp}, dann zurückwechseln. Dies ist der Rollback-Punkt.- Kein Git-Repo? Warnen Sie, dass es kein Sicherheitsnetz gibt, und holen Sie eine explizite Bestätigung ein.
Schritt 3: Aufklärung
- Grep / Glob / Read, um jede betroffene Datei zu finden.
- Zählen Sie die Arbeitseinheiten.
wc -lfür jede Datei. Markieren Sie Dateien mit 500+ Zeilen als schwer → weisen Sie einzeln zu.- Klassifizieren Sie in Bereiche (nach Verzeichnis, Importgraph, Dateityp, Benennungsmuster).
- Identifizieren Sie gemeinsame Abhängigkeiten – Grundlagendateien, die bereichsübergreifend importiert werden. Bearbeiten Sie diese zuerst (Schritt 5).
- Identifizieren Sie den Build-Befehl (package.json, Makefile, etc.).
Ausgabe: Dateien: N | Schwer: [Liste] | Bereiche: [Liste] | Gemeinsame Abhängigkeiten: [Liste] | Build-Befehl: [Befehl]
Schritt 4: Zusammensetzen
- Basis-Agent für gemeinsame Abhängigkeiten – läuft vor der parallelen Welle, damit Abhängige nicht in Konflikt geraten.
- Layer 1: ein Agent pro Bereich; teilen Sie große Bereiche auf mehrere Agenten auf.
- Layer 2: 2+ Sub-Agenten pro L1-Agent, zugewiesen nach gewichteter Dateilast, nicht nach Dateianzahl:
- Klein (<200 Zeilen): 2-3 pro Sub-Agent
- Mittel (200-500): 1-2 pro Sub-Agent
- Schwer (500+): 1 pro Sub-Agent, einzeln
- Benennen Sie jeden Agenten. Weisen Sie jede Datei genau einem Sub-Agenten zu – keine Überlappungen, keine Lücken.
Geben Sie den Armeeplan aus. Full Mode: Pause für „Fortfahren?“ Quick Mode: Einzeiler-Zusammenfassung, dann bereitstellen.
Deployment-Gate
Geben Sie diese Checkliste in Ihrer Antwort vor dem Bereitstellen aus. Prüfen Sie sie nicht mental – schreiben Sie sie aus.
DEPLOYMENT GATE:
[ ] Jedes L1-Briefing enthält "Sie MÜSSEN N Sub-Agenten erzeugen"
[ ] Jeder Sub-Agent ist benannt und hat spezifische Dateien zugewiesen
[ ] Jede Datei gehört genau einem Sub-Agenten (keine Überlappung, keine Lücke)
[ ] L1-Briefings enthalten vollständige Sub-Agenten-Bereitstellungsanweisungen
[ ] Stufe stimmt mit der Auswahl des Benutzers überein
[ ] Power Level gesetzt: `model: "<L1-Stufe>"` bei jedem L1-Aufruf; L2-Stufe + Hochstufungen in jedem Briefing
Alle müssen BESTANDEN sein. Jedes NICHT BESTANDEN → Plan vor dem Bereitstellen reparieren.
Schritt 5: Bereitstellen
- Basis-Agent zuerst (falls vorhanden), auf L1-Stufe. Warten Sie auf Abschluss.
- Starten Sie ALLE Layer-1-Agenten parallel –
run_in_background: trueundmodel: "<L1-Stufe>"bei jedem Aufruf, in einer einzigen Nachricht. - Jeder L1-Agent erzeugt seine L2-Sub-Agenten parallel (gemäß seinem Briefing).
- Melden Sie jeden Abschluss:
[Agent N/M abgeschlossen] Name: Ergebnisse.
Schritt 6: Überprüfen
- Erneutes Scannen – führen Sie erneut die Suchen aus Schritt 3 nach verbleibenden Verstößen durch.
- Phantomerledigungs-Prüfung – führen Sie
git diff --stataus und gleichen Sie es mit den Agentenberichten ab. Jeder Agent, der "ABGESCHLOSSEN, N Dateien geändert" gemeldet hat, ohne passenden Diff, hat gelogen oder nichts gemacht – setzen Sie ihn erneut ein. Vertrauen Sie dem Diff, nicht dem Bericht. - Build – führen Sie den Build-Befehl aus. Notieren Sie BESTANDEN/NICHT BESTANDEN.
- Lösen Sie teamübergreifende Flags aus den Berichten auf.
- Geben Sie den Armeebericht aus:
Agenten: N | Geänderte Dateien: N (diff-bestätigt) | Übersprungen: N | Build: BESTANDEN/NICHT BESTANDEN
Flags: [Liste] | Phantomerledigungen erwischt: N | Rollback: git checkout agent-army/checkpoint-{timestamp}
Wellen
Jede Welle ist eine neue, kleinere, anders spezialisierte Armee. Pausieren Sie vor jeder für die Zustimmung des Benutzers. Maximal 4 Wellen.
| Welle | Name | Auslöser | Zweck |
|---|---|---|---|
| 1 | Ausführen | immer | Änderungen vornehmen |
| 2 | Audit | Build fehlgeschlagen, verbleibende Verstöße, 20+ Dateien oder Flags > 0 | Neue Agenten überprüfen Welle 1 auf Korrektheit/Grenzfälle |
| 3 | Propagieren | Änderungen betreffen APIs/Typen/Schnittstellen; Tests oder Dokumente referenzieren alte Muster | Tests, Dokumentation, Konfigurationen, nachgelagerte Aufrufer aktualisieren |
| 4 | Benachrichtigen | Benutzer stimmt zu | PR-Beschreibung, Changelog, Slack-Zusammenfassung entwerfen |
Der Bericht jeder Welle ist die Aufklärung für die nächste Welle. Führen Sie nach jeder die Überprüfung erneut durch; stoppen Sie, wenn der erneute Scan sauber ist und der Build bestanden wird, oder nach 4 Wellen.
Fortsetzung / Notizblock
Für mehrwellige oder unterbrechbare Läufe schreiben Sie .army-state.md nach Welle 1: geänderte Dateien (diff-bestätigt), offene Flags, ungelöste Probleme, Entscheidungen. Wenn ein Lauf abgebrochen wird, liest der nächste Aufruf diese Datei und setzt ab der letzten sauberen Welle fort, anstatt neu zu starten. Überspringen Sie dies für Einwellenaufgaben.
Layer-1-Befehlsvorlage
Dies ist, was erzeugte Agenten tatsächlich sehen – der wichtigste Abschnitt des Skills.
Sie sind [AGENT_NAME], Spezialist für [BEREICH].
Ziel: [ein Satz]
Zugelassene Muster: [genaue Werte – Hexcodes, Klassennamen, API-Formen]
Verbotene Muster: [was entfernt/vermieden werden soll]
Ihre Dateien: [absolute Pfade mit Zeilenanzahlen]
Regeln: [Einschränkungen]. Überspringen Sie Dateien, die bereits zugelassene Muster verwenden (Idempotenz).
Markieren Sie Probleme außerhalb Ihrer Dateien in "Flags für Commander" – beheben Sie sie NICHT.
KRITISCH: Sie MÜSSEN das Agent-Tool verwenden, um die unten aufgeführten Sub-Agenten zu erzeugen. Tun
Sie die Arbeit NICHT selbst. Überspringen Sie die Erzeugung NICHT. Setzen Sie ALLE Sub-Agenten in einer einzigen
Nachricht mit mehreren Agent-Tool-Aufrufen ein, wobei Sie model: "[L2_STUFE]" bei jedem Aufruf übergeben
[notieren Sie Hochstufungen: außer "NAME", der model: "[höhere Stufe]" erhält].
Sub-Agenten:
- "[NAME]": [Dateien mit Zeilenanzahlen]
- "[NAME]": [Dateien mit Zeilenanzahlen]
Übergeben Sie jedem Sub-Agenten: Ziel, ihre Dateien, zugelassene/verbotene Muster, Regeln,
Berichtsformat. Nachdem alle abgeschlossen sind, fassen Sie ihre Berichte zusammen und verifizieren Sie (durch erneutes Lesen
oder Greppen), dass keine verbotenen Muster mehr in Ihrem Bereich vorhanden sind, bevor Sie Bericht erstatten.
Layer-2-Befehlsvorlage
Sie sind [SUB_AGENT_NAME], arbeiten unter [TEAM_MITGLIED_NAME].
Ziel: [ein Satz]
Dateien, die Sie besitzen: [absolute Pfade mit Zeilenanzahlen – berühren Sie nur diese]
Zugelassene / Verbotene Muster: [genaue zu verwendende und zu entfernende Werte]
Regeln: [Einschränkungen]. Überspringen Sie Dateien, die bereits korrekt sind. Markieren Sie Probleme außerhalb Ihrer Dateien –
beheben Sie sie NICHT.
Prozess: Lesen Sie jede Datei vollständig → prüfen Sie Idempotenz → wenden Sie zugelassene an, entfernen Sie verbotene
→ lesen Sie erneut, um sicherzustellen, dass keine verbotenen Muster mehr vorhanden sind.
Bericht: Geänderte Dateien (Datei: N Ersetzungen), Übersprungene Dateien (bereits korrekt),
Flags für Commander, Probleme, Status (ABGESCHLOSSEN/TEILWEISE/FEHLGESCHLAGEN).
Berichtsformat
Jeder Agent gibt zurück:
## Bericht: [Name]
Geänderte Dateien: [Datei: N Ersetzungen]
Übersprungene Dateien: [Datei: Grund]
Flags für Commander: [Problem oder "Keine"]
Probleme: [Problem oder "Keine"]
Status: ABGESCHLOSSEN / TEILWEISE / FEHLGESCHLAGEN
Anti-Patterns
Dies sind die Fehlermodi, die dieses Skill verhindern soll. Wenn Sie sich dabei ertappen, einen zu begehen, halten Sie an und korrigieren Sie.
- Phantom-Fan-Out – Ein L1-Agent erledigt die Arbeit selbst, anstatt Sub-Agenten zu erzeugen. Der gesamte Geschwindigkeitsvorteil ist weg. Durchgesetzt durch Pflichtregel 1 + das Gate.
- Phantom-Erledigung – Ein Agent meldet ABGESCHLOSSEN, ohne etwas bearbeitet zu haben. Wird durch den
git diff --stat-Abgleich erkannt, nicht durch Vertrauen auf den Bericht. - Stille Verkleinerung – Stiller Betrieb von 3 Agenten, wenn der Benutzer Aggressiv gewählt hat. Weichen Sie immer sichtbar ab.
- Modell-Drift – Weglassen von
model:bei Agent-Aufrufen, so dass jeder Sub-Agent stillschweigend das Commander-Modell erbt. Der Benutzer hat Economy gewählt und bekam Max Power berechnet. Durchgesetzt durch Pflichtregel 2b + das Gate. - Überlappende Zuständigkeit – Zwei Sub-Agenten bearbeiten dieselbe Datei → Konflikte und verlorene Änderungen. Durchgesetzt durch den genau-ein-Besitzer im Gate.
- Überspringen der Basis – Abhängige berühren, bevor gemeinsame Dateien aktualisiert werden → Kaskade kaputter Importe. Basis-Agent läuft zuerst.
- Armee für eine kleine Aufgabe – 9 Agenten für 4 Dateien ist langsamer (Orchestrierungs-Overhead) und verbrennt Token. Siehe „Wann NICHT verwenden".
Fehlerbehandlung
- Sub-Agent schlägt fehl → L1-Agent wiederholt seine Dateien oder erzeugt einen Ersatz.
- L1-Agent schlägt fehl → Commander erzeugt einen Ersatz mit dem gleichen Briefing.
- Build-Fehler → Diff gegen den Checkpoint-Branch, um den Bruch zu isolieren, dann eine Fix-Welle ausführen.
- Phantom-Erledigung → Die Dateien dieses Agenten an einen neuen Agenten weiterleiten.
- Idempotenz bei erneuter Ausführung → Agenten prüfen zuerst auf bereits angewendete Muster, sodass eine zweimalige Ausführung der Armee nie doppelt angewendet wird.
Arbeitsbeispiel
Benutzer
…
[gekürzt für Übersetzung]