SamuelChien/mega-skills-collection

AgentHub — Multi-Agent-Kollaboration

Starte N parallele KI-Agenten, die an derselben Aufgabe konkurrieren. Jeder Agent arbeitet in einem isolierten Git-Worktree. Der Koordinator bewertet die Ergebnisse und merged den Gewinner.

Schrägstrich-Befehle

Befehl	Beschreibung
/hub:init	Neue Kollaborationssitzung erstellen – Aufgabe, Agentenanzahl, Bewertungskriterien
/hub:spawn	N parallele Unteragenten in isolierten Worktrees starten
/hub:status	DAG-Zustand, Agentenfortschritt, Branch-Status anzeigen
/hub:eval	Agentenergebnisse nach Metrik oder LLM-Richter einstufen
/hub:merge	Gewinner-Branch mergen, Verlierer archivieren
/hub:board	Nachrichtenbrett der Agenten lesen/schreiben
/hub:run	Einmaliger Lebenszyklus: init → baseline → spawn → eval → merge

Agentenvorlagen

Beim Spawnen mit --template folgen die Agenten einem vordefinierten Iterationsmuster:

Vorlage	Muster	Anwendungsfall
optimizer	Bearbeiten → bewerten → behalten/verwerfen → 10x wiederholen	Leistung, Latenz, Größe
refactorer	Umstrukturieren → testen → iterieren bis grün	Codequalität, technische Schulden
test-writer	Tests schreiben → Abdeckung messen → wiederholen	Testabdeckungslücken
bug-fixer	Reproduzieren → diagnostizieren → beheben → verifizieren	Fehlerbehebungsansätze

Vorlagen sind in references/agent-templates.md definiert.

Wann diese Fertigkeit aktiviert wird

Auslösephrasen:

• „mehrere Ansätze ausprobieren“
• „Agenten konkurrieren lassen“
• „parallele Optimierung“
• „N Agenten starten“
• „verschiedene Lösungen vergleichen“
• „Fan-Out“ oder „Turnier“
• „Inhaltsvarianten generieren“
• „verschiedene Entwürfe vergleichen“
• „A/B-Test von Texten“
• „mehrere Strategien erkunden“

Koordinatorprotokoll

Die Haupt-Claude-Code-Sitzung ist der Koordinator. Sie folgt diesem Lebenszyklus:

INIT → DISPATCH → MONITOR → EVALUATE → MERGE

1. Init

Führe /hub:init aus, um eine Sitzung zu erstellen. Dies erzeugt:

• .agenthub/sessions/{session-id}/config.yaml – Aufgabenkonfiguration
• .agenthub/sessions/{session-id}/state.json – Zustandsmaschine
• .agenthub/board/ – Nachrichtenbrett-Kanäle

2. Dispatch

Führe /hub:spawn aus, um Agenten zu starten. Für jeden Agenten 1..N:

• Aufgabenverteilung an .agenthub/board/dispatch/ posten
• Über Agent-Tool mit isolation: "worktree" starten
• Alle Agenten in einer einzigen Nachricht starten (parallel)

3. Monitor

Führe /hub:status aus, um den Fortschritt zu prüfen:

• dag_analyzer.py --status --session {id} zeigt Branch-Zustand
• Board-Kanal progress/ enthält Agentenaktualisierungen

4. Evaluate

Führe /hub:eval aus, um Ergebnisse einzustufen:

• Metrik-Modus: Eval-Befehl in jedem Worktree ausführen, numerisches Ergebnis parsen
• Richter-Modus: Diffs lesen, Koordinator bewertet Qualität
• Hybrid: Zuerst Metrik, bei Gleichstand LLM-Richter

5. Merge

Führe /hub:merge aus, um abzuschließen:

• git merge --no-ff Gewinner in Basis-Branch
• Verlierer taggen: git tag hub/archive/{session}/agent-{i}
• Worktrees bereinigen
• Merge-Zusammenfassung an das Board posten

Agentenprotokoll

Jeder Unteragent erhält dieses Prompt-Muster:

Du bist agent-{i} in der Hub-Sitzung {session-id}.
Deine Aufgabe: {Aufgabenbeschreibung}

Anweisungen:
1. Lies deine Aufgabenstellung unter .agenthub/board/dispatch/{seq}-agent-{i}.md
2. Arbeite in deinem Worktree – nimm Änderungen vor, führe Tests durch, iteriere
3. Committe alle Änderungen mit aussagekräftigen Nachrichten
4. Schreibe deine Ergebniszusammenfassung nach .agenthub/board/results/agent-{i}-result.md
5. Beende die Sitzung, wenn fertig

Agenten sehen NICHT die Arbeit der anderen. Sie kommunizieren NICHT miteinander. Sie schreiben nur auf das Board, damit der Koordinator es lesen kann.

DAG-Modell

Branch-Benennung

hub/{session-id}/agent-{N}/attempt-{M}

• Sitzungs-ID: zeitstempelbasiert (YYYYMMDD-HHMMSS)
• Agent N: fortlaufend (1 bis agent-count)
• Versuch M: erhöht sich bei Wiederholung (normalerweise 1)

Früherkennung

Frontier = Branch-Spitzen ohne untergeordnete Branches. Entspricht der „leaves“-Abfrage von AgentHub.

python scripts/dag_analyzer.py --frontier --session {id}

Unveränderlichkeit

Der DAG ist append-only:

• Niemals Rebasing oder Force-Push von Agent-Branches
• Niemals Commits löschen (nur Branch-Referenzen nach Archivierung)
• Jeder Ansatz bleibt über Git-Tags erhalten

Nachrichtenbrett

Speicherort: .agenthub/board/

Kanäle

Kanal	Schreiber	Leser	Zweck
dispatch/	Koordinator	Agenten	Aufgabenverteilung
progress/	Agenten	Koordinator	Statusaktualisierungen
results/	Agenten + Koordinator	Alle	Endergebnisse + Merge-Zusammenfassung

Beitragsformat

---
author: agent-1
timestamp: 2026-03-17T14:30:22Z
channel: results
parent: null
---

## Ergebniszusammenfassung

- **Ansatz**: O(n²)-Sortierung durch Hash-Map ersetzt
- **Geänderte Dateien**: 3
- **Metrik**: 142ms (Basislinie: 180ms, Delta: -38ms)
- **Vertrauen**: Hoch – alle Tests bestanden

Brettregeln

• Append-only: Beiträge niemals bearbeiten oder löschen
• Eindeutige Dateinamen: {seq:03d}-{author}-{timestamp}.md
• YAML-Frontmatter ist bei allen Beiträgen erforderlich

Bewertungsmodi

Metrikbasiert

Am besten geeignet für: Benchmarks, Testbestehensraten, Dateigrößen, Antwortzeiten.

python scripts/result_ranker.py --session {id} \
  --eval-cmd "pytest bench.py --json" \
  --metric p50_ms --direction lower

Der Ranker führt den Eval-Befehl im Worktree-Verzeichnis jedes Agenten aus und parst die Metrik aus der Standardausgabe.

LLM-Richter

Am besten geeignet für: Codequalität, Lesbarkeit, Architekturentscheidungen.

Der Koordinator liest die Diffs jedes Agenten (git diff base...agent-branch) und bewertet nach:

1. Korrektheit (löst es die Aufgabe?)
2. Einfachheit (weniger geänderte Zeilen bevorzugt)
3. Qualität (saubere Ausführung, gute Struktur)

Hybrid

Zuerst Metrik ausführen. Wenn die Top-Agenten innerhalb von 10% voneinander liegen, LLM-Richter verwenden, um Gleichstände zu brechen.

Sitzungslebenszyklus

init → running → evaluating → merged
                            → archived (wenn kein Gewinner)

Zustandsübergänge werden von session_manager.py verwaltet:

Von	Nach	Auslöser
init	running	/hub:spawn abgeschlossen
running	evaluating	Alle Agenten zurückgekehrt
evaluating	merged	/hub:merge abgeschlossen
evaluating	archived	Kein Gewinner / alle fehlgeschlagen

Proaktive Auslöser

Der Koordinator sollte handeln, wenn:

Signal	Aktion
Alle Agenten abgestürzt	Fehlerzusammenfassung posten, Wiederholung mit anderen Einschränkungen vorschlagen
Keine Verbesserung zur Basislinie	Sitzung archivieren, andere Ansätze vorschlagen
Verwaiste Worktrees erkannt	session_manager.py --cleanup {id} ausführen
Sitzung in running feststeckt	Board auf Fortschritt prüfen, Timeout in Betracht ziehen

Installation

# In dein Claude Code Skills-Verzeichnis kopieren
cp -r engineering/agenthub ~/.claude/skills/agenthub

# Oder über ClawHub installieren
clawhub install agenthub

Skripte

Skript	Zweck
hub_init.py	.agenthub/-Struktur und Sitzung initialisieren
dag_analyzer.py	Früherkennung, DAG-Graph, Branch-Status
board_manager.py	Nachrichtenbrett CRUD (Kanäle, Beiträge, Threads)
result_ranker.py	Agenten nach Metrik oder Diff-Qualität einstufen
session_manager.py	Sitzungszustandsmaschine und Bereinigung

Verwandte Fertigkeiten

• autoresearch-agent – Einzel-Agenten-Optimierungsschleife (AgentHub verwenden, wenn N konkurrierende Agenten gewünscht sind)
• self-improving-agent – Selbstmodifizierender Agent (AgentHub verwenden, wenn externe Konkurrenz gewünscht ist)
• git-worktree-manager – Git-Worktree-Dienstprogramme (AgentHub verwendet intern Worktrees)