Stell dir vor, du gibst Claude Code eine komplexe Aufgabe — sagen wir: „Analysiere unsere gesamte Codebasis, schreibe fehlende Unit-Tests, refaktoriere die Performance-Bottlenecks und erstelle dabei eine vollständige Dokumentation." Sequenziell würde das Stunden dauern, den Kontext sprengen und Fehler produzieren, weil der Agent frühere Teilergebnisse vergisst.
Mit Multi-Agent-Workflows löst Claude Code genau dieses Problem: Mehrere spezialisierte Sub-Agents arbeiten gleichzeitig an verschiedenen Teilaufgaben, koordinieren sich über Nachrichten, und ein Orchestrator-Agent fasst die Ergebnisse zusammen. Das Ergebnis: kürzere Laufzeiten, bessere Qualität — und Workflows, die vorher schlicht unmöglich waren.
Das Konzept hinter Multi-Agent-Architekturen in Claude Code, wie du parallele Sub-Agents startest, Hintergrund-Agents einsetzt, Agents koordinierst, und welche Patterns sich in der Praxis bewährt haben — inklusive konkreter Prompt-Beispiele.
1. Multi-Agent Konzept: Warum mehrere KI-Agents?
Claude Code ist von Anthropic explizit für agentic Use Cases konzipiert — also Szenarien, in denen die KI eigenständig mehrstufige Aufgaben ausführt, Tools benutzt und Entscheidungen trifft. Multi-Agent-Workflows gehen einen Schritt weiter: Statt einem einzigen allmächtigen Agent teilt man die Arbeit auf spezialisierte Einheiten auf.
Sequenziell vs. Parallel — der entscheidende Unterschied
Sequenzielle Verarbeitung bedeutet: Agent A macht Aufgabe 1, dann Aufgabe 2, dann Aufgabe 3. Bei langen Aufgabenketten bläht der Kontext sich auf — der Agent „vergisst" frühe Details, macht Fehler, und die Gesamtlaufzeit addiert sich linear.
Parallele Verarbeitung bedeutet: Agent A, B und C starten gleichzeitig mit Aufgaben 1, 2 und 3. Die Laufzeit bestimmt das langsamste Sub-Task — nicht die Summe aller Tasks. Und jeder Agent hält nur seinen eigenen, kompakten Kontext.
| Kriterium | Sequenziell | Multi-Agent (Parallel) |
|---|---|---|
| Laufzeit bei 4 Tasks à 5 min | ~20 min | ~5-6 min |
| Kontext-Größe | Wächst linear | Jeder Agent: klein + fokussiert |
| Spezialisierung | ✗ Ein Agent, alles | ✓ Jeder Agent = Experte |
| Fehlertoleranz | Ein Fehler blockiert alles | Einzelne Agents können neu gestartet werden |
| Skalierbarkeit | Begrenzt durch Kontext-Window | Horizontal skalierbar |
Die drei Agent-Typen in Claude Code
Orchestrator Der Planer
Der Orchestrator-Agent kennt das große Bild. Er teilt komplexe Aufgaben in Sub-Tasks auf, startet spezialisierte Agents, sammelt deren Ergebnisse und integriert sie. Er schreibt selten selbst Code — er koordiniert. In Claude Code ist das oft der „Manager"-Subagent-Typ.
Parallel Worker Die Spezialisten
Parallele Worker-Agents führen konkrete Teilaufgaben aus: einer schreibt Code, einer recherchiert, einer führt Tests aus. Sie laufen gleichzeitig und berichten ihre Ergebnisse an den Orchestrator. Dank fokussiertem Kontext sind sie präziser als ein Generalist.
Hintergrund-Agent Der Async-Worker
Hintergrund-Agents starten mit run_in_background=True und arbeiten asynchron.
Der Hauptagent wird nicht blockiert und kann direkt weiterarbeiten. Ideal für lange
Analysen, Deployments oder Tests, die im Hintergrund laufen sollen.
Diese drei Muster lassen sich kombinieren: Ein Orchestrator startet mehrere parallele Worker, von denen einige im Hintergrund laufen — während er selbst bereits die nächste Phase plant.
2. Parallele Sub-Agents: Gleichzeitig arbeiten lassen
Claude Code erlaubt es, über das Agent()-Tool mehrere Sub-Agents
gleichzeitig zu starten. Der Trick: Du startest alle Agents in einem
einzigen Tool-Call-Block — dann laufen sie parallel.
Wie Parallelisierung in der Praxis aussieht
Claude Code startet dann drei separate Agent-Instanzen, die unabhängig voneinander im gleichen Repository arbeiten. Jeder Agent hat seinen eigenen Kontext, seine eigenen Tool-Calls, und gibt am Ende ein strukturiertes Ergebnis zurück.
Unabhängige Teilaufgaben identifizieren
Der Schlüssel zur effektiven Parallelisierung: Die Teilaufgaben müssen unabhängig voneinander sein — also kein Sub-Agent darf auf das Ergebnis eines anderen warten müssen. Gute Kandidaten für Parallelisierung:
- Analyse verschiedener Codebase-Bereiche (Frontend / Backend / Datenbank)
- Tests auf verschiedenen Branches gleichzeitig ausführen
- Dokumentation für verschiedene Module parallel schreiben
- Security-Audit und Performance-Analyse simultan durchführen
- Competitor-Recherche parallel zu eigenem Feature-Design
Synchronisation der Ergebnisse
Wenn alle parallelen Agents fertig sind, gibt jeder sein Ergebnis strukturiert zurück. Der Orchestrator wartet auf alle Ergebnisse (sofern nicht im Hintergrundmodus) und fasst sie zusammen. Für die Synchronisation bieten sich strukturierte JSON-Outputs an:
3. Hintergrund-Agents: Async ohne Blockierung
Mit run_in_background=True startet Claude Code einen Agent, ohne auf dessen
Abschluss zu warten. Der Hauptagent — oder der User — kann sofort weiterarbeiten. Das ist
besonders wertvoll für lang laufende Prozesse wie Deployments, umfangreiche Test-Suiten
oder zeitintensive Analysen großer Datensätze.
Typische Anwendungsfälle
Background Deployment-Agent
Du startest den Deployment-Agent im Hintergrund, während du bereits die Changelog-Notizen schreibst oder das nächste Feature planst. Der Deployment-Agent meldet sich, wenn er fertig ist — oder wenn ein Fehler auftritt.
Background Test-Suite-Runner
Eine vollständige E2E-Testsuite mit Playwright kann 10-15 Minuten dauern. Mit
run_in_background=True läuft sie durch, während du parallele Feature-Entwicklung
betreibst. Du bekommst eine Notification wenn Tests fehlschlagen.
Background Daten-Analyse-Agent
Große Log-Dateien (mehrere GB) analysieren, Embeddings berechnen, oder komplexe Datenbankmigrationen vorbereiten — all das passiert im Hintergrund, ohne den Entwicklungs-Flow zu unterbrechen.
Hintergrund-Agent starten — Beispiel-Prompt
Definiere immer, was „fertig" bedeutet und wann ein Agent eskalieren soll. Ohne klare Abbruch-Bedingungen können Hintergrund-Agents in Endlosschleifen geraten oder auf Ressourcen warten, die nie verfügbar werden.
Notification-Pattern: Wie Agents zurückmelden
Hintergrund-Agents haben zwei Möglichkeiten zur Rückmeldung: Sie schreiben ihr Ergebnis in
eine definierte Datei (z.B. /tmp/agent-result.json), die der Hauptagent
periodisch prüft — oder sie nutzen SendMessage, um den Orchestrator direkt zu
benachrichtigen, wenn sie fertig sind.
4. Agent-Koordination: Orchestrator und Spezialisten
Die eigentliche Stärke von Multi-Agent-Systemen liegt in der Koordination. Ein Orchestrator-Agent kennt das Gesamtziel, teilt es in Sub-Tasks auf, delegiert an Spezialisten und integriert die Ergebnisse. Spezialisten-Agents sind in ihrer Domäne tief spezialisiert — und genau deshalb präziser als ein Generalist.
Das Orchestrator-Pattern
Aufgabe verstehen und dekomponieren
Der Orchestrator analysiert die Gesamtaufgabe und zerlegt sie in unabhängige, delegierbare Sub-Tasks mit klaren Inputs und erwarteten Outputs.
Richtige Agents für Sub-Tasks wählen
Jeder Sub-Task bekommt den passenden Spezialisten: Researcher für Analyse, Coder für Implementierung, Reviewer für Qualitätssicherung, Runner für Ausführung.
Parallele oder sequenzielle Ausführung entscheiden
Unabhängige Tasks starten parallel. Tasks mit Abhängigkeiten (B braucht Ergebnis von A) starten sequenziell. Gute Orchestratoren minimieren sequenzielle Ketten.
Ergebnisse sammeln und validieren
Der Orchestrator prüft alle Sub-Task-Ergebnisse auf Vollständigkeit und Qualität. Bei Mängeln startet er einen weiteren Agent-Durchlauf (Retry-Loop).
Integration und Ausgabe
Alle validierten Teilresultate werden zu einem kohärenten Gesamtergebnis zusammengefasst und dem User oder dem übergeordneten System übergeben.
SendMessage: Direkte Agent-zu-Agent-Kommunikation
Claude Code erlaubt es Agents, sich gegenseitig Nachrichten zu senden — entweder direkt (Point-to-Point) oder als Broadcast an alle aktiven Agents. Das ermöglicht dynamische Koordination ohne zentralen Engpass.
Broadcast vs. Point-to-Point
- Point-to-Point: Ein Agent sendet direkt an einen anderen — für spezifische Delegation und Ergebnis-Reporting.
- Broadcast: Ein Agent (typisch der Orchestrator) sendet an alle aktiven Agents gleichzeitig — für System-Updates, Kontext-Änderungen oder Abbruch-Signale.
5. Praktische Patterns: Was wirklich funktioniert
Theorie ist gut — aber welche Patterns haben sich in echten Claude Code Multi-Agent-Projekten bewährt? Hier sind die fünf wichtigsten Muster mit konkreten Prompt-Vorlagen.
Pattern 1: Researcher + Coder + Reviewer (RCR-Triad)
Das beliebteste Pattern für Feature-Entwicklung. Drei spezialisierte Agents arbeiten sequenziell, aber innerhalb ihrer Phase maximal parallel.
Researcher Phase 1: Kontext sammeln
Analysiert die bestehende Codebase, Dokumentation und externe Quellen (Web, Bibliotheken). Output: strukturierte Analyse mit Empfehlungen für die Implementierung.
Coder Phase 2: Implementierung
Erhält den Research-Output als Input und implementiert das Feature. Schreibt gleichzeitig Unit-Tests. Nutzt den Researcher-Output als Kontext — kein Rediscovery nötig.
Reviewer Phase 3: Qualitätssicherung
Reviewed den Code des Coders nach Security, Performance und Stil. Gibt strukturiertes Feedback. Falls kritische Issues gefunden: Coder startet einen neuen Pass.
Pattern 2: Parallele Test-Branches
Wenn ein Feature auf mehreren Branches oder gegen verschiedene Node.js-Versionen getestet werden soll, startet Claude Code mehrere Test-Runner-Agents gleichzeitig.
Pattern 3: Code-Review Swarm
Bei großen Pull Requests mit hunderten geänderten Dateien ist ein einzelner Review-Agent überlastet. Der Swarm-Ansatz teilt den PR in Chunks auf:
Pattern 4: Kontext-Splitting für große Codebases
Große Repositories übersteigen das Kontext-Fenster eines einzelnen Agents. Multi-Agent löst dieses Problem elegant: Jeder Agent bekommt nur seinen eigenen Bereich als Kontext.
Wenn eine Aufgabe mehr als 50 Dateien betrifft oder mehr als 30.000 Tokens Kontext bräuchte — sofort auf Multi-Agent splitten. Faustregel: pro Agent maximal 20-25 relevante Dateien.
Pattern 5: Inkrementelle Parallelisierung
Nicht jedes Projekt lässt sich von Anfang an vollständig parallelisieren. Das Inkrementelle Muster startet mit einem Analyse-Agent, der automatisch bestimmt, welche Aufgaben parallelisierbar sind — und startet dann die passenden Agents dynamisch:
6. Best Practices: Multi-Agent richtig einsetzen
Multi-Agent-Workflows sind mächtig — aber auch komplex. Diese Best Practices helfen dir, häufige Fehler zu vermeiden und das Beste aus parallelen KI-Systemen herauszuholen.
Wann ist Multi-Agent sinnvoll?
| Nutze Multi-Agent wenn... | Nutze Single-Agent wenn... |
|---|---|
| ✓ Aufgabe hat >3 unabhängige Teilschritte | ✓ Task ist kleiner, zusammenhängender Schritt |
| ✓ Verschiedene Expertisen nötig (Research + Code + QA) | ✓ Starke Interdependenz zwischen Teilschritten |
| ✓ Codebase zu groß für einen Kontext | ✓ Kontext passt gut in ein Fenster |
| ✓ Parallelisierung spart >30% Zeit | ✓ Overhead überwiegt den Parallelisierungs-Gewinn |
| ✓ Lang laufende Tasks (Deployments, Tests) | ✓ Aufgabe dauert unter 2-3 Minuten |
Kontext-Management in Multi-Agent-Systemen
Jeder Agent hat sein eigenes Kontext-Fenster. Der Orchestrator sollte Sub-Task-Ergebnisse
kompakt halten — nicht den gesamten Agent-Output im eigenen Kontext speichern, sondern
nur eine strukturierte Zusammenfassung. Detaillierte Ergebnisse schreiben Agents in
temporäre Dateien (/tmp/ oder .work/).
Idempotenz: Agents sicher wiederholbar machen
Multi-Agent-Workflows scheitern manchmal. Ein Agent crasht, das Netzwerk unterbrach sich, ein Tool gab einen Fehler zurück. Damit Restarts sicher möglich sind, müssen Agents idempotent sein — das heißt: zweimaliges Ausführen führt zum gleichen Ergebnis wie einmaliges.
- Schreibe immer in dedizierte Ausgabedateien, die bei erneutem Start überschrieben werden
- Prüfe zu Beginn ob das Ergebnis bereits existiert:
if os.path.exists(output_file): return - Verwende atomare Schreiboperationen (Temp-Datei → Rename)
- Füge Checksums oder Timestamps in Ausgabedateien ein, damit der Orchestrator veraltete Ergebnisse erkennt
Fehlerbehandlung im Orchestrator
Ein häufiger Fehler: Der Orchestrator ignoriert fehlgeschlagene Sub-Agents und integriert nur die erfolgreichen Ergebnisse — ohne den User zu informieren. Das führt zu stillen Fehlern, die erst viel später auffallen.
Definiere in jedem Orchestrator-Prompt explizit das Fehler-Verhalten:
Token-Effizienz: Kosten im Griff behalten
Mehr Agents bedeutet mehr Token-Verbrauch. Diese Techniken helfen, die Kosten zu optimieren:
- Haiku für einfache Tasks: Recherche-Schritte, die nur Dateien lesen und zusammenfassen, benötigen kein Sonnet/Opus-Level.
- Kompakte Übergaben: Agents übergeben strukturierte JSONs, keine langen Prosa-Berichte.
- Lazy Loading: Starte Agents nur wenn ihr Input tatsächlich vorliegt — kein spekulatives Spawnen.
- Early Exit: Agents prüfen zu Beginn ob ihre Aufgabe überhaupt nötig ist. Wenn eine Datei unverändert ist, überspringen sie die Analyse.
- Budget-Limits: Definiere maximale Token-Budgets pro Agent und Gesamtworkflow.
Debugging Multi-Agent-Workflows
Wenn ein Multi-Agent-Workflow unerwartet verhält, hilft dieser Diagnose-Ansatz:
Agent-Logs zentralisieren
Jeder Agent schreibt in /tmp/agent-log-{name}-{timestamp}.json.
Ein separater Log-Aggregator-Agent liest alle Logs und erstellt eine Timeline.
Sequenziell reproduzieren
Wenn ein paralleler Workflow Fehler produziert, führe die Schritte sequenziell aus. Oft liegt das Problem in Race Conditions oder nicht-atomaren Schreiboperationen.
Kleinsten scheiternden Sub-Task isolieren
Starte nur den fehlschlagenden Agent alleine. Prüfe seinen Prompt, Input und Tool-Zugriffe. Dann schrittweise weitere Agents hinzufügen.
Zusammenfassung: Der Multi-Agent Stack 2026
Claude Code Multi-Agent-Workflows sind kein Feature für Edge Cases — sie sind die natürliche Weiterentwicklung des Agentic Programming. Komplexe Entwicklungsaufgaben, die früher Tage dauerten, lösen gut orchestrierte Agent-Systeme in Stunden. Die Schlüsselprinzipien:
- Orchestrator-first: Immer mit einem klaren Planer starten, der den Big Picture kennt
- Spezialisierung: Lieber drei fokussierte Agents als ein überlasteter Generalist
- Parallelisierung: Unabhängige Tasks immer gleichzeitig ausführen
- Strukturierte Übergaben: JSON-Outputs statt Prosa — Agents reden mit Maschinen, nicht mit Menschen
- Idempotenz: Jeden Agent so bauen, dass er sicher neu gestartet werden kann
- Observability: Logs, Checkpoints, strukturierte Ergebnisse — damit du weißt was wirklich passiert
Multi-Agent Workflows selbst erleben
Starte deinen kostenlosen SpockyMagicAI Trial und deploye deinen ersten Multi-Agent-Workflow noch heute — ohne Kreditkarte, ohne Setup-Overhead.
Kostenlos starten →