Sub-Agent-Systeme

Ein Agent ist maechtig. Mehrere Agenten, die zusammenarbeiten, sind transformativ. Lernen Sie, Systeme zu bauen, in denen Agenten delegieren, zusammenarbeiten und sich selbst verbessern.

Was sind Sub-Agenten?

Ein Sub-Agent ist ein Agent, der von einem anderen Agenten fuer eine spezifische Teilaufgabe erzeugt wird:

Haupt-Agent (Orchestrator)
  +-- Sub-Agent 1: "Dieses Thema recherchieren"
  +-- Sub-Agent 2: "Tests fuer diesen Code schreiben"
  +-- Sub-Agent 3: "Die Implementierung reviewen"

Warum Sub-Agenten?

Jeder Sub-Agent kann ein anderes Modell nutzen (guenstig fuer Recherche, teuer fuer Coding)
Sub-Agenten laufen parallel -- schneller als sequentielle Ausfuehrung
Jeder Sub-Agent hat ein fokussiertes Kontextfenster -- keine Kontext-Verschmutzung
Ausfall eines Sub-Agenten laesst die anderen nicht abstuerzen

Das Orchestrator-Muster

Die gaengigste Multi-Agent-Architektur:

Nutzer-Anfrage
     |
+----------------+
| Orchestrator   |  Plant und delegiert
| (Tier 3-4)     |  Nutzt ein Mid-Tier-Modell
+-------+--------+
        |
   +----+----+----------+
   |    |    |           |
+----++----++----++--------+
| R1 || R2 || R3 || R4    |  Spezialisten-Agenten
|T5  ||T1  ||T5  ||T3     |  Jeder nutzt optimale Stufe
+----++----++----++--------+
   |    |    |           |
   +----+----+-----------+
        |
+----------------+
| Orchestrator   |  Kombiniert Ergebnisse
| (Tier 3-4)     |
+----------------+
        |
   Finale Antwort

Kostenoptimierung: Der Orchestrator nutzt ein Tier-3-4-Modell fuer die Planung. Nur der Sub-Agent, der tiefes Reasoning braucht, nutzt ein Tier-1-Modell. Einfache Teilaufgaben nutzen Tier 5-6.

Sub-Agenten in der Praxis

OpenCode implementiert Sub-Agenten mit seinem Agent-System:

## AGENTS.md -- Sub-Agent-Definitionen

### Recherche-Agent
- Modell: gpt-4o-mini (schnell, guenstig)
- Tools: Websuche, Datei lesen
- Aufgabe: Informationen sammeln, Ergebnisse zusammenfassen
- Ausgabe: strukturiertes Recherche-Briefing

### Implementierungs-Agent
- Modell: claude-sonnet-4 (starkes Coding)
- Tools: Datei lesen/schreiben, Terminal
- Aufgabe: Code basierend auf Recherche-Briefing schreiben
- Ausgabe: funktionierende Implementierung mit Tests

### Review-Agent
- Modell: claude-opus-4.6 (gruendliche Analyse)
- Tools: Datei lesen, Terminal (Tests ausfuehren)
- Aufgabe: Implementierung reviewen, Probleme finden
- Ausgabe: Freigabe oder Liste benoetigter Aenderungen

Die zentrale Erkenntnis: Jeder Agent hat seinen eigenen System-Prompt, Toolset und Modell -- optimiert fuer seine spezifische Rolle.

Selbstverbessernde Agent-Systeme

Das fortgeschrittenste Muster: Agenten, die sich selbst verbessern.

Die Verbesserungsschleife:

1. Agent fuehrt eine Aufgabe aus
2. Agent bewertet seine eigene Leistung
3. Agent identifiziert, was schiefgelaufen ist oder besser sein koennte
4. Agent aktualisiert seine eigenen Anweisungen (AGENTS.md, Prompts)
5. Naechste Aufgabe nutzt die verbesserten Anweisungen
6. Wiederholen

Praktisches Beispiel:

Sitzung 1:
  Agent schreibt eine Funktion mit einem Bug
  Tests finden den Bug
  Agent behebt ihn

Sitzung 2 (Selbstverbesserung):
  Agent reviewed Protokolle von Sitzung 1
  Entdeckt: "Ich vergesse oft Null-Checks bei optionalen Feldern"
  Aktualisiert AGENTS.md: "Always add null checks for optional parameters"

Sitzung 3:
  Agent schreibt eine Funktion MIT Null-Checks von Anfang an
  Tests bestehen beim ersten Versuch

Ein selbstverbesserndes System bauen

Eine praktische Implementierung:

Schritt 1: Alles protokollieren

// Nach jeder Agent-Sitzung eine Retrospektive speichern
const retro = {
  task: "Add user search endpoint",
  attempts: 3,
  errors: [
    "Missing null check on query parameter",
    "Forgot to add route to index.js"
  ],
  fix_patterns: [
    "Always validate query parameters",
    "Always register new routes in index.js"
  ],
  timestamp: new Date().toISOString()
};
await fs.writeFile('agent-retros/session-42.json', JSON.stringify(retro));

Schritt 2: Erkenntnisse periodisch zusammenfassen

Prompt: "Review the last 20 agent retrospectives.
Identify the top 5 recurring mistakes. For each, write
a concise rule that would prevent it. Update AGENTS.md
with these rules in the Pitfalls section."

Schritt 3: Verbesserung verifizieren Fehlerraten ueber die Zeit verfolgen. Wenn eine bestimmte Fehlerart nach Hinzufuegen einer Regel abnimmt, verbessert sich das System tatsaechlich.

Multi-Agent-Kommunikation

Wie Agenten miteinander kommunizieren:

Direktes Weiterreichen (einfachste Methode):

result_1 = await research_agent.run(task);
result_2 = await coding_agent.run(task, result_1);
result_3 = await review_agent.run(result_2);

Message Queue (skalierbar):

Recherche-Agent -> veroeffentlicht Ergebnisse in Queue
Coding-Agent    -> abonniert Ergebnisse, veroeffentlicht Code
Review-Agent    -> abonniert Code, veroeffentlicht Reviews

Gemeinsamer Workspace (dateibasiert):

Alle Agenten lesen/schreiben in ein gemeinsames Verzeichnis:
  workspace/
    research.md     <- Recherche-Agent schreibt
    implementation/ <- Coding-Agent schreibt
    review.md       <- Review-Agent schreibt
    plan.md         <- Orchestrator liest alles, aktualisiert Plan

Das gemeinsame Workspace-Muster ist das einfachste und am besten debugbare. Sie koennen jede Datei inspizieren, um zu verstehen, was jeder Agent produziert hat.

Wann Sub-Agenten NICHT nutzen

Sub-Agenten fuegen Komplexitaet hinzu. Nutzen Sie sie nur, wenn der Nutzen die Kosten rechtfertigt:

Sub-Agenten nutzen, wenn:

Verschiedene Teilaufgaben verschiedene Modelle benoetigen
Teilaufgaben parallel laufen koennen fuer Geschwindigkeit
Jede Teilaufgabe komplex genug ist, um ein Kontextfenster zu fuellen
Sie unterschiedliche Toolsets pro Teilaufgabe benoetigen

Sub-Agenten nicht nutzen, wenn:

Ein einzelner Agent mit dem richtigen Modell die gesamte Aufgabe bewaeltigen kann
Der Orchestrierungs-Overhead die gesparte Zeit uebersteigt
Die Aufgabe sequentiell ist und jeder Schritt vom vorherigen abhaengt
Sie Komplexitaet der Architektur zuliebe hinzufuegen

Die Kosten von Sub-Agenten:

Jeder Agent-Aufruf hat Latenz-Overhead (2-5 Sekunden)
Orchestrator-Tokens summieren sich (Planung, Ergebnisse kombinieren)
Multi-Agent-Fehler zu debuggen ist schwerer als bei einem einzelnen Agenten
Mehr bewegliche Teile = mehr Fehlermoeglichkeiten

Beginnen Sie mit einem Agenten. Teilen Sie erst in Sub-Agenten auf, wenn Sie auf eine klare Limitation stossen, die Sub-Agenten loesen.

---quiz question: Was ist der Hauptvorteil der Nutzung von Sub-Agenten mit verschiedenen Modellstufen? options:

{ text: "Sub-Agenten sind immer schneller als einzelne Agenten", correct: false }
{ text: "Jeder Sub-Agent kann das optimale Modell fuer seine spezifische Aufgabe nutzen, was Kosten senkt bei gleichbleibender Qualitaet", correct: true }
{ text: "Sub-Agenten brauchen keine System-Prompts", correct: false } feedback: Sub-Agenten ermoeglichen Kostenoptimierung durch Zuordnung jeder Teilaufgabe zu ihrem idealen Modell -- ein guenstiges Tier-5-6-Modell fuer Recherche, ein teures Tier 1 fuer komplexes Reasoning und ein Mid-Tier fuer alles andere.

---quiz question: Wie funktionieren selbstverbessernde Agent-Systeme? options:

{ text: "Sie trainieren das zugrunde liegende LLM automatisch nach", correct: false }
{ text: "Sie protokollieren Fehler, identifizieren Muster und aktualisieren ihre eigenen Anweisungen (AGENTS.md), um wiederkehrende Fehler zu verhindern", correct: true }
{ text: "Sie laden Updates aus dem Internet herunter", correct: false } feedback: Selbstverbessernde Systeme protokollieren ihre Fehler, analysieren Muster und aktualisieren ihre Anweisungsdateien (wie AGENTS.md), damit zukuenftige Sitzungen von vergangenen Fehlern profitieren -- was einen tugendhaften Verbesserungszyklus schafft.

---quiz question: Wann sollten Sie Sub-Agenten NICHT nutzen? options:

{ text: "Wenn verschiedene Teilaufgaben verschiedene Modelle benoetigen", correct: false }
{ text: "Wenn ein einzelner Agent die gesamte Aufgabe bewaeltigen kann und der Orchestrierungs-Overhead die gesparte Zeit uebersteigen wuerde", correct: true }
{ text: "Bei der Arbeit mit Open-Source-Modellen", correct: false } feedback: Sub-Agenten fuegen Latenz, Token-Kosten und Debugging-Komplexitaet hinzu. Nutzen Sie sie nur, wenn ein einzelner Agent auf klare Limitationen stoesst -- wie unterschiedliche Modelle, parallele Ausfuehrung oder isolierte Kontextfenster fuer verschiedene Teilaufgaben.