Praxisregeln für Multi-Agent Systeme

Wissen

Multi-Agent Systeme klingen auf dem Papier elegant. In der Praxis wirst du mit Problemen konfrontiert, die bei einzelnen Agents nicht existieren: Agents, die sich gegenseitig blockieren. Explodierende Kosten. Fehler, die sich durch Ketten von Agents propagieren und am Ende nicht mehr nachvollziehbar sind.

Die Single-Agent-First-Regel

Starte immer mit einem einzelnen Agent und skaliere erst, wenn du an seine Grenzen stößt. Konkrete Trigger für Multi-Agent:

• Der System-Prompt wird zu lang (>3000 Tokens) und der Agent macht zunehmend Fehler, weil er zu viele Rollen gleichzeitig spielen soll
• Die Tool-Liste wird zu groß (>10 Tools) und der Agent wählt regelmäßig das falsche Tool
• Die Aufgabe hat natürliche Parallelisierung -- z.B. 5 unabhängige Analysen, die gleichzeitig laufen könnten
• Checks and Balances sind geschäftskritisch -- ein Agent erstellt, ein anderer prüft

Wann ein einzelner Agent reicht

• Die Aufgabe ist linear (Schritt A, dann B, dann C)
• Du brauchst maximal 5-6 Tools
• Das Context Window reicht für alle relevanten Informationen
• Fehler sind nicht kritisch (z.B. ein Entwurf, den ein Mensch reviewt)

Kommunikationsmuster

Direkte Kommunikation -- Agent A sendet eine Nachricht an Agent B:

Agent A → "Hier ist meine Analyse: ..." → Agent B

• Vorteil: Klar nachvollziehbar, wer was wem gesagt hat
• Nachteil: Wird bei vielen Agents schnell n-zu-n (quadratische Komplexität)

Shared State -- Alle Agents lesen und schreiben in einen gemeinsamen Zustand:

Agent A → [Shared State] ← Agent B
                ↑
            Agent C

• Vorteil: Agents sind entkoppelt, einfach hinzuzufügen/entfernen
• Nachteil: Race Conditions, widersprüchliche Schreibvorgänge

Empfehlung: Unter 4 Agents direkte Kommunikation, 4-10 Agents Shared State mit klaren Schreibrechten, 10+ Agents Event-basierte Kommunikation mit Message Queue.

Die goldenen Regeln

1. Single-Agent-First -- Skaliere erst zu Multi-Agent, wenn ein einzelner Agent nachweislich nicht reicht
2. Modell-Mix -- Nutze teure Modelle nur dort, wo Reasoning nötig ist
3. Validation Gates -- Prüfe Ergebnisse zwischen Agent-Übergängen
4. Budget-Limits -- Setze harte Kosten-Grenzen pro Agent und Gesamtsystem
5. Logging -- Protokolliere jede Agent-Entscheidung und jeden Tool-Call
6. Kill-Switch -- Jedes System braucht einen Notausschalter

Verstehen

Das Kaskaden-Problem

Der gefährlichste Fehler in Multi-Agent Systemen: Error Cascading. Ein Agent produziert einen subtilen Fehler. Der nächste Agent baut darauf auf. Der übernächste verstärkt den Fehler. Am Ende ist das Ergebnis komplett falsch, und du weißt nicht, wo es anfing.

Strategien gegen Error Cascading

1. Validation zwischen Agents

Zwischen jedem Agent-Übergang: Prüfe das Ergebnis, bevor es weitergeht.

result = agent_a.run(task)

# Validation Gate
if not validate_result(result):
    # Retry oder Fallback
    result = agent_a.run(task, retry=True)
    if not validate_result(result):
        return escalate_to_human(result)

agent_b.run(result)

2. Checkpoints und Rollback

Speichere den Zustand nach jedem erfolgreichen Agent-Schritt. Bei einem Fehler kannst du auf den letzten guten Zustand zurückrollen, statt von vorne anzufangen.

3. Independent Verification

Bei kritischen Ergebnissen: Ein separater Agent prüft das Ergebnis unabhängig (Ensemble-Prinzip). Das kostet extra, verhindert aber die Propagation von Fehlern.

4. Timeout und Circuit Breaker

Wenn ein Agent zu lange braucht oder zu viele Fehler produziert, schalte ihn ab (Circuit Breaker Pattern) und nutze einen Fallback-Agent oder eskaliere.

Das Kosten-Multiplier-Problem

Jeder Agent verbraucht Tokens. Ein Multi-Agent System mit 5 Agents kann leicht das 5-10-fache eines einzelnen Agents kosten -- nicht nur wegen der Agent-Calls selbst, sondern auch wegen der Kommunikation zwischen Agents.

Kostenoptimierung

1. Modell-Strategie pro Agent

2. Prompt Caching nutzen

Wenn mehrere Agents denselben System-Prompt oder dieselben Referenzdokumente nutzen, aktiviere Prompt Caching. Bei Anthropic kostet ein gecachter Prompt 90% weniger.

3. Budgets pro Agent und Gesamtsystem

agent_config = {
    "max_tokens_per_call": 4000,
    "max_calls_per_task": 10,
    "max_cost_per_task_usd": 0.50,
    "total_system_budget_usd": 5.00
}

4. Ergebnisse cachen

Wenn ein Agent dieselbe Frage mehrfach stellt, cache die Antwort. Das spart nicht nur Kosten, sondern auch Latenz.

Anwenden

Reflektieren

Die goldenen Regeln -- Single-Agent-First, Modell-Mix, Validation Gates, Budget-Limits, Logging und Kill-Switch -- sind dein Kompass für produktive Multi-Agent Systeme. Sie helfen dir, die Balance zwischen Autonomie und Kontrolle zu finden. Im Quiz testest du dein Gesamtverständnis dieses Moduls.