Wie KI-Agenten Aufgaben aneinander delegieren: Orchestrierung in OpenClaw erklärt
Der Tweet, der gerade die Runde macht
> "This army of @openclaw agents runs an entire company for $400/month. Here's the exact structure to follow."
366 Retweets. Kein Wunder — das klingt wie ein Traum. Ein Team aus KI-Agenten, das Vertrieb, Marketing, Code, Support und Koordination übernimmt, ohne Gehaltszettel.
Was der Tweet aber nicht zeigt: Wie reden die Agenten eigentlich miteinander?
Wie weiß ein Coding-Agent, dass der Marketing-Agent eine neue Feature-Beschreibung braucht? Wie bekommt die Teamleitung mit, wenn ein Sub-Agent fertig ist? Wie verhindert man, dass ein Auftrag einfach verschwindet?
Dieser Post beantwortet genau das — aus dem echten Betrieb unseres 6-Agenten-Teams.
---
Die drei Wege, wie Agenten in OpenClaw kommunizieren
OpenClaw bietet drei unterschiedliche Mechanismen für die Kommunikation zwischen Agenten. Jeder hat seinen Platz, und die Wahl zwischen ihnen ist nicht egal.
1. sessions_send — Direkte Nachrichten zwischen Agenten
Das ist die simpelste Form: Ein Agent schickt einem anderen eine Nachricht, als wäre es eine normale Chat-Nachricht.
```javascript
// Sam schickt Peter eine Aufgabe
sessions_send({
sessionKey: "agent-peter",
message: "Kannst du die neuen API-Endpunkte in apps/api/routes.ts reviewen?
Fokus: Sicherheitslücken und fehlende Input-Validierung.
Ergebnis in ClickUp Task TC-47 als Kommentar posten."
});
```
Peter bekommt die Nachricht wie eine normale Nutzernachricht — er "wacht auf", liest sie, führt die Aufgabe aus.
Wann man das nutzt:
Einschränkung: Du bekommst keine direkte Antwort. Sam kann Peter eine Nachricht schicken — aber sie muss dann warten oder aktiv nachfragen, ob Peter fertig ist.
---
2. Sub-Agents (sessions_spawn) — Temporäre Spezialisten
Für Aufgaben, die eine eigenständige Arbeitseinheit sind, spawnt Sam einen temporären Sub-Agenten. Der Sub-Agent existiert nur für diese eine Aufgabe, liefert sein Ergebnis zurück, und verschwindet dann.
```javascript
// Sam spawnt einen einmaligen Security-Auditor
const result = await sessions_spawn({
task: `Führe einen vollständigen Security-Audit der Datei
/opt/agents/docker-compose.yml durch.
Prüfe: exposed ports, hardcoded secrets, missing resource limits.
Gib eine priorisierte Liste von Problemen zurück (CRITICAL/HIGH/MEDIUM).`,
runtime: "subagent",
mode: "run"
});
```
Der Unterschied zu sessions_send: Sam wartet auf die Antwort. Der Sub-Agent läuft isoliert, erledigt seine Aufgabe, und gibt eine strukturierte Antwort zurück. Danach: weg.
Wann man das nutzt:
Praxisbeispiel aus unserem Setup:
Wenn ein Cron-Job morgens ausgeführt wird und Sam den Tagesbericht erstellt, spawnt sie für jeden Bereich einen Sub-Agent parallel:
```
Sam spawnt gleichzeitig:
├── Sub-Agent A: "Prüfe ungelesene E-Mails und extrahiere wichtige Punkte"
├── Sub-Agent B: "Lade ClickUp-Tasks mit hoher Priorität für heute"
└── Sub-Agent C: "Prüfe den Kalender für die nächsten 48 Stunden"
Sam wartet auf alle drei Ergebnisse.
Sam kombiniert die Ergebnisse zu einem Morgenreport.
Sam schickt den Report per Telegram.
```
Total-Laufzeit: die des langsamsten Sub-Agents — nicht die Summe aller drei.
---
3. Geteiltes Gedächtnis — Koordination durch Dateien
Das ist der am meisten unterschätzte Mechanismus. Agenten können über gemeinsame Dateien kommunizieren — was auf den ersten Blick primitiv wirkt, aber in der Praxis sehr robust ist.
Beispiel: Peter hat eine Aufgabe abgeschlossen
Peter schreibt in seine Workspace-Datei `status/tc-47.md`:
```markdown
# TC-47: API Security Review
Status: DONE
Abgeschlossen: 2026-03-07 03:45 UTC
Gefundene Probleme
ClickUp-Kommentar gepostet: Ja
```
Sam liest diese Datei beim nächsten Heartbeat-Check und weiß ohne Rückfrage: TC-47 ist fertig, und es gibt kritische Probleme, um die sie sich kümmern muss.
Warum das funktioniert:
---
Das Orchestrierungsmuster, das wirklich funktioniert
Nach vielen Iterationen haben wir uns auf ein Muster geeinigt, das für die meisten Aufgaben funktioniert. Wir nennen es intern "Claim & Complete":
```
1. Sam identifiziert eine Aufgabe (aus ClickUp, E-Mail, oder eigenem Kontext)
2. Sam wählt den richtigen Agenten basierend auf Aufgaben-Typ
3. Sam delegiert via sessions_send (bei langen Aufgaben) oder spawnt Sub-Agent (bei schnellen)
4. Sam schreibt den delegierten Status in ihre eigene HEARTBEAT.md
5. Beim nächsten Check prüft Sam, ob die Aufgabe erledigt wurde
6. Bei Timeout oder Fehler: eskaliert Sam oder übernimmt selbst
```
Das klingt nach viel Overhead — ist es aber nicht. Schritt 4 ist eine Zeile in einer Markdown-Datei. Schritt 5 dauert Sekunden.
---
Welcher Agent für welche Aufgaben?
Das ist die Entscheidung, die Sam bei jeder Delegation trifft. Unser Routing:
| Aufgabentyp | Delegiert an | Mechanismus |
|-------------|--------------|-------------|
| Code Review | Peter | sessions_send |
| Blog-Post schreiben | Maya | sessions_send |
| Schnelle Recherche | Sub-Agent | sessions_spawn |
| CEO-Briefing | Atlas | sessions_send |
| E-Mail-Antworten | Alex | sessions_send |
| Komplexe Analyse | Sub-Agent (Opus) | sessions_spawn mit model="claude-opus" |
Der wichtigste Faktor: Brauche ich die Antwort sofort? → Sub-Agent. Kann ich warten und der Agent soll eigenständig arbeiten? → sessions_send.
---
Fehler, die wir gemacht haben (und du vermeiden solltest)
Fehler 1: Zu granulare Delegation
Wir haben anfangs jeden kleinen Schritt delegiert. "Peter, erstell eine Variable." Das ist Overhead ohne Gewinn. Agenten sind gut für Aufgaben, die 5–60 Minuten menschliche Arbeit ersetzen. Für 5-Sekunden-Tasks: Sam erledigt es selbst.
Fehler 2: Keine Bestätigung des Auftrags
Sam schickt eine Nachricht an Peter. Peter antwortet nicht (läuft vielleicht gerade ein anderer Task). Sam spawnt einen zweiten Peter. Jetzt läuft dieselbe Aufgabe doppelt.
Lösung: sessions_send mit einem klaren Acknowledgement-Pattern. Peter schreibt als erstes in sein Status-File: "TC-47: IN BEARBEITUNG". Sam prüft das File bevor sie einen zweiten Auftrag schickt.
Fehler 3: Zirkuläre Delegation
Peter braucht eine Information und schickt Sam eine Nachricht. Sam schickt sie an Iris weiter. Iris sendet das Ergebnis an Sam. Sam antwortet Peter. Das ist ein 3-Hop-Chain für etwas, das Sam auch direkt hätte fragen können.
Regel: Maximal ein Delegations-Hop. Wenn Peter etwas von Iris braucht, schickt Sam direkt an Iris — nicht Peter → Sam → Iris.
Fehler 4: Shared State ohne Locking
Zwei Sub-Agents schreiben gleichzeitig in dieselbe Datei. Ergebnis: beschädigte Daten.
Lösung: Jeder Sub-Agent schreibt in seine eigene Datei. Sam kombiniert die Ergebnisse. Keine shared writes.
---
Das Gesamtbild: Wie ein echter Arbeitstag läuft
08:45 Uhr — Sam's Morgenreport-Cron läuft:
```
Sam spawnt 3 parallele Sub-Agents:
├── A: E-Mail-Check → 2 wichtige Mails, 14 Newsletter
├── B: Kalender → 1 Meeting um 10:00, 1 um 15:00
└── C: ClickUp → 3 hochpriore Tasks offen, davon 1 blockiert
Sam fasst zusammen und sendet Report an Dimitrios via Telegram.
Sam identifiziert: TC-89 (kritischer Bug) braucht sofortiges Handeln.
Sam delegiert TC-89 an Peter via sessions_send.
Sam notiert in HEARTBEAT.md: "TC-89 delegiert an Peter, Check um 10:00"
```
10:00 Uhr — nächster Heartbeat:
```
Sam liest HEARTBEAT.md.
Sam prüft Peters Status-File: TC-89 = IN BEARBEITUNG, geschätzt fertig 11:00.
Sam aktualisiert HEARTBEAT.md: "TC-89 bis 11:00 warten"
```
11:00 Uhr — Heartbeat:
```
Peter's Status-File: TC-89 = DONE, PR #142 erstellt.
Sam prüft PR #142 kurz.
Sam informiert Dimitrios: "TC-89 gefixt, PR bereit zum Review."
Sam löscht TC-89 aus HEARTBEAT.md.
```
Gesamte menschliche Beteiligung: Dimitrios liest morgens den Report und den finalen Status. Der Rest: komplett zwischen Agenten.
---
Kosten der Orchestrierung
Das ist der praktische Teil: Jede Kommunikation zwischen Agenten kostet Tokens.
Für das "$400/Monat"-Setup aus dem viralen Tweet: Das ist realistisch, wenn die meisten Koordinationsaufgaben über Shared Memory laufen und Sub-Agents sparsam für echte Parallelarbeit eingesetzt werden.
Unser Setup liegt bei ~350-450€/Monat für 6 Agenten mit aktivem Betrieb — der Großteil davon sind LLM-Kosten für inhaltliche Arbeit (Code, Texte, Analysen), nicht Koordination.
---
Tiefer einsteigen
Die komplette Implementierung — System-Prompts, SOUL.md-Konfiguration für jede Agenten-Rolle, Docker-Setup und die genauen Cron-Konfigurationen — ist im OpenClaw Setup Playbook dokumentiert.
18 Kapitel. Das echte Setup, nicht ein hypothetisches Framework.
Komplett auf Deutsch verfügbar. 🇩🇪