"Agent Orchestration: So steuerst du KI-Teams mit Claude Code"

## Was ist Agent Orchestration?

Agent Orchestration ist die Fähigkeit, mehrere KI-Agenten koordiniert zusammenarbeiten zu lassen. Statt einen einzelnen Agenten alle Aufgaben nacheinander abarbeiten zu lassen, verteilst du Arbeit auf spezialisierte Agenten — genau wie ein Projektmanager ein Team steuert.

Die Definition lässt sich präzisieren: Agent Orchestration beschreibt das Planen, Delegieren und Koordinieren von Aufgaben über mehrere autonome KI-Agenten hinweg, wobei jeder Agent eine klar definierte Rolle, eigene Werkzeuge und einen abgegrenzten Kontext hat.

In Claude Code ist Agent Orchestration keine Zukunftsmusik. Es ist ein Feature, das du heute nutzen kannst — mit Subagenten, Git Worktrees und strukturierten Workflows.

Warum mehrere Agenten statt einem?

Die Grenzen eines einzelnen Agenten werden schnell sichtbar:

Jeder KI-Agent hat ein begrenztes Kontextfenster. Je mehr Informationen du hineinstopfst, desto ungenauer werden die Ergebnisse. Ein Agent, der gleichzeitig Frontend, Backend, Tests und Dokumentation bearbeitet, verliert den Überblick — genau wie ein Mensch, der zu viele Aufgaben parallel jongliert.

Ein Agent, der nur für CSS zuständig ist, liefert besseres CSS als ein Agent, der nebenbei auch noch die Datenbank-Migration schreibt. Multi-Agent-Workflows nutzen dieses Prinzip: Jeder Agent bekommt einen klaren Auftrag und den dafür nötigen Kontext — nicht mehr.

Architektur-Patterns für Agent Orchestration

Es gibt drei grundlegende Patterns, die du kennen solltest:

Das wichtigste Pattern. Du zerlegst eine große Aufgabe in unabhängige Teilaufgaben, verteilst sie an spezialisierte Agenten (Fan-out) und führst die Ergebnisse wieder zusammen (Fan-in).

Beispiel: Du baust eine neue Feature-Seite.

• Agent A: Erstellt das Frontend-Layout (React-Komponenten, Styling)
• Agent B: Baut die API-Endpunkte (Backend-Logik, Datenbank)
• Agent C: Schreibt die Tests (Unit-Tests, Integration-Tests)
• Orchestrator: Führt die Ergebnisse zusammen, prüft Kompatibilität

Jeder Agent arbeitet in einem eigenen Git Worktree — isoliert, ohne die Arbeit der anderen zu stören.

Aufgaben werden nacheinander von spezialisierten Agenten bearbeitet. Jeder Agent baut auf dem Ergebnis des vorherigen auf.

Beispiel: Code-Review-Pipeline.

Ein übergeordneter Agent (Manager) delegiert Aufgaben an Worker-Agenten und koordiniert deren Ergebnisse. Der Manager trifft Entscheidungen, die Worker führen aus.

Beispiel: Feature-Entwicklung mit Lead-Agent.

• Lead-Agent: Plant die Architektur, verteilt Aufgaben, reviewed Ergebnisse
• Worker 1: Implementiert Komponente A
• Worker 2: Implementiert Komponente B
• Worker 3: Schreibt Dokumentation

Praktische Umsetzung mit Claude Code

Claude Code unterstützt Subagenten nativ. Du kannst aus einer Claude Code Session heraus weitere Agenten starten, die eigenständig arbeiten. So funktioniert es:

Schritt 1: Aufgabe definieren

Beschreibe dem Hauptagenten, was du bauen willst. Sei spezifisch über die Architektur und welche Teile parallelisiert werden können.

Schritt 2: Subagenten delegieren

Claude Code kann Subagenten spawnen, die jeweils eine klar definierte Aufgabe bearbeiten. Jeder Subagent bekommt:

• Einen klaren Auftrag (was soll er tun?)
• Den nötigen Kontext (welche Dateien sind relevant?)
• Einschränkungen (was soll er nicht anfassen?)

Schritt 3: Ergebnisse zusammenführen

Der Hauptagent prüft die Ergebnisse der Subagenten, löst eventuelle Konflikte und integriert alles in den Hauptbranch.

Git Worktrees sind das technische Rückgrat der Agent Orchestration. Ein Worktree ist eine separate Arbeitskopie deines Repositories — gleicher Git-Verlauf, aber eigenes Verzeichnis.

Warum das wichtig ist: Wenn zwei Agenten gleichzeitig an denselben Dateien arbeiten, gibt es Konflikte. Mit Worktrees arbeitet jeder Agent in seinem eigenen Verzeichnis auf einem eigenen Branch. Die Zusammenführung passiert erst am Ende, kontrolliert und überprüfbar.

So erstellst du einen Worktree:

``` git worktree add ../feature-frontend feature/frontend git worktree add ../feature-backend feature/backend ```

Jetzt können zwei Claude Code Instanzen parallel arbeiten — eine im Frontend-Worktree, eine im Backend-Worktree.

Die CLAUDE.md-Datei ist das zentrale Steuerungsdokument. Für Multi-Agent-Workflows brauchst du:

Ein Beispiel für eine Projekt-CLAUDE.md:

```markdown # Projekt: SaaS Dashboard

Tech Stack - Frontend: React 19, Tailwind v4 - Backend: Next.js API Routes - Database: Supabase

Regeln - TypeScript strict mode - Jede Komponente bekommt eine eigene Datei - Tests sind Pflicht für Business-Logik - Keine `any` Types ```

Praktische Beispiele für Agent Orchestration

Aufgabe: Erstelle eine Landing Page mit Wartelisten-Funktion.

Fan-out: - Agent Frontend: Hero-Section, Feature-Grid, Pricing-Tabelle, Footer — alles responsive mit Tailwind - Agent Backend: Supabase-Tabelle für Warteliste, API-Route für Anmeldungen, E-Mail-Bestätigung - Agent Content: SEO-Texte, Meta-Tags, Open-Graph-Bilder

Fan-in: Hauptagent integriert Frontend + Backend, prüft die Verknüpfung und testet den Flow end-to-end.

Zeitersparnis: Statt 4-6 Stunden sequenziell — ca. 1,5 Stunden parallel.

Aufgabe: Refactore eine monolithische React-App in saubere Module.

Pipeline: 1. Agent Analyse: Scannt die Codebase, identifiziert Dependencies, erstellt einen Dependency-Graph 2. Agent Architektur: Plant die neue Modulstruktur basierend auf der Analyse 3. Agent Migration (parallelisiert): Mehrere Agenten migrieren jeweils ein Modul 4. Agent Testing: Schreibt und führt Tests aus, um sicherzustellen, dass nichts kaputt ist

Aufgabe: Blog-Artikel in 4 Sprachen erstellen.

Fan-out: - Agent DE: Schreibt den deutschen Artikel - Agent EN: Übersetzt und lokalisiert für den englischen Markt - Agent ES: Übersetzt und lokalisiert für den spanischen Markt - Agent SEO: Optimiert alle Versionen für Suchmaschinen

Best Practices für Agent Orchestration

Jeder Agent braucht einen eindeutigen Scope. Überlappende Zuständigkeiten führen zu Konflikten. Definiere für jeden Agenten:

• Was er tun soll (Scope)
• Was er nicht tun soll (Boundaries)
• Welche Dateien er anfassen darf (File Access)
• Wann er fertig ist (Definition of Done)

Gib jedem Agenten nur die Informationen, die er braucht. Ein Frontend-Agent braucht keine Datenbank-Schemas. Ein Test-Agent braucht keine Design-Entscheidungen. Weniger Kontext bedeutet bessere Ergebnisse.

Stelle sicher, dass jede Agent-Aufgabe idempotent ist — sie kann ohne Seiteneffekte wiederholt werden. Wenn ein Agent fehlschlägt, kannst du ihn einfach neu starten, ohne den Zustand des Gesamtprojekts zu korrumpieren.

Zwischen Fan-out und Fan-in sollte immer ein Review-Schritt liegen. Der Orchestrator (du oder ein Lead-Agent) prüft die Ergebnisse, bevor sie zusammengeführt werden. Das fängt Fehler früh ab.

Beginne nicht mit 10 parallelen Agenten. Starte mit einem Subagenten für eine klar definierte Aufgabe. Wenn das funktioniert, skaliere auf zwei, dann drei. Du lernst mit jedem Durchlauf, wie du Aufgaben besser schneidest.

Jeder Agent sollte dokumentieren, was er getan hat. In Claude Code passiert das automatisch über die Session-History. Bei komplexen Orchestrations lohnt es sich, die Ergebnisse jedes Agenten in einer Markdown-Datei zusammenzufassen.

Häufige Fehler bei der Agent Orchestration

Agent Orchestration hat Overhead. Für eine simple Bugfix-Aufgabe brauchst du keinen Multi-Agent-Workflow. Faustregel: Wenn die Aufgabe in unter 30 Minuten mit einem Agenten erledigt ist, nutze einen Agenten.

Wenn Agent A eine API baut und Agent B das Frontend dafür, müssen beide die gleiche API-Spezifikation kennen. Definiere Schnittstellen vor dem Fan-out — nicht danach.

Was passiert, wenn ein Agent fehlschlägt? Ohne Plan B blockiert der gesamte Workflow. Baue Fallbacks ein: Wenn ein Agent nach drei Versuchen nicht liefert, eskaliere an den Orchestrator.

Tools und Ressourcen

• Subagenten: Native Unterstützung für parallele Agenten
• Git Worktrees: Isolation für parallele Arbeit
• CLAUDE.md: Zentrale Steuerungsdatei
• MCP-Server: Erweitere Agenten mit externen Tools (Datenbanken, APIs, File Systems)
• Session History: Automatisches Logging aller Agent-Aktionen

• Projekte mit klar trennbaren Komponenten (Frontend/Backend/Tests)
• Refactoring großer Codebases
• Content-Produktion in mehreren Sprachen oder Formaten
• Code Reviews mit mehreren Prüfungs-Dimensionen
• Aufgaben, die mehr als 2 Stunden dauern würden

Agent Orchestration lernen

Agent Orchestration ist ein fortgeschrittenes Thema. Wenn du die Grundlagen von Claude Code bereits beherrschst, ist es der nächste logische Schritt, um deine Produktivität zu vervielfachen.

In den [Kursen der SixSides Academy](/de/kurse) lernst du Agent Orchestration hands-on — von einfachen Subagenten bis zu komplexen Multi-Agent-Workflows. Der [Kurs-Finder](/de/kurs-finder) hilft dir, den passenden Kurs für dein Level zu finden.

Für Teams, die Agent Orchestration im Unternehmen einführen wollen, bieten wir maßgeschneiderte [Workshops](/de/workshops) mit praxisnahen Szenarien aus eurem Arbeitsalltag.

Fazit

Agent Orchestration ist der Unterschied zwischen "KI als Tool nutzen" und "KI als Team führen". Es multipliziert deine Produktivität, weil du nicht mehr durch die Grenzen eines einzelnen Agenten limitiert bist.

Die Kernprinzipien sind einfach: klare Aufgabentrennung, minimaler Kontext, Review-Gates und inkrementelles Skalieren. Die Umsetzung erfordert Übung — aber die Investition zahlt sich bei jedem Projekt aus.

Starte jetzt: Schau dir die [Bundle-Angebote](/de/bundles) an, die Vibe Coding Grundlagen mit fortgeschrittener Agent Orchestration kombinieren.