Wenn ein KI-Agent versagt – wen macht man dafür verantwortlich? Die Analyse der Fehlerkette
Warum „das Modell halluziniert“ unzureichend ist: Eine Übersicht über die Fehlerkaskade des Agents – von Absicht und Informationsabruf über Tools, Wiederholungsversuche und Protokollierung bis hin zu den zu beobachtenden Aspekten.
Bild, das einen KI-Assistenten bittet, einen Flug nach São Paulo für morgen früh, gegen 9 Uhr, zu buchen. Ein paar Sekunden später antwortet er, der Flug sei gebucht worden. Doch das ist nicht der Fall – es gibt weder ein Ticket noch eine Bestätigungs-E-Mail noch eine Gebühr.
Der verlockende Schluss ist, dass die KI Halluzinationen hatte. Vielleicht stimmt das. Aber vielleicht hat sich das Modell genau so verhalten, wie es entworfen wurde. Die Buchungs-API könnte einen Fehler zurückgegeben haben, den der Assistent falsch interpretiert hat. Der Assistent könnte nach Flügen gesucht haben, ohne jemals das Buchungstool aufzurufen. Die API könnte nach Abschluss der Transaktion abgelaufen sein. Das Tool könnte einen Kostenvoranschlag und keine bestätigte Reservierung zurückgegeben haben. Oder „morgen früh“ wurde in der falschen Zeitzone interpretiert.
Sobald KI-Systeme anfangen, Aufgaben auszuführen, anstatt nur Fragen zu beantworten, werden Fehler viel schwieriger zu erklären. Das stellt ein neues Ingenieurproblem dar: Wenn ein Agent versagt, wer oder was trägt die Schuld?
Alte Software war einfacher zu debuggen
Herkömmliche Software kann komplex sein, doch ihr Ausführungspfad ist in der Regel vertraut:
User
↓
Frontend
↓
Backend
↓
Database
Wenn etwas kaputtgeht, sind die zu überprüfenden Stellen gut bekannt: ob die Anfrage das Backend erreicht hat, ob die Datenbank ausgefallen ist, ob eine nachgelagerte API stecken geblieben ist, ob eine Ausnahme aufgetreten ist. Protokolle, Metriken und Spuren helfen dabei, das Gesamtbild zusammenzusetzen.
Ein Agent sieht ganz anders aus:
User Request
↓
Interpret Intent
↓
Retrieve Context
↓
Create a Plan
↓
Select a Tool
↓
Call the Tool
↓
Interpret the Result
↓
Reason Again
↓
Final Answer
Ein erfolgreicher HTTP-Antworttext sagt hier nur sehr wenig aus. Das System kann zurückgeben
200 OK
und tut trotzdem etwas völlig Falsches. Das ist der wesentliche Unterschied zwischen klassischer Überwachung und AI-Überwachbarkeit: Ein System kann aus betrieblicher Sicht gesund sein, aber in seinem Verhalten falsch handeln.
„Das Modell hat halluziniert“ – das neue „Der Computer ist kaputt“
Fast jedes schlechte AI-Ergebnis wird als Halluzination bezeichnet, und dieser Begriff verliert schnell an Bedeutung. Angenommen, ein Assistent behauptet, Ihr Unternehmen gewähre 30 Tage bezahlten Urlaub, obwohl die tatsächliche Richtlinie 22 Tage vorsieht. Eine Halluzination? Möglicherweise. Aber nehmen wir an, die richtige Richtlinie lag im Dokumentenspeicher, doch die Abfrage holte eine veraltete Version. Das Modell könnte anhand des ihm zur Verfügung gestellten Kontexts fehlerfrei geantwortet haben. Das Modell hat nicht versagt – der Kontextverarbeitungspfad hat es getan, und das Wechseln des Modells wird das System nicht reparieren.
Der Agent-Fehler-Stack
Ein nützliches mentales Modell betrachtet ein agierendes System als eine Abfolge von Schritten, an denen etwas schiefgehen kann:
┌───────────────────────────┐
│ User Intent │
├───────────────────────────┤
│ Prompt / Instructions │
├───────────────────────────┤
│ Context / Retrieval │
├───────────────────────────┤
│ Memory │
├───────────────────────────┤
│ Planning / Reasoning │
├───────────────────────────┤
│ Tool Selection │
├───────────────────────────┤
│ Tool Parameters │
├───────────────────────────┤
│ Tool Execution │
├───────────────────────────┤
│ External Systems │
├───────────────────────────┤
│ Orchestration │
├───────────────────────────┤
│ Infrastructure │
└───────────────────────────┘
Nennen wir es den Fehlerstack des Agenten. Der Punkt ist, dass die endgültige Antwort lediglich die sichtbare Spitze eines viel längeren Ausführungspfades ist.
1. Der Agent hat etwas Falsches verstanden
Bitten Sie einen Assistenten, das Treffen mit John am Freitag abzusagen. Er findet ein wiederkehrendes Ereignis mit dem Namen „Wöchentliche Abstimmung mit John“ und löscht die gesamte Serie. Die Kalender-API funktionierte, die Authentifizierung funktionierte, die Löschung war erfolgreich. Der Fehler trat bereits auf, bevor irgendein Tool aufgerufen wurde:
User Intent
↓
Wrong Interpretation
↓
Correct Tool Call
↓
Wrong Outcome
Das ist ein Versagen der Intentionserkennung, und es ist gefährlich, weil alles, was nach dem ursprünglichen Fehler folgt, einwandfrei funktionieren kann.
2. Die Informationen waren vorhanden, aber der Agent hat sie nie gesehen
Nehmen wir einen Rechtsassistenten, der einen Vertrag liest, in dem steht, dass jede Partei nach 90 Tagen kündigen kann. Die Informationsabfrage sendet dem Modell eine benachbarte Klausel über eine Kündigungsfrist von 30 Tagen, und die KI kommt zu dem Schluss, der Vertrag könne nach 30 Tagen enden. Auch hier kann das Modell aufgrund schlechter Eingabedaten zu richtigen Schlussfolgerungen gelangen:
Documents
↓
Retrieval
↓
Wrong Chunk
↓
Model
↓
Wrong Answer
Das Problem liegt bei der Abrufung und nicht unbedingt bei der Erstellung. Das Beheben eines RAG-Fehlers ähnelt oft eher der Anpassung einer Suchmaschine als der Behebung eines Chatbots.
3. Das Gedächtnis kann ein intelligentes System gezielt veraltet machen
Agenten verfügen zunehmend über ein Gedächtnis, das nützlich ist – bis es veraltet. Angenommen, der Agent erinnert sich
Customer Plan = Basic
Aber der Kunde hat letzte Woche auf ein höheres Paket upgegraded, und der tatsächliche Zustand ist
Customer Plan = Enterprise
Der Agent weigert sich, eine Funktion bereitzustellen, zu der der Benutzer Anspruch hat. Nichts ist abgestürzt, und der Speicher hat genau das getan, wofür er konzipiert wurde – er hat einfach weiterhin Informationen gespeichert, die nicht mehr zutrafen. Manchmal ist Vergessen genauso wichtig wie Erinnern.
Werkzeuge erhöhen das Risiko
LLMs erzeugen Text. Agenten erzeugen Aktionen, und das verändert das Risiko. Geben Sie einem Agenten zwei Werkzeuge:
search_customer()
update_customer()
Der Benutzer fragt, welche Adresse für Sarah gespeichert ist. Das offensichtliche Werkzeug ist
search_customer()
dennoch wählt das Modell
update_customer()
Das ist ein Fehler bei der Auswahl des Werkzeugs. Oder es wählt das richtige Werkzeug aus und geht weiter.
{
"currency": "USD"
}
wo der richtige Wert war
{
"currency": "BRL"
}
Das ist ein Fehler im Tool-Parameter. Die API kann problemlos laufen, doch das Ergebnis ist dennoch falsch.
Manchmal funktioniert das Tool nicht
Externe Systeme sind unzuverlässig. APIs erreichen ihre Zeitlimits, Datenbanken gehen offline, es greifen Gebührenbeschränkungen, und Berechtigungen verfallen. Betrachten Sie diese Kette:
Agent
↓
Book Flight API
↓
TIMEOUT
Wie sollte der Agent reagieren: es erneut versuchen, den Benutzer fragen oder zunächst überprüfen, ob eine Reservierung existiert? Nehmen wir nun an, die Buchung ist tatsächlich erfolgt, aber die Bestätigung ist auf dem Rückweg verloren gegangen, sodass der Agent es ein zweites Mal versucht:
First booking → SUCCESS
Response → LOST
Retry → SUCCESS
Nun besitzt der Kunde zwei Tickets. Es handelt sich dabei nicht mehr nur um ein Problem der KI – es ist ein klassisches Problem von verteilten Systemen, wobei Wiederholungsversuche, Idempotenz, Zustandsverwaltung und Transaktionen zu Bestandteilen der KI-Entwicklung werden.
Mehre-Agenten-Konfigurationen verschleiern die Schuldzuweisung
Stellen Sie sich nun nacheinander drei Agenten vor:
Research Agent
↓
Analysis Agent
↓
Writing Agent
Der Forschungsagent findet die richtigen Fakten. Der Analyseagent liest sie korrekt. Der Schreibagent lässt eine wichtige Einschränkung aus, wodurch die endgültige Antwort irreführend ist. Welcher Agent hat versagt? Agentensysteme ähneln zunehmend verteilten Softwarelösungen, deren Komponenten probabilistische Entscheidungen treffen, was die Beobachtbarkeit unerlässlich macht.
Spuren sind wichtiger als Protokolle
Nehmen wir an, ein Agent liefert eine schreckliche Antwort, während das Infrastruktur-Dashboard Folgendes anzeigt:
HTTP Status: 200
Latency: 3.8s
CPU: Normal
Memory: Normal
Errors: 0
Alles scheint in Ordnung zu sein, doch die Antwort ist falsch. Die klassische Überwachung zeigt an, dass das System ausgeführt wurde. Die Ingenieure müssen wissen, warum es diese Entscheidung getroffen hat. Dafür ist etwas nötig, das eher einem Agenten-Trace ähnelt:
TRACE #84721
User Request
↓
Intent: "Book Flight"
↓
Retrieved user preferences
↓
Planner created 3 steps
↓
search_flights()
↓
Selected Flight #2
↓
book_flight()
↓
API response: timeout
↓
Agent assumed success
↓
Final response:
"Your flight has been booked."
Nun ist der Fehler behobbar. Der Agent hat nicht einfach nur einen Flug erfunden. Das System hat einen unbekannten Tool-Zustand als abgeschlossene Transaktion behandelt, und das ist etwas, was Ingenieure beheben können.
Was eine Trace erfassen sollte
Eine nützliche Agent-Trace könnte Folgendes enthalten:
trace_id
user_requestmodel_versionprompt_versionretrieved_contextmemory_usedtool_callstool_parameterstool_resultsretrieslatencytoken_usagecostfinal_answerevaluation_result
Nicht jede Anwendung muss jedes Feld speichern, da Privatsphäre, Sicherheit und Kosten weiterhin von Bedeutung sind. Das Prinzip ist jedoch einfach: Wenn ein Agent zehn Schritte benötigt, um zu einer Antwort zu gelangen, ist es so, als würde man bei der Fehlersuche in einer Microservice-Architektur nur die erste Anfrage und die letzte Antwort protokollieren – das hilft kaum weiter.
Monitoring ist keine Observabilität
Der Unterschied ist insbesondere für KI-Systeme nützlich. Monitoring fragt, ob etwas falsch ist. Tracing fragt, welchen Weg die Aufgabe genommen hat. Observabilität fragt, warum sich das System so verhalten hat. Evaluation fragt, ob das Verhalten tatsächlich gut war.
Monitoring
"Is the system healthy?"
↓
Tracing
"What path did it follow?"
↓
Observability
"Why did it behave this way?"
↓
Evaluation
"Was the result correct?"
Die KI-Entwicklung benötigt alle vier.
Auch Metriken müssen sich entwickeln
Herkömmliche Dienste werden mit Zahlen wie
Availability
Latency
Throughput
Error Rate
und die sind immer noch wichtig. Die Agenten fügen neue Fragen hinzu:
Task Success Rate
Tool Success RateRetrieval Success RateTrajectory Success RateHuman Escalation RateAverage Steps per TaskTokens per TaskCost per TaskCost per Successful Task
Der letzte Punkt ist besonders aufschlussreich. Ein Agent, der 0,01 Dollar pro Anfrage kostet, aber nur zu Hälfte erfolgreich ist, könnte ein schlechterer Deal sein als einer, der 0,03 Dollar kostet und zu 98 Prozent erfolgreich ist. Das günstigste KI-System ist nicht unbedingt das am günstigstenen Modell – es ist vielmehr das, das das günstigste erfolgreiche Ergebnis liefert.
Wer trägt also die Schuld?
Zurück zum Flug: Der Nutzer bat um eine Buchung nach São Paulo für morgen früh, der Agent sagte „Erledigt“, und es existiert kein Ticket. Das Modell? Vielleicht. Die Anfrage? Möglicherweise. Oder die Abruffunktion, das Buchungstool, die Fluggesellschafts-API, der Orchestrierer, die Infrastruktur?
Die unangenehme Antwort ist, dass man es erst wissen kann, wenn man die Ausführung rekonstruieren kann. Dies stellt eine bedeutende Wende in der KI-Entwicklung dar. Sobald Modelle zu Agenten werden und Agenten zu ganzen Systemen, ist Zuverlässigkeit nicht mehr nur eine Eigenschaft des Modells selbst, sondern wird zu einer Eigenschaft des gesamten Ausführungspfades:
Model Quality
+
Context Quality
+
Tool Reliability
+
Orchestration
+
Infrastructure
+
Evaluation
+
Observability
↓
Reliable AI System
Stärkere Modelle werden sicherlich helfen, aber allein die Leistungsfähigkeit macht KI-Systeme nicht zuverlässig. Die grundlegenden Prinzipien, die Softwareentwickler seit Jahrzehnten gelernt haben zu berücksichtigen, gelten weiterhin: Protokolle, Spuren, Zeitlimits, Wiederholungsversuche, Berechtigungen, Zustand, Tests, Metriken und Fehleranalyse. Wenn ein Agent in der Produktion versagt, klingt der Satz „Das Modell hat halluziniert“ letztendlich genauso nützlich wie „Der Computer hat etwas Seltsames getan“. Die Ingenieurkunst beginnt dort, wo diese Erklärungen nicht mehr ausreichen.
Verwandte Artikel
- Agent-Audit-Protokolle benötigen 12 Felder: Was sechs Frameworks tatsächlich aufzeichnen — Eine statische Übersicht von sechs Agent-Frameworks im Vergleich zu einem Entwurf für ein 12-Felder-Audit-Protokoll: Die durchschnittliche Abdeckung beträgt 5 von 12 Feldern, und keines der Frameworks erfasst Beweise für Manipulationen oder ein Vertrauensniveau.