Zuverlässige KI-Agenten: Best Practices für Multi-Agenten-Systeme

Inhalt

Multi-Agenten-Systeme auf Basis von Large Language Models (LLMs) verteilen eine komplexe Aufgabe auf spezialisierte Agenten, die gemeinsam planen, schlussfolgern und handeln. In der Praxis sind sie einem gut gebauten einzelnen Agenten aber oft nicht überlegen. Dieser Beitrag erklärt anhand der Fehler-Taxonomie aus dem Paper "Why Do Multi-Agent LLM Systems Fail?", woran das liegt, und stellt dann die Design-Regeln vor, die gegen die einzelnen Fehler helfen: klare Rollen, strukturierte Kommunikation, Prüfung bei jedem Schritt und der Start mit dem einfachsten System, das funktioniert.

Das Paper hat über 150 Aufgaben in fünf verbreiteten Multi-Agenten-Frameworks untersucht. Ergebnis: Obwohl diese Frameworks immer häufiger eingesetzt werden, bringen sie in Standard-Benchmarks im Vergleich zu gut gebauten Einzel-Agenten kaum Verbesserungen. Die Autorinnen und Autoren haben 14 verschiedene Fehlerarten gefunden, die die Zuverlässigkeit untergraben.

Das deckt sich mit dem, was wir bei Pondhouse Data in vielen Multi-Agenten-Systemen für unsere Kunden beobachtet haben. Ein einfaches, vielversprechendes MVP mit einem einzelnen Agenten wächst schnell zu einem komplexen, fragilen System mit mehreren Agenten, das nicht liefert, was es soll.

Der Grund: Agenten interagieren miteinander. Diese Interaktionen verstärken die Schwächen jedes einzelnen Agenten und erzeugen Fehler, die schwer vorherzusagen und schwer zu diagnostizieren sind. Bessere Prompts allein helfen dagegen nicht, denn die Probleme liegen darin, wie Agenten kommunizieren, wie ihre Schlussfolgerungen zusammenpassen und wie das System orchestriert ist.

Warum Multi-Agenten-Systeme mit LLMs scheitern

Das Paper von Mert Cemri, Melissa Z. Pan, Shuyi Yang, Lakshya A. Agrawal, Bhavya Chopra, Rishabh Tiwari, Kurt Keutzer, Aditya Parameswaran, Dan Klein, Kannan Ramchandran, Matei Zaharia, Joseph E. Gonzalez und Ion Stoica ordnet die Fehlerarten, die in verschiedenen Multi-Agenten-Frameworks auftreten, in eine strukturierte Taxonomie ein. Das ist ein guter Ausgangspunkt, um Systeme zu bauen, die diese Fehler vermeiden.

So wurde die Studie durchgeführt

Die Studie "Why Do Multi-Agent LLM Systems Fail?" hat Fehlermuster mit einer nachvollziehbaren Methode erfasst und eingeordnet:

• Untersuchung von fünf verbreiteten Open-Source-Frameworks für Multi-Agenten-Systeme (MetaGPT, ChatDev, HyperAgent, AppWorld, AG2)
• Analyse von über 150 Aufgaben, die typisch für den Einsatzzweck der Systeme sind
• Aufgaben aus Softwareentwicklung, Service-Anwendungen und komplexen Denkaufgaben
• Annotation durch menschliche Fachleute mit einem Cohens Kappa von 0,88, also hoher Übereinstimmung zwischen den Bewertenden
• Validierung sowohl durch manuelle Durchsicht als auch automatisch per LLM-as-a-Judge

Dieselben Fehlermuster zeigten sich in unterschiedlichen Architekturen. Das spricht für grundsätzliche Probleme von Multi-Agenten-Designs und gegen Bugs in einem bestimmten Framework.

Drei Ebenen von Agenten-Fehlern

Damit man mit den Fehlerarten aus dem Paper leichter arbeiten kann, ordnen wir sie drei Ebenen zu (diese Einteilung stammt von uns, das Paper selbst nutzt die drei Kategorien, die weiter unten beschrieben sind):

1. Fehler einzelner Agenten: Grenzen innerhalb eines einzelnen LLM-Agenten, darunter:

   • Probleme beim Prompt Engineering (unklare Anweisungen, Empfindlichkeit gegenüber Formulierungen)
   • Probleme mit dem Kontext (begrenzte Kontextlänge, Halluzinationen)
   • Fehler beim Schlussfolgern (falsche Folgerungen, schwache Planung)
   • Probleme beim Befolgen von Anweisungen (vorgegebene Aktionen werden nicht ausgeführt)

2. Fehler im Zusammenspiel mehrerer Agenten: Probleme, die aus der Zusammenarbeit entstehen:

   • Kommunikationsabbrüche (falsch verstandene Nachrichten, uneinheitliche Formate)
   • Probleme bei der Zusammenarbeit (Zielkonflikte, doppelte Arbeit)
   • Ineffizienter Ressourcenverbrauch (zu viele Tokens, hohe Latenz)

3. Fehler auf Systemebene: Fehler, die aus der Architektur des Systems entstehen:

   • Emergente Fehler (unvorhersehbare Fehler aus dem Zusammenspiel der Komponenten)
   • Kumulative Fehler (Fehler, die sich fortpflanzen und verstärken)
   • Probleme zwischen Mensch und Agent (Aufgabe anders verstanden als gemeint)

Fehlermuster, die in allen Frameworks auftreten

Die 14 Fehlerarten aus dem Paper treten in mehreren Frameworks auf. Sie lassen sich so gruppieren:

• Verstöße gegen Aufgaben- und Rollenvorgaben (Agenten ignorieren festgelegte Einschränkungen)
• Probleme mit dem Kontext (Verlust des Verlaufs, Neustart des Gesprächs)
• Probleme im Informationsfluss (Informationen werden zurückgehalten oder Eingaben ignoriert)
• Mängel bei der Prüfung (unvollständige oder falsche Prüfung)
• Fehler im Aufgabenverlauf (Wiederholungen, vorzeitiger Abbruch, Abdriften)

Diese Fehler sind nicht zufällig. Sie folgen erkennbaren Mustern, und deshalb lassen sie sich mit Änderungen an der Architektur systematisch angehen.

Fehlerarten einzelner Agenten

Bevor Sie das Zusammenspiel der Agenten optimieren, sollten Sie die Fehler innerhalb jedes Agenten beheben. Fehler eines einzelnen Agenten wandern oft durch die Interaktionen weiter und werden dabei zu größeren Problemen, deren Ursache schwer zu finden ist.

Probleme beim Prompt Engineering

Schwache Prompts sind eine Hauptursache für Fehler einzelner Agenten, oft schon bevor überhaupt mehrere Agenten zusammenarbeiten.

Technische Ursachen:

• Mehrdeutige Anweisungen ohne konkrete Einschränkungen oder Abnahmekriterien
• Überladene Prompts mit widersprüchlichen Zielen
• Empfindlichkeit gegenüber Formulierung und Formatierung des Prompts
• Fehlende Kontextinformationen, die für die Aufgabe nötig sind

Beobachtete Fehler:

• Die Fehlerart "Disobey Task Spec", bei der Agenten ausdrückliche Vorgaben ignorieren oder falsch verstehen
• Ergebnisse, die manche Vorgaben erfüllen und andere verletzen
• Schwankende Leistung bei ähnlichen Aufgaben, weil der Prompt anders formuliert ist

Wie man sie erkennt:

• Prüf-Agenten, die Ergebnisse gegen die ausdrücklichen Anforderungen validieren
• Automatisierte Tests mit Prompt-Varianten, die zeigen, wie empfindlich der Agent auf Formulierungen reagiert
• Eine Checkliste, mit der man Prompts vor der Umsetzung auf Vollständigkeit prüft

Probleme mit dem Kontext

LLMs haben eingebaute Grenzen im Umgang mit Kontext, und diese Grenzen machen sie in Multi-Agenten-Systemen weniger zuverlässig.

Technische Ursachen:

• Feste Größe des Kontextfensters (Token-Limits)
• Ungleichmäßige Aufmerksamkeit für Informationen im Kontextfenster
• Der Zustand lässt sich über lange Interaktionen nicht genau verfolgen und aktualisieren
• Neigung, bei unvollständigen Informationen Kontext zu halluzinieren oder zu erfinden

Beobachtete Fehler:

• "Loss of History": Agenten vergessen frühere Gesprächsinhalte oder Entscheidungen
• "Conversation Reset": Agenten beginnen eine Interaktion neu, ohne an das Bisherige anzuknüpfen
• Erfundene Informationen, wenn nur ein Teil der Daten vorliegt
• Widersprüchliche Bezüge auf bereits festgestellte Fakten

Wie man sie erkennt:

• Überwachen, wie stark das Kontextfenster ausgelastet ist
• Testen, ob Informationen über mehrere Gesprächsrunden erhalten bleiben
• Widersprüche zwischen aktuellen und früheren Aussagen erkennen
• Aussagen bis zur Quellinformation zurückverfolgen

Grenzen beim Schlussfolgern

Schwächen im Schlussfolgern setzen einem Agenten eine harte Obergrenze.

Technische Ursachen:

• Schwaches logisches Schließen, besonders über mehrere Schritte
• Neigung zu assoziativem statt kausalem Denken
• Grenzen bei quantitativen oder mathematischen Operationen
• Probleme mit zeitlichen Abläufen und Reihenfolgen

Beobachtete Fehler:

• "Reasoning Mismatch": Die Aktionen folgen nicht logisch aus der genannten Begründung
• Falsche Schlüsse, obwohl die richtigen Informationen vorliegen
• Abdriften von der Aufgabe, wenn komplexe Gedankenketten nötig sind
• Logische Widersprüche in den eigenen Ergebnissen werden nicht erkannt

Wie man sie erkennt:

• Die Gedankenschritte (Reasoning Traces) Schritt für Schritt prüfen
• Folgerungsketten mit bekannten logischen Mustern vergleichen
• Gedankensprünge ohne Begründung in den Schlussfolgerungen des Agenten finden
• Mit schwierigen Denkaufgaben testen, deren Lösung bekannt ist

Probleme beim Befolgen von Anweisungen

LLMs fällt es oft schwer, Anweisungen genau zu befolgen, besonders wenn es um strukturierte Ausgaben oder feste Abläufe geht.

Technische Ursachen:

• Neigung, auf gängige Muster zurückzufallen, statt die Anweisung genau zu befolgen
• Schwierigkeiten, Anweisungen über lange Ausgaben hinweg einzuhalten
• Vorgaben werden während der Aufgabe uneinheitlich angewendet
• Grenzen beim Verstehen und Umsetzen formaler Spezifikationen

Beobachtete Fehler:

• "Step Repetition": Agenten wiederholen ohne Not bereits erledigte Schritte
• Mehrteilige Anweisungen werden nur teilweise umgesetzt
• Verstöße gegen das vorgegebene Format bei strukturierten Ausgaben
• "Task Derailment": Agenten entfernen sich nach und nach vom vorgegebenen Ziel

Wie man sie erkennt:

• Ausgaben automatisch gegen die strukturellen Anforderungen prüfen
• Schritte mitprotokollieren, um Wiederholungen oder Auslassungen zu finden
• Bewerten, wie gut die Ausgabe die ausdrücklichen Anweisungen erfüllt
• Messen, wie weit sich der Agent vom ursprünglichen Ziel entfernt

Fehler einzelner Agenten vermeiden

Gegen Fehler einzelner Agenten helfen systematische Maßnahmen im Agenten-Design:

1. Strukturierte Prompts:

   • Ausdrückliche Prüfkriterien in den Prompt schreiben
   • Bei komplexen Denkaufgaben Chain-of-Thought-Prompting nutzen
   • Formatvorlagen verwenden, die die Teile der Antwort klar trennen
   • Beispiele einbauen, die die erwartete Argumentation zeigen

2. Besseres Kontext-Management:

   • Den Kontext zusammenfassen, um lange Interaktionen zu bewältigen
   • Kontext priorisieren, damit wichtige Informationen im Fenster bleiben
   • Für dauerhafte Informationen externe Speicher nutzen (siehe unseren Beitrag dazu, wie man einem KI-Agenten ein Gedächtnis gibt, auf Englisch)
   • Den Zustand ausdrücklich mitführen

3. Prüfmechanismen:

   • Vor der Ausgabe einen Schritt zur Selbstprüfung einbauen
   • Komplexe Aufgaben in Teile zerlegen, die sich einzeln prüfen lassen
   • Das Format strukturierter Ausgaben validieren
   • Gedankenschritte auf logische Konsistenz prüfen

Fehler einzelner Agenten sind oft die Vorstufe zu den komplexeren Problemen im Zusammenspiel mehrerer Agenten, um die es im nächsten Abschnitt geht.

Fehler im Zusammenspiel mehrerer Agenten

Sobald mehrere LLM-Agenten interagieren, entstehen neue Fehlerarten, die über die Grenzen jedes einzelnen Agenten hinausgehen. Diese Fehler schaden Leistung und Zuverlässigkeit auch dann, wenn jeder Agent für sich gut funktioniert.

Kommunikationsfehler

Die Weitergabe von Informationen zwischen Agenten schafft Schwachstellen, an denen das ganze System brechen kann.

Technische Ursachen:

• Uneinheitliche Formate und Strukturen der Nachrichten zwischen Agenten
• Unterschiedlicher Detail- und Abstraktionsgrad in der Kommunikation
• Unvollständige Informationen bei der Übergabe von einem Agenten zum nächsten
• Parallele Gespräche, die den Kontext zersplittern

Beobachtete Fehler:

• "Withholding Info": Agenten geben wichtige Informationen nicht weiter
• Falsch verstandene Nachrichten führen zu unpassenden Aktionen
• Informationen gehen bei der Verarbeitung nacheinander verloren
• Verstöße gegen das Kommunikationsprotokoll brechen das erwartete Zusammenspiel

Wie man sie erkennt:

• Den Informationsfluss über die Grenzen der Agenten hinweg verfolgen
• Überwachen, ob das Kommunikationsprotokoll eingehalten wird
• Prüfen, ob Nachrichten alle für die Aufgabe nötigen Informationen enthalten
• Semantisch analysieren, ob die Nachrichten zwischen Agenten zusammenpassen

Probleme bei der Zusammenarbeit und Zielkonflikte

Wenn mehrere Agenten mit spezialisierten Rollen auf ein gemeinsames Ziel hinarbeiten, gibt es häufig Abstimmungsprobleme.

Technische Ursachen:

• Unvollständige oder mehrdeutige Rollendefinitionen mit unscharfen Grenzen
• Agenten optimieren auf unterschiedliche Ziele
• Schlechte Zerlegung der Aufgabe, sodass Zuständigkeiten fehlen
• Keine Regeln, welche Entscheidung bei einem Konflikt Vorrang hat

Beobachtete Fehler:

• "Disobey Role Spec": Agenten handeln außerhalb ihrer festgelegten Zuständigkeit
• Mehrere Agenten bearbeiten doppelt dieselben Teilaufgaben
• "Ignore Input": Agenten übergehen die Beiträge anderer Agenten
• Widersprüchliche Ergebnisse, die erst zusammengeführt werden müssen

Wie man sie erkennt:

• Rollengrenzen analysieren, um Überschreitungen zu finden
• Doppelte Beiträge in den Ausgaben der Agenten erkennen
• Widersprüchliche Entscheidungen in gemeinsamen Ergebnissen finden
• Verfolgen, wie stark die Eingaben eines Agenten die anderen beeinflussen

Ineffiziente Interaktionen und Ressourcenverbrauch

Multi-Agenten-Architekturen erzeugen oft erheblichen Overhead. Das kostet Leistung und treibt die Betriebskosten.

Technische Ursachen:

• Zu viele Nachrichten zwischen den Agenten
• Derselbe Kontext wird von mehreren Agenten verarbeitet
• Agenten werden für Aufgaben aufgerufen, die ein einzelner Agent erledigen könnte
• Wartezeiten bei der Synchronisation in sequenziellen Pipelines

Beobachtete Fehler:

• Hoher Token-Verbrauch im Verhältnis zur Komplexität der Aufgabe
• Höhere Latenz durch Abhängigkeiten in der Reihenfolge
• Rechenaufwand durch wiederholtes Laden des Kontexts
• Abnehmender Nutzen mit jedem weiteren Agenten

Wie man sie erkennt:

• Token-Verbrauch pro Agent und für das ganze System analysieren
• Die Latenz über die Interaktionen der Agenten hinweg messen
• Den Mehrwert jedes einzelnen Agenteneinsatzes messen
• Mit der Leistung eines einzelnen Agenten als Basis vergleichen

Verstärkung der Fehler einzelner Agenten

Interaktionen zwischen Agenten verstärken meist die Fehler einzelner Agenten, und die Fehler pflanzen sich kaskadenartig durch das System fort.

Technische Ursachen:

• Fehler pflanzen sich durch nacheinander ablaufende Interaktionen fort
• Halluzinationen oder Denkfehler summieren sich über mehrere Agenten
• Zwischen den Agenten werden Fehler weder erkannt noch korrigiert
• Der Kontext verschlechtert sich durch wiederholtes Zusammenfassen und Weitergeben

Beobachtete Fehler:

• "Task Derailment", beschleunigt durch die Interaktion mehrerer Agenten
• Falsche Ergebnisse wirken durch scheinbaren Konsens sicherer, als sie sind
• Denkfehler summieren sich durch die Spezialisierung der Agenten
• Informationen werden bei der Weitergabe verzerrt

Wie man sie erkennt:

• Die Fortpflanzung von Fehlern durch die Interaktionen verfolgen
• Konsistenz über die Grenzen der Agenten hinweg prüfen
• Fakten an jeder Übergabe zwischen Agenten prüfen
• Messen, wie weit das Ergebnis von der ursprünglichen Aufgabenstellung abweicht

Fehler im Zusammenspiel vermeiden

Gegen Fehler im Zusammenspiel helfen Änderungen an der Architektur, die Kommunikation und Koordination regeln:

1. Strukturierte Kommunikationsprotokolle:

   • Einheitliche Nachrichtenformate mit ausdrücklicher Schema-Validierung verwenden
   • Vorlagen für den Informationsaustausch so gestalten, dass wichtige Daten immer weitergegeben werden
   • Formale Übergabeprozesse mit Prüfschritten festlegen
   • Die gesamte Kommunikation zentral protokollieren, um Fehler zu finden

2. Klare Rollen und Zuständigkeiten:

   • Die Grenzen jedes Agenten mit klarer Entscheidungsbefugnis festlegen
   • Regeln für Konflikte bei überlappenden Zuständigkeiten einführen
   • Kritische Entscheidungen hierarchisch überwachen
   • Den Kontext pro Rolle verwalten, um Doppelungen zu vermeiden

3. Effizienz:

   • Agenten je nach Bedarf der Aufgabe dynamisch aufrufen
   • Gemeinsame Kontextspeicher nutzen, um doppelte Verarbeitung zu reduzieren
   • Unabhängige Teilaufgaben parallel ausführen
   • Faustregeln für die passende Zahl von Agenten je Aufgabentyp entwickeln

4. Fehlerbehandlung über Agentengrenzen hinweg:

   • Agenten die Arbeit der anderen gegenseitig prüfen lassen
   • Ausdrückliche Abläufe für das Erkennen und Korrigieren von Fehlern festlegen
   • Feedbackschleifen für laufende Verbesserung einbauen
   • Die Sicherheit (Confidence) der Ausgaben bewerten, um mögliche Fehler zu markieren

Fehler auf Systemebene

Neben den Grenzen einzelner Agenten und den direkten Fehlern im Zusammenspiel zeigen Multi-Agenten-Systeme emergentes Verhalten, das zu Fehlern auf Systemebene führt. Einfache Erkennungsmethoden übersehen diese oft, man muss das System als Ganzes analysieren.

Emergente Fehler

Emergente Fehler lassen sich keiner einzelnen Komponente zuordnen. Sie entstehen aus dem Zusammenspiel der Komponenten in der Architektur.

Technische Ursachen:

• Nichtlineare Wechselwirkungen zwischen mehreren Agenten und Komponenten
• Feedbackschleifen, die kleine Fehler zu großen Ausfällen verstärken
• Inkonsistente Zustände in verteilten Systemkomponenten
• Interaktionsmuster, mit denen beim Systemdesign niemand gerechnet hat

Beobachtete Fehler:

• Das System schwankt, weil Agenten Entscheidungen immer wieder rückgängig machen
• Deadlocks, in denen Agenten gegenseitig auf ihre Ausgaben warten
• Das System erzeugt immer verschachteltere Lösungen
• Die Leistung sinkt, ohne dass sich eine bestimmte Komponente als Ursache finden lässt

Wie man sie erkennt:

• Das Verhalten des gesamten Systems überwachen, um Muster zu erkennen
• Die Leistung über verschiedene Ausführungspfade statistisch auswerten
• Simulationstests mit gezielt eingeschleusten Fehlern
• Vergleich mit Referenzimplementierungen

Kumulative Fehler

Kumulative Fehler bauen sich nach und nach aus kleinen Fehlern auf, die sich über die Zeit oder über viele Interaktionsschritte summieren.

Technische Ursachen:

• Fehlende Fehlerkorrektur, sodass kleine Fehler weiterwandern
• Präzisionsverlust über aufeinanderfolgende Verarbeitungsschritte
• Der Kontext driftet in langen Interaktionen allmählich ab
• Das Ziel verschiebt sich über mehrere Entscheidungspunkte hinweg Schritt für Schritt

Beobachtete Fehler:

• Die Qualität der Ausgaben sinkt über mehrere Gesprächsrunden immer weiter
• Die Ergebnisse entfernen sich über aufeinanderfolgende Teilaufgaben immer weiter von der Aufgabenstellung
• Fehler verstärken sich durch wiederholtes Zusammenfassen oder Umformen
• Kleine Denkfehler summieren sich zu deutlich falschen Schlüssen

Wie man sie erkennt:

• Fehlerraten über den Verlauf der Interaktionen hinweg auswerten
• An kritischen Stellen im Prozess gegen bekannte richtige Ergebnisse (Ground Truth) prüfen
• Während der Ausführung messen, wie weit das System von der ursprünglichen Vorgabe abweicht
• Die Qualität über den zeitlichen Verlauf der Interaktion vergleichen

Probleme zwischen Mensch und Agent

Auch die Schnittstelle zwischen Menschen und Multi-Agenten-Systemen bietet weitere Möglichkeiten zu scheitern.

Technische Ursachen:

• Die Absicht des Menschen und die formale Aufgabenstellung passen nicht zusammen
• Menschen können komplexe Interaktionen zwischen Agenten kaum wirksam überwachen
• Entscheidungen der Agenten sind schwer zu erklären
• Was das System kann und was Menschen erwarten, klafft auseinander

Beobachtete Fehler:

• "Fail Clarify": Agenten fragen bei mehrdeutigen Anweisungen nicht nach
• Menschliches Feedback wird in interaktiven Abläufen falsch verstanden
• Zu wenig Transparenz, als dass Menschen wirksam eingreifen könnten
• Das Fachwissen der Menschen fließt nicht ein

Wie man sie erkennt:

• Die Zufriedenheit der Menschen mit den Ergebnissen messen
• Auswerten, wie oft Menschen im Betrieb eingreifen müssen
• Rückfragen der Agenten über verschiedene Interaktionstypen hinweg verfolgen
• Bewerten, wie gut die Agenten ihre Entscheidungen begründen

Fehler im Systemdesign

Architekturentscheidungen in einem Multi-Agenten-System können strukturelle Schwächen erzeugen, die die Gesamtleistung beeinträchtigen.

Technische Ursachen:

• Ungünstige Topologie der Agenten mit unnötigen Abhängigkeiten
• Zu wenig Spezialisierung, sodass Rollen verschwimmen
• Hohe Komplexität ohne entsprechenden Leistungsgewinn
• Orchestrierung, die nicht zur Aufgabe passt

Beobachtete Fehler:

• Engpässe in sequenziellen Architekturen
• Der Koordinationsaufwand frisst den Nutzen der Spezialisierung auf
• Starre Architekturen, die sich nicht an wechselnde Anforderungen anpassen
• Fehler in der Orchestrierung komplexer Agenten-Netzwerke

Wie man sie erkennt:

• Die Leistung der Architektur modellieren und Engpässe finden
• Alternative Topologien der Agenten im Vergleich testen
• Den Mehrwert jeder Komponente der Architektur analysieren
• Das Verhältnis von Komplexität zu Leistung bewerten

Fehler auf Systemebene vermeiden

Gegen Fehler auf Systemebene helfen Maßnahmen in der Architektur, die das Verhalten des ganzen Systems betrachten:

1. Monitoring und Analyse auf Systemebene:

   • Durchgängige Telemetrie einbauen, um die Leistung über das ganze System zu verfolgen (Werkzeuge wie Langfuse oder Opik (auf Englisch) zeichnen jeden LLM-Aufruf als Trace auf)
   • Anomalien im emergenten Verhalten automatisch erkennen
   • Simulationsumgebungen bauen, in denen sich Grenzfälle kontrolliert testen lassen
   • Gegen Basis-Implementierungen benchmarken

2. Fehlerkorrektur und Wiederherstellung:

   • An regelmäßigen Checkpoints gegen die Vorgaben prüfen
   • Bei Teilausfällen kontrolliert mit eingeschränktem Funktionsumfang weiterarbeiten
   • Bekannte Fehlermuster automatisch beheben
   • Feedback-Mechanismen einbauen, die verhindern, dass sich Fehler aufsummieren

3. Human in the Loop:

   • Unsicherheit ausdrücklich signalisieren, damit ein Mensch eingreifen kann (die Workflows im Microsoft Agent Framework unterstützen Checkpoints und Human-in-the-Loop-Schritte, die einen Prozess anhalten, bis eine Person entscheidet)
   • Zwischenergebnisse sichtbar machen, damit laufend kontrolliert werden kann
   • Strukturierte Feedbackkanäle für Fachleute schaffen
   • Entscheidungen des Systems erklären

4. Einfachere Architektur:

   • Ockhams Rasiermesser auf das Systemdesign anwenden und unnötige Komplexität vermeiden
   • Modulare Architekturen bauen, in denen Fehler auf einen Bereich begrenzt bleiben
   • Die Komplexität nur so weit steigern, wie die Aufgabe es verlangt
   • Von Anfang an auf Beobachtbarkeit (Observability) und Testbarkeit auslegen

Fehler auf Systemebene sind der schwierigste Teil beim Design von Multi-Agenten-Systemen. Gegen sie braucht es eine vorbeugende Architektur und eine gute Fehlererkennung. Monitoring, Fehlerkorrektur und einfachere Architekturen machen Multi-Agenten-Systeme zusammen zuverlässiger und ihre Leistung beständiger.

Die Fehlerkategorien aus dem Paper

Das Paper ordnet seine Fehlerarten drei Kategorien zu: Fehler in Spezifikation und Systemdesign, fehlende Abstimmung zwischen Agenten (Inter-Agent Misalignment) sowie Probleme bei Prüfung und Abschluss von Aufgaben.

Fehler in Spezifikation und Systemdesign

Bei diesen Fehlern geht es darum, wie Agenten die Vorgaben für ihre Aufgaben und Rollen verstehen und einhalten.

Missachtung der Aufgabenvorgaben

Der Agent liefert Ergebnisse, die ausdrückliche Anforderungen der Aufgabe verletzen. Das ist die Fehlerart "Disobey Task Spec", bei der Agenten Einschränkungen oder Anforderungen ignorieren. Ein Beispiel: Bei einer Code-Generierung mit konkreten Vorgaben zur API schreibt der Agent Code, der veraltete oder nicht erlaubte Methoden nutzt. Das Ergebnis wirkt funktionsfähig, verfehlt aber wichtige Anforderungen und verursacht später Probleme bei der Integration.

Verstöße gegen die Rollenvorgaben

Der Agent handelt außerhalb seiner festgelegten Rolle. Bei der Fehlerart "Disobey Role Spec" übernehmen Agenten Aufgaben, die anderen Agenten zugewiesen sind, etwa wenn ein Recherche-Agent Entscheidungen zur Umsetzung trifft, für die ein Entwicklungs-Agent zuständig wäre. Die Folge sind verschwimmende Rollen, uneinheitliche Entscheidungen und Lücken in den Zuständigkeiten.

Doppelte Arbeit

Der Agent wiederholt bereits erledigte Arbeit. Die Fehlerart "Step Repetition" trat in mehreren Frameworks auf, zum Beispiel bei einem Planungs-Agenten, der Pläne neu erstellt, obwohl es weder neue Informationen noch neue Anforderungen gibt. Das verschwendet Tokens, macht das System langsamer und kann zu Widersprüchen zwischen den Durchläufen führen.

Fehlende Abstimmung zwischen Agenten

Hier geht es um Brüche darin, wie Agenten Informationen teilen und ihre Arbeit koordinieren.

Kontextverlust und Gedächtnisprobleme

Agenten halten den Kontext über mehrere Interaktionen nicht konsistent. Das sind die Fehlerarten "Loss of History" und "Conversation Reset". Ein Agent vergisst wichtige Entscheidungen aus dem früheren Gesprächsverlauf oder beginnt eine Aufgabe mittendrin von vorn. Die Folgen sind uneinheitliche Entscheidungen, wiederholte Fragen und die Unfähigkeit, auf früherer Arbeit aufzubauen.

Informationen werden nicht geteilt

Wichtige Informationen kommen nicht von einem Agenten zum anderen. Das beschreiben die Fehlerarten "Withholding Info" und "Ignore Input", etwa wenn ein Analyse-Agent wichtige Erkenntnisse nicht an einen Reporting-Agenten weitergibt. Das Ergebnis sind unvollständige Analysen, doppelte Arbeit und Ausgaben, die nur auf einem Teil der Informationen beruhen.

Widersprüchliche Schlussfolgerungen

Die Aktionen eines Agenten folgen nicht aus seiner eigenen Begründung. Bei der Fehlerart "Reasoning Mismatch" passen Schlussfolgerungen nicht zu den Prämissen: Ein Agent erkennt ein Problem richtig, schlägt aber eine Lösung vor, die nichts damit zu tun hat oder ihm widerspricht. Das Verhalten des Systems wird unvorhersehbar, und die Ergebnisse lassen sich nicht auf eine logische Argumentation zurückführen.

Abdriften vom Ziel

Agenten entfernen sich nach und nach vom eigentlichen Ziel. Bei der Fehlerart "Task Derailment" kann sich ein Planungs-Agent zum Beispiel langsam Nebenthemen zuwenden und das Hauptziel aus den Augen verlieren. Ressourcen fließen in unwichtige Pfade, und die Kernaufgabe bleibt liegen.

Probleme bei Prüfung und Abschluss von Aufgaben

Hier geht es darum, wie Agenten ihre eigene Arbeit bewerten und entscheiden, wann sie fertig ist.

Vorzeitiger Abbruch

Agenten schließen Aufgaben ab, bevor alle Anforderungen erfüllt sind. Die Fehlerart "Premature Stop" zeigte sich in mehreren Frameworks, etwa bei einem Code-Agenten, der eine unvollständige Implementierung liefert und die Aufgabe als erledigt markiert. Das Ergebnis wirkt fertig, ist es aber nicht, und ein Mensch muss eingreifen.

Das Ziel wird nicht erkannt

Agenten merken nicht, dass sie ihr Ziel erreicht haben. Bei der Fehlerart "Unaware Stop" machen Agenten unnötig weiter, etwa ein Recherche-Agent, der noch Informationen sammelt, obwohl der Informationsbedarf längst gedeckt ist. Das verschwendet Ressourcen, erhöht die Komplexität und kann Fehler in Arbeit bringen, die schon fertig war.

Mängel bei der Prüfung

Ergebnisse werden nicht ordentlich gegen die Anforderungen geprüft. Das sind die Fehlerarten "No Verification" und "Incorrect Verification", zum Beispiel ein QA-Agent, der offensichtliche Fehler übersieht oder falsche Ergebnisse freigibt. Die Fehler landen dann in nachgelagerten Prozessen oder bei den Endnutzern, und zwar mit dem Anschein, geprüft zu sein.

Fehlende Rückfragen

Agenten arbeiten mit mehrdeutigen Anweisungen weiter, ohne nachzufragen. Die Fehlerart "Fail Clarify" tritt in mehreren Frameworks auf: Ein Agent trifft Annahmen über mehrdeutige Anforderungen, statt um eine genaue Vorgabe zu bitten. Das Ergebnis erfüllt formal die Anforderungen, so wie der Agent sie verstanden hat, verfehlt aber das, was eigentlich gemeint war.

Muster über die Fehlerkategorien hinweg

In der ersten Version des Papers verteilten sich die Fehler so auf die drei Kategorien:

• Fehler in Spezifikation und Systemdesign: 37,2 %
• Fehlende Abstimmung zwischen Agenten: 31,4 %
• Prüfung und Abschluss von Aufgaben: 31,4 %

Keine Kategorie dominiert. Wer nur eine Art von Problem behebt, bekommt also noch kein zuverlässiges Multi-Agenten-System.

Die Kategorien hängen außerdem zusammen. Eine verletzte Rollenvorgabe kann dazu führen, dass Informationen nicht geteilt werden, verlorener Kontext kann zu widersprüchlichen Schlussfolgerungen führen, und eine schwache Prüfung lässt fast jeden anderen Fehler bis ins Endergebnis durch.

So bauen Sie zuverlässige KI-Agenten-Systeme

Aus der Fehler-Taxonomie lässt sich ein praktischer Rahmen für Design, Umsetzung und Verbesserung von Multi-Agenten-Systemen ableiten. Die folgenden Regeln sind ein guter Ausgangspunkt.

Grundlagen des Agenten-Designs

Klare Aufgaben und Rollen

Laut der Forschung tragen unklare Rollen erheblich zu Fehlern von Agenten bei. Diese Regeln machen die Vorgaben klarer:

• Legen Sie die Grenzen jedes Agenten ausdrücklich fest: seine Zuständigkeiten, seine Befugnisse und seine Einschränkungen im System.

1AGENT ROLE: Code Reviewer
2PRIMARY RESPONSIBILITY: Evaluate code for security vulnerabilities and logic errors
3AUTHORITY: Can request code revisions but cannot modify code directly
4LIMITATIONS: Should not suggest feature enhancements or architectural changes

• Halten Sie in einer Zuständigkeitsmatrix fest, welcher Agent für welche Teilaufgabe, welche Art von Entscheidung und welchen Prüfschritt zuständig ist.

• Schreiben Sie ausdrücklich hinein, was der Agent nicht tun soll. Das hilft gegen die Fehlerart "Disobey Role Spec".

• Ergänzen Sie die Vorgaben um konkrete Beispiele für richtiges und falsches Verhalten des Agenten.

Prompt Engineering für Zuverlässigkeit

Das Design der Prompts beeinflusst die Zuverlässigkeit von Agenten stark. Diese Regeln sind durch die Forschung gestützt:

• Verwenden Sie für alle Agenten dieselbe Prompt-Struktur, damit ihr Verhalten vorhersehbar bleibt.

• Bauen Sie Schritte zur Selbstprüfung in die Prompts ein, um Denkfehler abzufangen:

1Before submitting your response, verify that:
21. Your analysis directly addresses the specific question asked
32. Your reasoning is supported by the provided information
43. You have not introduced unsupported assumptions
54. Your conclusion logically follows from your analysis

• Geben Sie ausdrückliche Anweisungen, wichtige Entscheidungen im Blick zu behalten. Das hilft gegen die Fehlerart "Loss of History":

1Important: Maintain awareness of key decisions from our conversation:
2- Selected database: PostgreSQL
3- Authentication method: OAuth2
4- Deployment environment: Kubernetes

• Lassen Sie Agenten ihre Überlegungen Schritt für Schritt zeigen, damit Fehler leichter auffallen.

Modulare Agenten-Architektur

Laut der Forschung tragen zu komplexe Rollen zu Systemfehlern bei. Diese Architekturprinzipien helfen:

• Geben Sie jedem Agenten einen einzigen, klar definierten Zweck, statt mehrere Rollen zu kombinieren.

• Verwenden Sie zwischen den Agenten einheitliche Ein- und Ausgabeformate, damit weniger Kommunikationsfehler entstehen.

• Starten Sie mit Generalisten und teilen Sie sie in Spezialisten auf, sobald die Anforderungen an das System klarer sind.

• Legen Sie riskante Aufgaben (Prüfungen, Sicherheitschecks) in eigene Agenten mit einfachen Prompts.

Interaktion und Kommunikation gestalten

Strukturierte Gesprächsabläufe

Die Forschung nennt unstrukturierte Gespräche als Ursache dafür, dass Agenten von der Aufgabe abdriften. Diese Interaktionsmuster helfen:

• Legen Sie feste Formate für Anfragen, Antworten und Übergaben zwischen Agenten fest.

• Teilen Sie komplexe Aufgaben in einzelne Phasen mit ausdrücklichen Kriterien für den Übergang von einer Phase zur nächsten.

• Verwenden Sie feste Nachrichtentypen (etwa Anfrage, Antwort, Prüfung, Rückfrage), damit die Interaktionen vorhersehbar sind.

• Legen Sie fest, wie ein Gespräch beginnt, verläuft und endet. Das hilft gegen die Fehlerart "Conversation Reset".

Prüfmechanismen

Mängel bei der Prüfung sind in allen Frameworks eine wichtige Fehlerkategorie. Diese Prüfstrategien helfen:

• Richten Sie Schleifen zur gegenseitigen Prüfung ein, in denen ein Agent die Ausgabe eines anderen prüft, bevor der Workflow weiterläuft:

1VERIFICATION WORKFLOW:
21. Agent A generates solution
32. Agent B evaluates solution against requirements
43. If approved, proceed; if rejected, return to Agent A with specific feedback
54. Limit iterations to prevent infinite loops

• Bauen Sie eigene Prüf-Agenten, die nur für die Qualitätssicherung zuständig sind und mit ausdrücklichen Prüfkriterien arbeiten.

• Validieren Sie Ausgaben gegen vorab definierte Schemas, um Formatfehler abzufangen.

• Setzen Sie Prüfpunkte über den ganzen mehrstufigen Prozess hinweg und nicht nur am Ende.

Regeln für Rückfragen

Die Fehlerart "Fail Clarify" taucht in allen Frameworks immer wieder auf. Diese Strategien für Rückfragen helfen:

• Weisen Sie Agenten an, nachzufragen, wenn ihre Sicherheit unter einen festgelegten Schwellenwert fällt.

• Fordern Sie Agenten auf, mehrdeutige Anweisungen zu erkennen und zu markieren:

1If the requirements contain any of these ambiguity indicators:
2- Multiple possible interpretations
3- Undefined technical terms
4- Conflicting constraints
5- Unclear priorities
6Then: Request specific clarification before proceeding

• Legen Sie ein Format für Rückfragen fest, das die Mehrdeutigkeit genau benennt.

• Wenn ein Agent ohne Rückfrage weitermacht, muss er seine Annahmen ausdrücklich dokumentieren.

Systemarchitektur und Orchestrierung

Topologie

Fehler im Systemdesign sind eine große Kategorie von Problemen in Multi-Agenten-Systemen. Diese Architekturprinzipien helfen:

• Setzen Sie Supervisor-Agenten ein, die spezialisierte Worker-Agenten koordinieren. Das hilft gegen die Fehlerart "Task Derailment".

• Bauen Sie Feedbackschleifen, in denen Ergebnisse schrittweise verbessert werden:

1REFINEMENT CYCLE:
21. Draft generation
32. Critical evaluation
43. Targeted improvement
54. Re-evaluation against acceptance criteria
65. Finalization or return to step 2

• Nutzen Sie mehrere Prüfwege, um verschiedene Arten von Fehlern zu finden.

• Trennen Sie Erstellung und Bewertung auf verschiedene Agenten auf. Fehler fallen leichter auf, wenn der prüfende Agent die Arbeit nicht selbst erstellt hat.

Workflows optimieren

Ineffiziente Interaktionen sind eine große Fehlerkategorie. Diese Strategien helfen:

• Legen Sie Kontext in gemeinsamen Speichern ab, damit weniger Informationen doppelt zwischen Agenten übertragen werden.

• Geben Sie Agenten Informationen nur, wenn sie für die aktuelle Aufgabe relevant sind, damit ihr Kontext sauber bleibt.

• Rufen Sie spezialisierte Agenten nur bei Bedarf auf, statt alle Agenten den ganzen Prozess über aktiv zu halten.

• Bearbeiten Sie unabhängige Teilaufgaben parallel, um die Gesamtlaufzeit zu verkürzen.

Fehlerbehandlung und Wiederherstellung

Laut der Forschung führt die Fortpflanzung von Fehlern zu kumulativen Systemfehlern. Diese Mechanismen helfen:

• Legen Sie klare Fehlertypen und für jeden eine Reaktion fest.

• Bauen Sie das System so, dass es mit eingeschränkter Funktion weiterläuft, wenn Komponenten ausfallen.

• Ermöglichen Sie, bei einem erkannten Fehler zu einem bekannten guten Zustand zurückzukehren.

• Legen Sie konkrete Bedingungen fest, bei denen automatisch an einen Menschen eskaliert wird.

Umsetzung und Tests

Schrittweise Entwicklung

Laut der Forschung hängt die Fehlerrate mit der Komplexität des Systems zusammen. Mit diesem Vorgehen behalten Sie die Komplexität im Griff:

1. Mit minimalen Agenten starten: Beginnen Sie mit dem einfachsten System, das die Kernaufgabe erledigt (unser Leitfaden zu KI-Agenten ohne Framework (auf Englisch) zeigt, wie klein das sein kann).

2. Testgetrieben erweitern: Fügen Sie Agenten oder Funktionen erst hinzu, wenn die Basis zuverlässig läuft.

3. Komplexität kontrolliert steigern: Führen Sie immer nur ein neues Interaktionsmuster ein und testen Sie es gründlich.

4. Laufend vergleichen: Vergleichen Sie die Leistung des Multi-Agenten-Systems immer wieder mit einem einzelnen Agenten, um die zusätzliche Komplexität zu rechtfertigen.

Systematisch testen

Die Bandbreite der Fehlerarten aus der Forschung verlangt gründliche Tests:

• Testen Sie jede Fehlerart der Taxonomie gezielt.

• Erstellen Sie schwierige Grenzfälle, die bestimmte Fehlermuster auslösen sollen.

• Bewerten Sie die Leistung über lange Interaktionsfolgen, um kumulative Fehler zu finden.

• Bewerten Sie einzelne Agenten isoliert, bevor Sie sie integrieren, um ihre Grundfähigkeiten zu kennen.

Laufende Verbesserung

Laut der Forschung verändern sich die Fehlermuster, während sich ein System weiterentwickelt. Mit diesem Kreislauf halten Sie Schritt:

1. Fehler einordnen: Ordnen Sie beobachtete Fehler den Kategorien der Taxonomie zu.

2. Ursachen analysieren: Führen Sie Fehler auf konkrete Elemente der Architektur oder des Prompt-Designs zurück.

3. Gezielt eingreifen: Verbessern Sie gezielt das, was die Ursache ist.

4. Prüfen: Bestätigen Sie, dass die Änderungen die jeweilige Fehlerart beheben, ohne neue zu erzeugen.

Beispiel: ein System zur gemeinsamen Erstellung von Dokumenten

Zur Veranschaulichung ein System, in dem Agenten gemeinsam Dokumente erstellen.

Ursprüngliches, fehleranfälliges Design:

• Ein einziger Agent erstellt und überarbeitet die Inhalte
• Unstrukturierter Gesprächsablauf
• Keine ausdrücklichen Prüfmechanismen
• Keine Kriterien für den Abschluss

Verbessertes Design nach den Best Practices:

1. Spezialisierte Agenten:

   • Recherche-Agent: sammelt Informationen und prüft Fakten
   • Content-Agent: erstellt den ersten Entwurf
   • Editor-Agent: verbessert Stil und Struktur
   • QA-Agent: prüft das Ergebnis abschließend gegen die Anforderungen

2. Strukturierter Workflow:

   • Klare Übergänge zwischen den Phasen mit Prüfpunkten
   • Ausdrückliche Übergaberegeln zwischen den Agenten
   • Festgelegte Kriterien, wann der Prozess abgeschlossen ist

3. Prüfmechanismen:

   • Gegenseitige Prüfung der Fakten durch die Agenten
   • Checkliste zur Einhaltung der Anforderungen
   • Ausdrückliche Validierung der Ausgabe gegen die Formatvorgaben

4. Fehlerbehandlung:

   • Klare Regeln, wie Meinungsverschiedenheiten zwischen Agenten gelöst werden
   • Eskalation an einen Menschen, wenn sich ein Konflikt nicht lösen lässt
   • Der Kontext bleibt über den gesamten Workflow erhalten

Das verbesserte Design adressiert die wichtigsten Fehlerarten aus der Forschung und bleibt trotzdem effizient.

Grundprinzipien für zuverlässige KI-Agenten-Systeme

Forschung und Praxiserfahrung lassen sich auf fünf Prinzipien verdichten:

1. Klarheit schlägt Komplexität: Systeme mit klaren, einfachen Rollen schneiden besser ab als ausgefeiltere Architekturen mit unklaren Zuständigkeiten.

2. Prüfung ist Pflicht: Jede Ausgabe eines Agenten muss geprüft werden, durch Selbstprüfung, gegenseitige Prüfung oder eigene Prüf-Agenten.

3. Struktur im Gespräch schafft Zuverlässigkeit: Ausdrückliche Gesprächsprotokolle verringern Abdriften und Kontextverlust deutlich.

4. Modularität macht widerstandsfähig: Spezialisierte Agenten mit klar umrissenen Aufgaben lassen sich gezielter verbessern und leichter debuggen.

5. Komplexität schrittweise steigern: Beginnen Sie mit einer minimalen Architektur und erhöhen Sie die Komplexität nur, wenn messbare Verbesserungen das rechtfertigen.

Wenn Sie gerade ein Multi-Agenten-System planen, beginnen Sie mit einem einzelnen Agenten, messen Sie seine Leistung und fügen Sie einen zweiten Agenten erst hinzu, wenn er diese Basis übertrifft und einen eigenen Prüfschritt mitbringt. Wenn Sie ein Agenten-System für Ihr Unternehmen planen und Unterstützung bei der Architektur suchen: Unser Team für KI-Beratung baut solche Systeme gemeinsam mit Kunden. Sprechen Sie uns an.

Sie möchten zuverlässige KI-Agenten-Systeme bauen?

Wir haben auf Basis aktueller Forschung einen ausführlichen Leitfaden (auf Englisch) erstellt, wie Sie robuste KI-Agenten-Systeme bauen, die auch im produktiven Betrieb funktionieren. Der Leitfaden behandelt:

• die 14 systematischen Fehlerquellen in Multi-Agenten-Systemen
• belegte Best Practices für das Design von Agenten
• strukturierte Kommunikationsprotokolle und Prüfmechanismen

Weiterlesen

• Fortgeschrittene KI-Agenten selbst bauen: ein mehrstufiger Agent (auf Englisch)
• KI-Agenten ohne Framework bauen: Schritt-für-Schritt-Anleitung (auf Englisch)
• DSPy: bessere KI-Systeme durch automatische Prompt-Optimierung (auf Englisch)
• RAG mit Azure AI Search
• KI-Agenten für Unternehmen mit dem Microsoft Agent Framework
• smolagents: ein minimalistisches Framework für Einzel-Agenten (auf Englisch)

Über den Autor

Andreas Nigg

Mitgründer, Pondhouse Data

Andreas entwickelt seit mehr als acht Jahren Datenanwendungen. Bei Pondhouse Data konzipiert und baut er KI-Systeme und integriert sie in komplexe, gewachsene Unternehmensumgebungen.

Sprechen Sie mit Andreas über Ihr ProjektAuf LinkedIn folgen