Startseite / Artikel

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.

Verlag: REACTAPP.TOP8 Min. Lesezeit1753 Wörter

Quellen: When an AI Agent Fails, Who Do You Blame?

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

  • Wenn das Dashboard grün ist und der Agent falsche Spuren verfolgt: Zustandsverfolgung — Wie Agentfehler in zwischen den funktionierenden Schritten übertragenen Zuständen verborgen bleiben und welche Verfolgungsmethoden, Laufzeitbeschränkungen, Routing-Einträge sowie Auswertungen erforderlich sind, um dies zu erfassen.
  • Wenn ein Klassifizierer heimlich Ihr Modell austauscht: Der Fall für Anschriftshinweise des bereitgestellten Modells — Ein stummer Wechsel auf ein günstigeres Modell hinterlässt weder Fehler noch Einträge in den Protokollen. Wie man Daten des bereitgestellten Modells in den Transkripten von Claude Code liest und warum Anbieter diese in ihren Antworten bereitstellen sollten.