Warum LLM-Agenten scheitern können: Technische Limits erklärt

Wenn ein Agent gut arbeitet, sieht das wie Magie aus.

Du gibst eine Aufgabe, erklärst nichts, kontrollierst nicht jeden Schritt, und das System findet selbst Daten, wählt Tools aus und kommt mit einem Ergebnis zurück.

Und irgendwann wirkt es so, als ob es versteht, was es tut.

Und dann plötzlich:

• Es nutzt das falsche Tool
• Es vergisst die Hälfte der Aufgabe
• Es macht einen unnötigen API-Aufruf
• Oder es liefert selbstsicher völligen Unsinn zurück

Und das Schlimmste: Es macht das sehr überzeugend.

Ohne Textfehler.
Ohne Zögern.
Als ob alles korrekt wäre.

In diesem Moment entsteht eine logische Frage:

Wie konnte ein System, das gerade noch intelligent gehandelt hat, so einen Fehler machen?

Weil innen drin kein Denken steckt

Um zu verstehen, warum ein Agent manchmal Fehler macht, muss man anschauen, wie er Entscheidungen tatsächlich trifft.

Denn in ihm steckt kein "Denken".

Ein KI-Agent denkt nicht. Er prüft keine Fakten. Er versteht nicht, was richtig und was falsch ist.

Er arbeitet über ein Sprachmodell.

Und ein Sprachmodell kennt keine Antworten.

Es sucht nicht nach Wahrheit. Es öffnet keine Wissensdatenbank. Es prüft keine Realität.

Es wählt die nächste Aktion oder Antwort, die in diesem Kontext am wahrscheinlichsten aussieht.

Jedes Mal, wenn der Agent:

• Den nächsten Schritt entscheidet
• Ein Tool auswählt
• Eine Anfrage schreibt
• Oder ein Ergebnis bewertet

— ist das nur ein Versuch zu raten, was in diesem Kontext am korrektesten aussieht.

Und manchmal ist diese Vermutung falsch.

Wie der Agent Entscheidungen wirklich trifft

Der Agent weiß nicht, welche Aktion richtig ist.

Aber er ist auf einer riesigen Menge von Beispielen trainiert, wie eine richtige Aktion aussieht in ähnlichen Situationen.

Beim Training hat das Modell gesehen:

• Wie API-Anfragen aussehen
• Wie Daten analysiert werden
• Wie Berichte erstellt werden
• Wie Tools verwendet werden

Und jetzt, wenn der Agent arbeitet, schaut es auf:

• Das Ziel
• Vorherige Schritte
• Erhaltene Ergebnisse

Und stellt sich die Frage:

"Welche Aktion sieht am ehesten wie eine aus, die früher in einer ähnlichen Situation geholfen hat?"

Zum Beispiel, wenn alles gut läuft:

Der Agent bekommt die Aufgabe: "Sammle Kundendaten."
Im Kontext gibt es ein Tool: get_user_data(user_id)

Das Modell "weiß", dass in ähnlichen Aufgaben:

• Zuerst Daten geholt werden
• Danach analysiert wird

Deshalb wählt es: get_user_data aufrufen

Nicht, weil es sicher ist.
Sondern weil es wie der nächste logische Schritt aussieht.

Aber hier läuft es schief:

Der Agent bekommt die Aufgabe: "Schreibe einen kurzen Firmenüberblick für einen neuen Kunden."

Im Kontext liegen alte Meeting-Notizen von einem anderen Kunden, ähnlich im Format.

Das Modell sieht ein ähnliches Muster und denkt:

"In einer ähnlichen Situation nutzt man meistens bereits vorhandene Daten."

Und deshalb erstellt es einen Überblick, aber über die falsche Firma.

Selbstsicher. Ohne Warnung. Mit sauber formatiertem Text.

Nur eben nicht über den richtigen Kunden.

Nach jedem Schritt macht es wieder eine Vorhersage:

"Was macht man normalerweise danach?"

Und so weiter, Schritt für Schritt.

Genau deshalb führt ein Agent oft richtige Aktionen aus.

Aber manchmal eben nicht.

Denn er prüft nicht, ob es stimmt.
Er wählt nur das, was in diesem Kontext am passendsten aussieht.

Im Code sieht das so aus

Unten steht dasselbe Prinzip im einfachen Format:
das Modell "kennt die Wahrheit" nicht, sondern wählt den Schritt, der im aktuellen Kontext am wahrscheinlichsten aussieht.

Zuerst haben wir Aktionen (Tools), die aufgerufen werden können:

def fetch_company_profile(company_id: str):
    return {"company_id": company_id, "summary": "Official profile"}


def summarize_notes(notes: str):
    return {"summary": f"Summary from notes: {notes}"}


TOOLS = {
    "fetch_company_profile": fetch_company_profile,
    "summarize_notes": summarize_notes,
}

Jetzt haben wir den Aufgabenkontext:

state = {
    "task_company_id": "acme",
    "old_notes": "Meeting notes about beta-corp",  # alte Notizen über eine andere Firma
}

Das Modell macht eine Vermutung über den nächsten Schritt:

def choose_action(state: dict):
    # Wenn im Kontext schon Notizen vorhanden sind, kann das Modell entscheiden,
    # dass das für einen schnellen Überblick "ausreicht".
    if state.get("old_notes"):
        return {
            "tool": "summarize_notes",
            "parameters": {"notes": state["old_notes"]},
        }

    return {
        "tool": "fetch_company_profile",
        "parameters": {"company_id": state["task_company_id"]},
    }

Das System führt aus, was das Modell vorgeschlagen hat:

model_output = choose_action(state)

tool_name = model_output["tool"]
params = model_output["parameters"]
result = TOOLS[tool_name](**params)

In diesem Fall ist das Ergebnis "überzeugend", aber über die falsche Firma:

# {'summary': 'Summary from notes: Meeting notes about beta-corp'}

Um das Risiko zu reduzieren, fügen wir vor der finalen Antwort eine einfache Quellenprüfung hinzu:

def validate_summary_source(state: dict, result: dict):
    if "beta-corp" in result.get("summary", "") and state["task_company_id"] == "acme":
        return {"error": "Kontextfehler: Daten sind über die falsche Firma"}
    return {"ok": True}

Das entfernt LLM-Grenzen nicht vollständig, aber es reduziert solche Fehler im Prod-Betrieb.

Analogie aus dem Alltag

Stell dir einen Kochanfänger vor, der tausende Rezeptvideos gesehen hat.

Er hat gesehen:

• Wie man Fleisch brät
• Wie man Suppe kocht
• Wie man Soßen macht
• Wie man Gerichte anrichtet

Aber er erinnert sich an kein einziges Rezept wortwörtlich.

Und er weiß nicht sicher, wie man jedes Gericht richtig kocht.

Jetzt bittest du ihn: "Koch etwas Ähnliches wie Carbonara."

Er öffnet kein Buch. Er prüft keine Anleitung.

Er denkt:

"Was macht man normalerweise in einem ähnlichen Gericht?"

Und:

• Gibt Sahne dazu
• Brät Speck an
• Mischt es mit Pasta

Manchmal wird es sehr gut.
Manchmal seltsam.

Denn er weiß nicht, was korrekt ist.
Er macht nur das, was am meisten wie ein richtiges Rezept aussieht, das er früher gesehen hat.

Ein Agent arbeitet genauso.

Er weiß nicht, welche Aktion richtig ist. Und er erinnert keine fertigen Lösungen.

Er wählt die aus, die in einer ähnlichen Situation am meisten wie die richtige aussieht.

Kurz

FAQ

Q: Weiß ein Agent, dass seine Antwort korrekt ist?
A: Nein. Er wählt die Option, die in diesem Kontext am wahrscheinlichsten aussieht.

Q: Kann sich das Modell selbst prüfen?
A: Es kann versuchen, die Antwort zu bewerten, aber auch das bleibt eine Vermutung.

Q: Warum klingt ein Agent selbstsicher, auch wenn er falsch liegt?
A: Weil das Modell darauf trainiert ist, plausiblen Text zu erzeugen, nicht zu zweifeln.

Was als Nächstes

Jetzt weißt du, warum ein Agent Fehler machen kann und dass dahinter nicht Nachlässigkeit steckt, sondern die Natur der Technologie selbst.

Es gibt mehrere Wege, einen Agenten zuverlässiger zu machen: klare Instruktionen, ein begrenzter Tool-Satz, Ergebnisvalidierung. Aber einer der effektivsten und interessantesten Wege ist Memory.

Wenn ein Agent sich merken kann:

• Was schon gemacht wurde
• Welche Tools funktioniert haben
• Welche Daten er vorher erhalten hat

Verlässt er sich weniger auf Vermutungen und mehr auf konkrete Erfahrung in dieser Aufgabe.

Genau darum geht es im nächsten Artikel.