swarma – Wachstumsexperimente-Loop für Agententeams

Wann diese Fähigkeit genutzt werden sollte

Nutze swarma, wenn der Benutzer Folgendes möchte:

Wachstumsexperimente durchführen (Hooks, Landing Pages, Outreach, Preise, Aktivierung, Bindung)
Agententeams aufbauen, die lernen und sich verbessern durch A/B-Tests, nicht nur einmalig ausführen
Ein validiertes Playbook erhalten, das tatsächlich für die spezifische Zielgruppe/Produkt funktioniert
Ideen in großem Maßstab testen (50+ Experimente/Woche statt 2–5)
„Das haben wir versucht, es hat nicht funktioniert" durch protokollierte, analysierte, durchsuchbare Experimentdaten ersetzen

Auslösephrasen: „teste was funktioniert", „optimiere meinen Trichter", „finde die besten Hooks", „Experimente durchführen", „A/B-Test", „was funktioniert", „ein Playbook erstellen", „Wachstumsexperimente", „Conversion verbessern"

NICHT verwenden, wenn: Benutzer Workflow-Automatisierung (n8n/Make), Gesprächsspeicher (honcho) oder einmalige Agenten-Pipelines (CrewAI/AutoGen) möchte. swarma ist speziell für Experiment-Loops, die sich mit der Zeit verbessern.

Kurzreferenz

Befehle auf einen Blick

Befehl	Was er tut	Wann verwenden
`swarma init`	Instanz + Start-Team erstellen	Ersteinrichtung
`swarma cycle <team>`	Einen Experimentzyklus ausführen	Testen, manuelle Ausführung
`swarma cycle <team> --topic "..."`	Zyklus mit einem bestimmten Thema ausführen	Ad-hoc-Experimente
`swarma team create <name> --from-goal "..."`	Team aus einem Ziel generieren	Neuen Experimentbereich starten
`swarma team show <name>`	Teamkonfiguration anzeigen	Überprüfen, was generiert wurde
`swarma team list`	Alle Teams anzeigen	Übersicht
`swarma status`	Kosten, letzte Läufe, Experimente	Health Check
`swarma metric log <team> <agent> <value>`	Externe Metrik protokollieren	Echtzeitdaten einspeisen
`swarma metric import <team> <csv>`	Metriken in Bulk importieren	Batch-Datenaufnahme
`swarma metric show <team>`	Protokollierte Metriken anzeigen	Leistungsüberprüfung
`swarma serve --port 8282`	REST-API starten	Externe Integrationen
`swarma serve --mcp`	MCP-Server starten	Claude Code / Hermes-Integration
`swarma run`	Geplanten Engine-Start	Kontinuierlicher Betrieb
`swarma expert list`	Überlegungslinsen durchsuchen	Experten-Frameworks erkunden

Entscheidung: Welches Squad-Template?

Benutzer möchte verbessern...	Dieses Squad verwenden	AARRR-Stufe
Eröffnungszeilen / Hooks	`hook-lab`	Akquisition
Landing-Page-Texte	`landing-lab`	Akquisition
SEO-Rankings	`seo-engine`	Akquisition
Kaltakquise-Antwortraten	`cold-outbound`	Akquisition
Multiplattform-Inhalte	`channel-mix`	Akquisition
Onboarding von Anmeldung zu Wert	`activation-flow`	Aktivierung
Preise und Pakete	`pricing-lab`	Umsatz
Abwanderung und Bindung	`retention-squad`	Bindung
Virale Loops und Empfehlungen	`referral-engine`	Empfehlung
Marktpositionierung	`competitive-intel`	--
Kurzvideo-Pipeline	`faceless-factory`	Akquisition
Anzeigen-Creative-Tests	`ad-creative-lab`	Akquisition
UGC-Inhaltssimulation	`ugc-factory`	Akquisition
Programmatisches SEO	`programmatic-seo`	Akquisition
Newsletter-Wachstum	`newsletter-engine`	Bindung
Paid + organische Loops	`acquisition-squad`	Akquisition
Community-getriebenes Wachstum	`community-engine`	Bindung
KI-Commerce-Optimierung	`agentic-storefront`	Umsatz

Entscheidung: Generieren vs. Vorlage?

Situation	Ansatz
Benutzer hat ein spezifisches, klar definiertes Ziel	`swarma team create --from-goal` (KI entwirft das Team)
Ziel entspricht einem bestehenden Squad-Template	Template kopieren, dann anpassen
Benutzer möchte breit experimentieren	Mit `hook-lab` starten (am allgemeinsten)
Benutzer weiß nicht, wo er anfangen soll	Nach Trichterengpass fragen, dann auswählen

Der GROWS-Loop (Kernkonzept)

Jeder Experimentzyklus folgt fünf Schritten:

  Generieren       Ausführen       Beobachten       Urteilen       Erweitern
 Hypothese --> Experiment --> Signal --> Urteil --> Playbook
     ^                                                  |
     └──────────────────────────────────────────────────┘

Schritt	Was passiert	Wo im Code
G -- Generieren	Agent liest `strategy.md`, schlägt eine Hypothese vor	`core/cycle.py`
R -- Ausführen	Agent führt mit aktiver Hypothese aus, produziert Ausgabe	`flow/executor.py`
O -- Beobachten	Separates günstiges LLM bewertet Ausgabe (1–10, erzwungene Dezimalstellen)	`core/agent.py`
W -- Urteilen	Nach 5 Zyklen: Durchschnitt vs. Basislinie. >20% = behalten/verwerfen	`core/experiment.py`
S -- Erweitern	Validierte Muster werden in `strategy.md` + Playbook geschrieben	`core/agent.py`

Schlüsselzahlen:

Urteilsschwelle: 20% Verbesserung zum Behalten, 20% Verschlechterung zum Verwerfen
Standard min_sample_size: 5 Zyklen vor Urteil
Bewertung: 1–10-Skala mit erzwungenen Dezimalstellen (7,3, nicht 7)

Setup-Anleitung

Plattform: Claude Code / Claude Desktop

pip install swarma
swarma init

Zu .mcp.json hinzufügen:

{
  "mcpServers": {
    "swarma": {
      "command": "swarma",
      "args": ["serve", "--mcp"],
      "env": { "OPENROUTER_API_KEY": "sk-or-..." }
    }
  }
}

Wichtig: OPENROUTER_API_KEY muss im MCP env-Block sein. Die Instanz .env wird nicht von Unterprozessen geerbt.

Plattform: Hermes (via Terminal)

Hermes hat Terminalzugriff – es kann swarma-CLI-Befehle direkt ausführen. MCP nicht erforderlich.

pip install swarma
swarma init

Dann Hermes sagen: „führe swarma cycle hook-lab --topic 'KI-Agenten werden überbewertet' aus"

Hermes liest Terminalausgabe und handelt basierend auf Ergebnissen. Für strukturierten Zugriff MCP hinzufügen:

# hermes config.yaml
mcp_servers:
  swarma:
    transport: stdio
    command: swarma
    args: ["serve", "--mcp"]
    env:
      OPENROUTER_API_KEY: "sk-or-..."

Plattform: OpenClaw

pip install swarma
swarma init

Als MCP-Tool konfigurieren oder Terminalzugriff nutzen, je nach OpenClaw-Setup.

Plattform: CLI (Standalone)

pip install swarma
swarma init                                        # erstellt Instanz + Start-Team
swarma cycle starter --topic "warum startups scheitern"   # einen Zyklus ausführen
swarma status                                      # Kosten, Läufe, Experimente prüfen

Aus dem Quellcode

git clone https://github.com/glitch-rabin/swarma.git
cd swarma && pip install -e .
swarma init

Umgebungseinrichtung

Nach swarma init deinen API-Key hinzufügen:

echo "OPENROUTER_API_KEY=sk-or-..." >> ~/.swarma/instances/default/.env

Einen Key unter openrouter.ai/keys abrufen.

Optional (für teamübergreifendes Wissen):

# Nur bei 3+ Teams erforderlich
echo "QMD_ENDPOINT=http://localhost:8181/mcp" >> ~/.swarma/instances/default/.env

Onboarding-Ablauf

Wenn ein Benutzer swarma einrichten möchte, folge dieser Sequenz. Der Team-Generator ist der schnellste Weg – zwinge Benutzer nicht, Agenten manuell zu konfigurieren.

Schritt 1: Ziel verstehen

Fragen:

„Was möchtest du verbessern?" (Conversion, Engagement, Antwortrate bei Kaltakquise, SEO-Rankings usw.)
„Wer ist deine Zielgruppe?" (B2B-SaaS-Nutzer, Krypto-Community, Unternehmenskäufer usw.)
„Wie sieht Erfolg aus?" (mehr Anmeldungen, höhere CTR, bessere Antwortraten usw.)

Schritt 2: Installieren

pip install swarma
swarma init --yes

Schritt 3: Team generieren

Dies ist der entscheidende Schritt. Verwende den Team-Generator anstatt Vorlagen auszuwählen.

swarma team create growth-lab \
  --from-goal "optimiere Landing-Page-Conversion für unser B2B-SaaS" \
  --context "Entwicklertools-Unternehmen, 500 kostenlose Nutzer, 2% Conversion zu Kostenpflichtig" \
  --budget 30

Der Generator:

Entwirft das Team (2–5 Agenten mit spezifischen Rollen)
Wählt Modelle, die zu den Rollen passen
Schreibt Agentenanweisungen und Experimentmuster
Erstellt eine erste Experimenthypothese, die startbereit ist

Überprüfe, was generiert wurde:

swarma team show growth-lab

Schritt 4: Ersten Zyklus ausführen

swarma cycle growth-lab

Erwartete Ausgabe:

Running cycle: growth-lab
  flow: researcher -> copywriter -> judge
  agents: ['researcher', 'copywriter', 'judge']

                              Cycle: growth-lab
  Agent      Model              Cost       Output Preview
  researcher sonar-pro          $0.000384  **Thema:** 52% der Führungskräfte...
  copywriter qwen3.5-plus-02-15 $0.000746  [A] Wir haben 4.382 Kaltmails gesendet...
  judge      mistral-nemo       $0.000416  **Hook-Variationen:** A: "Hast...

  duration: 43,9s | total cost: $0,001546 | agents: 3

Schritt 5: Weitere Zyklen ausführen und überprüfen

swarma cycle growth-lab                    # weiteren Zyklus ausführen
swarma cycle growth-lab --topic "spezifischer Winkel"  # mit einem Thema
swarma status                              # Fortschritt prüfen

Nach 5 Zyklen gibt die Experiment-Engine ihr erstes Urteil ab. Die Strategiedatei entwickelt sich automatisch weiter.

Tägliche Nutzung

Experimente ausführen

# Einzelzyklus
swarma cycle hook-lab

# Mit einem bestimmten Thema
swarma cycle hook-lab --topic "KI-Agenten werden zur Commodity"

# Kontinuierlich (Teams mit Cron-Zeitplänen laufen automatisch)
swarma run

# Kontinuierlich mit API-Server
swarma run --port 8282

Echtmetriken einspeisen

LLM-Selbstbewertung ist ein Ausgangsproxy. Für die Produktion echte Signale zurückspeisen:

# Einzelne Metrik protokollieren
swarma metric log hook-lab copywriter 4.2 --metric ctr_pct

# An ein bestimmtes Experiment anhängen
swarma metric log hook-lab copywriter 127 --metric impressions --exp 3

# Notiz hinzufügen
swarma metric log hook-lab copywriter 5.1 --metric ctr_pct --note "aus LinkedIn-Analyse"

# Bulk-Import aus CSV
swarma metric import hook-lab metrics.csv

# Protokollierte Metriken anzeigen
swarma metric show hook-lab

CSV-Format: agent,value,metric_name,note

copywriter,4.2,ctr_pct,Woche 1
copywriter,5.1,ctr_pct,Woche 2
researcher,7.8,relevance_score,

Squad-Vorlagen verwenden

# Eine Vorlage in deine Instanz kopieren
cp -r "$(python -c "import swarma; print(swarma.__path__[0])")/examples/hook-lab" \
  ~/.swarma/instances/default/teams/hook-lab

# Oder wenn du das Repository geklont hast
cp -r examples/hook-lab ~/.swarma/instances/default/teams/hook-lab

# Ausführen
swarma cycle hook-lab --topic "warum die meisten Startups scheitern"

Status prüfen

swarma status

Zeigt: alle Teams, letzte Läufe, Kosten (heute + diesen Monat), ausstehende Pläne, Warteschlangen-Statistiken.

MCP-Tools-Referenz

Wenn über MCP verbunden, sind diese 16 Tools verfügbar:

Tool	Beschreibung	Parameter
`swarma_health`	Prüfen, ob swarma läuft	--
`swarma_list_teams`	Alle konfigurierten Teams auflisten	--
`swarma_get_team`	Teamdetails abrufen (Agenten, Flow, Zeitplan)	`team_id`
`swarma_list_agents`	Agenten in einem Team auflisten	`team_id`
`swarma_run_agent`	Einzelnen Agenten mit optionalem Kontext ausführen	`team_id`, `agent_id`, `context?`
`swarma_run_cycle`	Vollständigen Zyklus für ein Team ausführen	`team_id`, `topic?`
`swarma_status`	Instanzstatus (Kosten, Läufe, Experimente)	--
`swarma_costs`	Kostenaufschlüsselung (heute, dieser Monat)	--
`swarma_list_plans`	Ausstehende Experimentpläne anzeigen	`team_id?`
`swarma_approve_plan`	Ausstehenden Experimentplan genehmigen	`plan_id`
`swarma_reject_plan`	Ausstehenden Plan ablehnen	`plan_id`, `reason?`
`swarma_get_outputs`	Aktuelle Ausgaben von Agenten	`team_id?`, `agent_id?`, `limit?`
`swarma_list_tools`	Verfügbare Agenten-Tools auflisten	--
`swarma_list_experts`	Überlegungslinsen von Experten durchsuchen	--
`swarma_get_expert`	Expertendetails nach ID abrufen	`expert_id`
`swarma_generate_team`	Neues Team aus einem Ziel generieren	`name`, `goal`, `context?`, `budget?`

Häufige MCP-Workflows

„Was ist passiert?"

swarma_status – Übersicht
swarma_get_outputs – aktuelle Agentenausgaben
swarma_list_plans – ausstehende Experimente

„Ein Experiment ausführen"

swarma_run_cycle mit team_id und optionalem Thema
swarma_get_outputs zur Ergebnisüberprüfung

„Einen neuen Experimentbereich starten"

swarma_generate_team mit Ziel und Kontext
swarma_get_team zur Überprüfung, was generiert wurde
swarma_run_cycle zum Starten

„Was funktioniert?"

swarma_get_outputs für aktuelle Ergebnisse
strategy.md des Teams für validierte Muster lesen

Teamkonfigurations-Referenz

Ein Team ist ein Ordner. Kein Code erforderlich.

teams/my-squad/
├── team.yaml          # Ziel, Flow, Zeitplan, Budget
├── program.md         # Team-Kontext und Einschränkungen
└── agents/
    ├── researcher.yaml
    ├── writer.yaml
    └── strategy.md    # Vorbereitetes Wachstumswissen (entwickelt sich automatisch)

team.yaml

name: my-squad
Ziel: finde was funktioniert.
flow: "researcher -> writer"        # sequentiell
# flow: "researcher -> [writer, analyst]"  # parallel
Zeitplan: "0 8 * * 1-5"            # optional: Werktags um 8 Uhr
Budget: 30                           # optional: monatliches Budget in $

agent.yaml

id: writer
Name: Schreiber
Anweisungen: |
  verwandle recherche in einen beitrag. max 200 worte.
  hook in der ersten zeile. praxisstimme.
model: qwen/qwen3.5-plus-02-15     # optional: Standard-Routing überschreiben
Metrik:
  name: content_quality
  target: 8.0
experiment_config:
  min_sample_size: 5
  auto_propose: true

strategy.md (entwickelt sich automatisch)

Beginnt mit Vorwissen, wächst mit jedem validierten Experiment:

### Validierte Muster

**Spezifität gewinnt**
- Hooks mit konkreten Zahlen übertreffen vage Behauptungen um das 2- bis 3-Fache bei Saves
- „47% der Startups" > „die meisten Startups"

### Anti-Patterns (Verworfen)
- Generische inspirierende Eröffnungen: -23% vs. Basislinie. Verworfen.

### Zu testende Muster
- [ ] Ich-Form-Geständnis vs. Fallstudie in dritter Person
- [ ] Zeitlich verankerte („Im Jahr 2024...") vs. zeitlose Hooks

Flow-DSL

# Sequentiell: a läuft, Ausgabe geht an b
flow: "researcher -> writer"

# Parallel: a läuft, dann b und c laufen gleichzeitig
flow: "researcher -> [writer, analyst]"

# Gemischt:
…

[gekürzt für die Übersetzung]

In Ihrer bevorzugten KI fragen

Dokumentation