Zum Inhalt springen

KI-Agenten testen: von Unit-Tests bis zur Eval-Suite

Ein KI-Agent besteht aus Code, der sich wie jede Software testen lässt, und aus einem Sprachmodell, dessen Antworten von Lauf zu Lauf schwanken. Wer beides gleich behandelt, bekommt entweder Tests, die ständig rot werden, oder Tests, die nichts mehr aussagen. Dieser Überblick ordnet die Testarten zu einer Pyramide und zeigt, wie Sie sie als feste Entwicklungsdisziplin einführen.

Was heißt es, einen KI-Agenten zu testen?

Einen KI-Agenten zu testen heißt, zwei Fragen getrennt zu beantworten: Funktioniert der Code um das Modell herum fehlerfrei, und trifft das Modell in diesem Aufbau verlässlich die richtigen Entscheidungen? Die erste Frage beantworten klassische Tests mit eindeutigem Ergebnis. Die zweite beantworten Evals, die mit Wahrscheinlichkeiten statt mit Ja und Nein arbeiten.

Ein Agent, der etwa Angebotsanfragen aus dem Postfach liest, Artikelnummern im ERP nachschlägt und einen Angebotsentwurf erzeugt, enthält beide Welten. Das Parsen der Mail, der ERP-Aufruf, die Berechnung von Mengenrabatten und das Schreiben der PDF-Datei sind gewöhnlicher Code. Ob der Agent die richtige Artikelnummer aus einer unklar formulierten Anfrage ableitet, ist eine Modellentscheidung.

Testen ist dabei mehr als ein einmaliger Qualitätsnachweis vor dem Go-live. Prompts, Modellversionen, Tool-Beschreibungen und Datenquellen ändern sich laufend. Jede dieser Änderungen kann Verhalten verschieben, das gestern noch stimmte. Deshalb gehört das Testen in den Entwicklungsalltag, genau wie bei klassischer Software.

Die Abgrenzung zu verwandten Themen: Der Artikel Evals für KI-Agenten: Qualität messbar machen behandelt, wie Sie Qualität überhaupt definieren und messen – Metriken, Grader, Datensätze. Hier geht es um die Frage, wie Evals zusammen mit Unit-, Integrations- und Regressionstests eine Teststrategie bilden, die im Entwicklungsprozess mitläuft.

Wie sieht die Testpyramide für Agenten aus?

Die Testpyramide für Agenten hat vier Ebenen: unten viele schnelle deterministische Unit-Tests, darüber Komponententests einzelner Modellaufrufe, dann Integrationstests ganzer Agentenläufe gegen Testsysteme und oben eine Regressions-Suite aus echten Fällen. Nach oben werden Tests langsamer, teurer und statistischer, nach unten zahlreicher und eindeutiger.

Ebene 1: deterministische Unit-Tests

Alles, was kein Modellaufruf ist, testen Sie wie gewohnt: Tool-Funktionen, Parser für Modellausgaben, die Funktion, die den Prompt aus Vorlage und Kontext zusammensetzt, Validierung von Tool-Argumenten, Berechtigungsprüfungen. Diese Tests laufen in Millisekunden, kosten nichts und sind exakt reproduzierbar.

Das Modell selbst ersetzen Sie in dieser Ebene durch eine Attrappe, die vorbereitete Antworten liefert. In Python geht das etwa mit dem monkeypatch-Fixture von pytest, das laut Dokumentation genau für Code gedacht ist, der von Netzwerkzugriffen oder globalen Einstellungen abhängt.

# test_parser.py – Modellausgabe wird simuliert, nicht abgefragt
from agent.parser import parse_tool_call

def test_parser_akzeptiert_gueltigen_tool_call():
    raw = {"name": "lookup_article", "input": {"sku": "A-1042"}}
    call = parse_tool_call(raw)
    assert call.tool == "lookup_article"
    assert call.args["sku"] == "A-1042"

def test_parser_lehnt_fehlendes_pflichtfeld_ab():
    raw = {"name": "lookup_article", "input": {}}
    try:
        parse_tool_call(raw)
        assert False, "Fehlendes Pflichtfeld muss abgelehnt werden"
    except ValueError:
        pass

Besonders lohnend sind Tests für die Fehlerpfade: Was passiert, wenn das Modell ein Tool aufruft, das es nicht gibt, ein Feld im falschen Format liefert oder abbricht? Diese Fälle kommen im Betrieb vor, und der Code muss sie sauber abfangen.

Ebene 2: Komponententests einzelner Modellaufrufe

Auf der zweiten Ebene rufen Sie das echte Modell auf, aber nur für einen klar abgegrenzten Schritt: eine Klassifikation, eine Extraktion, die Auswahl eines Tools. Die Prüfung richtet sich auf Eigenschaften der Antwort, nicht auf den genauen Wortlaut – etwa „ist gültiges JSON", „enthält die Artikelnummer A-1042" oder „wählt das Tool lookup_article".

Werkzeuge wie promptfoo bieten dafür fertige Prüfungen. Die Liste der Assertions umfasst deterministische Prüfungen wie contains, regex, is-json, is-valid-function-call oder eigene python- und javascript-Funktionen, Prüfungen auf latency und cost sowie modellgestützte Prüfungen wie llm-rubric und factuality. Für Agenten gibt es außerdem Trajektorie-Prüfungen wie trajectory:tool-used und trajectory:tool-sequence.

Ebene 3: Integrationstests ganzer Läufe

Ein Integrationstest lässt den Agenten eine vollständige Aufgabe gegen Testsysteme erledigen: Testpostfach, ERP-Sandbox, Testordner im Dokumentenmanagement. Geprüft wird am Ende der Zustand des Zielsystems: Liegt ein Angebotsentwurf mit den richtigen Positionen vor, wurde nichts gelöscht, wurde keine Mail verschickt, die nur ein Entwurf hätte sein sollen?

Dieses Prinzip nutzt auch der Forschungs-Benchmark τ-bench: Er vergleicht den Datenbankzustand am Ende eines Gesprächs mit einem annotierten Zielzustand, statt den Gesprächsverlauf Wort für Wort zu bewerten.

Ebene 4: Regressions-Suite aus echten Fällen

Die oberste Ebene ist eine Sammlung echter Aufgaben, die der Agent schon einmal richtig gelöst hat oder an denen er gescheitert ist und die danach behoben wurden. Diese Suite läuft bei jeder relevanten Änderung. Ihr Zweck ist nicht, neue Fähigkeiten zu messen, sondern zu verhindern, dass Gelöstes wieder kaputtgeht.

Wie gehe ich mit nicht deterministischen Ausgaben um?

Mit nicht deterministischen Ausgaben gehen Sie um, indem Sie jeden Fall mehrfach ausführen und eine Erfolgsquote statt eines einzelnen Ergebnisses bewerten. Dazu kommen Prüfungen, die gültige Varianten zulassen: Sie prüfen Eigenschaften und Ergebnisse, nicht den exakten Text. So wird aus einem flackernden Test eine messbare Zuverlässigkeit.

Wiederholen und die richtige Kennzahl wählen

Zwei Kennzahlen haben sich etabliert. Laut Anthropic schätzt pass@k die Wahrscheinlichkeit, dass mindestens einer von k Versuchen gelingt, und pass^k die Wahrscheinlichkeit, dass alle k Versuche gelingen. Für einen Agenten, der einem Menschen einen Vorschlag macht, den dieser ohnehin prüft, kann pass@k ausreichen. Für einen Agenten, der eigenständig Tickets beantwortet oder Daten schreibt, zählt pass^k.

Der Unterschied ist erheblich: Bei einer Erfolgsquote von 75 % pro Versuch ergeben sich nach dem Rechenbeispiel von Anthropic über drei Versuche nur rund 42 % für pass^3. Die Autoren von τ-bench berichten, dass selbst damals aktuelle Agenten mit Funktionsaufrufen in der Domäne Einzelhandel ein pass^8 unter 25 % erreichten. Ein Agent, der „meistens" funktioniert, ist also oft weniger verlässlich, als ein einzelner erfolgreicher Testlauf vermuten lässt.

In promptfoo führt die Option --repeat laut Kommandozeilen-Dokumentation jeden Test mehrfach aus. Achten Sie darauf, dass dabei kein Antwort-Cache greift, sonst messen Sie dieselbe Antwort mehrfach; dafür gibt es --no-cache.

Ergebnis prüfen, nicht den Weg

Agenten finden häufig andere, ebenfalls gültige Wege zum Ziel. Anthropic rät in seinem Leitfaden zu Agenten-Evals, eher zu bewerten, was der Agent erzeugt hat, als den Weg dorthin. Ein Test, der eine feste Reihenfolge von Tool-Aufrufen verlangt, wird bei jeder harmlosen Verbesserung rot.

Den Weg prüfen Sie nur, wo er selbst Teil der Anforderung ist: Ein Freigabe-Tool muss vor dem Buchen aufgerufen werden, ein Löschwerkzeug darf in einem bestimmten Ablauf gar nicht vorkommen, personenbezogene Daten dürfen nicht an ein externes Tool gehen. Solche Regeln lassen sich als harte Prüfungen formulieren und gehören in jede Suite. Im Betrieb setzen Guardrails für KI-Agenten dieselben Regeln durch; der Test prüft, ob sie greifen.

Grader passend wählen

Für die Bewertung stehen drei Arten von Gradern zur Verfügung. Nach der Einordnung von Anthropic sind codebasierte Grader schnell, günstig und reproduzierbar, aber empfindlich gegenüber gültigen Abweichungen; modellbasierte Grader sind flexibel, aber selbst nicht deterministisch und müssen mit menschlichen Bewertungen abgeglichen werden; menschliche Bewertung gilt als Maßstab, ist aber langsam und teuer.

Die Faustregel für die Praxis: so viel wie möglich mit Code prüfen, ein Modell als Grader nur für das, was sich nicht in Regeln fassen lässt (Tonfall, Vollständigkeit einer Zusammenfassung), und menschliche Stichproben nutzen, um die Modell-Grader zu kalibrieren.

Welche Testarten passen zu welchem Agententyp?

Welche Testarten Gewicht bekommen, hängt davon ab, was der Agent tut. Ein lesender Recherche-Agent braucht vor allem Evals zur Antwortqualität und Quellentreue. Ein schreibender Agent, der Daten in Fachsysteme überträgt, braucht vor allem Integrationstests auf den Endzustand und harte Prüfungen der erlaubten Aktionen.

  • Wissens- und Recherche-Agenten (Fragen an Handbücher, Richtlinien, Projektakten): Schwerpunkt auf Evals zu Treffergenauigkeit der Suche und Treue der Antwort zu den gefundenen Dokumenten. Unit-Tests für das Zerlegen und Indizieren der Dokumente. Hintergrund zu solchen Agenten finden Sie unter KI-Agenten für Wissensmanagement.
  • Prozess-Agenten mit Schreibzugriff (Angebote, Tickets, Bestellungen): Schwerpunkt auf Integrationstests gegen Sandboxes, auf Prüfungen der Berechtigungen und auf pass^k für die Kernabläufe. Beispiele für solche Abläufe zeigt die Seite KI-Agenten für die Angebotserstellung.
  • Dialog-Agenten mit Kundenkontakt (Service, Vertrieb): zusätzlich simulierte Gesprächspartner, wie τ-bench sie verwendet, und Prüfungen auf Tonfall und Richtlinientreue, die meist ein Modell-Grader übernimmt.
  • Mehrstufige Agenten mit Unteragenten: zusätzlich Tests an den Übergabestellen – ob ein Unteragent die Information bekommt, die er braucht, und ob seine Antwort korrekt weiterverarbeitet wird.

Einen Überblick über die Einsatzfelder von Agenten insgesamt bietet die Seite KI-Agenten.

Welche Voraussetzungen braucht eine Teststrategie für Agenten?

Eine Teststrategie für Agenten braucht drei Dinge: eine Architektur, die Modellaufrufe von übrigem Code trennt, Testumgebungen für alle Systeme, auf die der Agent schreibt, und eine Sammlung realer Eingaben mit bekanntem richtigen Ergebnis. Fehlt eines davon, bleibt nur manuelles Ausprobieren.

Architektur

Der Modellaufruf sollte hinter einer schmalen Schnittstelle liegen, die sich im Test austauschen lässt. Tools sollten reine Funktionen mit klaren Ein- und Ausgaben sein, keine Methoden, die nebenbei globalen Zustand verändern. Jeder Agentenlauf sollte eine vollständige Aufzeichnung erzeugen: Eingabe, Prompts, Tool-Aufrufe mit Argumenten, Tool-Ergebnisse, Ausgabe. Diese Aufzeichnungen sind später das Rohmaterial für neue Testfälle.

Testumgebungen

Für Integrationstests brauchen Sie Systeme, in denen der Agent nichts Echtes kaputtmachen kann: eine ERP-Sandbox, ein Test-Postfach, eine Kopie der Dokumentenablage mit pseudonymisierten Daten. Wo es keine Sandbox gibt, helfen nachgebaute Schnittstellen, die das Verhalten des echten Systems für die getesteten Fälle nachbilden – mit dem Risiko, dass sie vom Original abweichen.

Testdaten

Die wertvollsten Testfälle stammen aus dem Betrieb: echte Anfragen, bei denen der Agent danebenlag, und echte Anfragen, die typisch für den Alltag sind. Anthropic empfiehlt, mit 20 bis 50 einfachen Aufgaben aus echten Fehlern zu beginnen, statt auf hunderte Fälle zu warten. Zu jedem Fall gehört eine eindeutige Definition, was als Erfolg zählt. Personenbezogene Daten in Testfällen sollten Sie pseudonymisieren, damit die Suite datenschutzkonform betreibbar bleibt.

Organisation

Jemand aus der Fachabteilung muss festlegen, was ein richtiges Ergebnis ist. Ein Entwickler kann nicht beurteilen, ob ein Angebotsentwurf die richtige Staffelung enthält oder ob eine Serviceantwort fachlich stimmt. Planen Sie diese Zeit fest ein, sonst fehlt der Eval-Suite die Grundlage.

Wie führe ich das Testen Schritt für Schritt ein?

Führen Sie das Testen in fünf Schritten ein: zuerst Unit-Tests für den deterministischen Code, dann eine kleine Eval-Suite aus echten Fällen, anschließend wiederholte Läufe mit einer Erfolgsquote, danach die Einbindung in die CI-Pipeline und zuletzt ein fester Ablauf, der jeden Fehler aus dem Betrieb in einen neuen Testfall verwandelt.

  1. Deterministischen Code isolieren und testen. Tools, Parser, Prompt-Aufbau und Validierung bekommen Unit-Tests mit simuliertem Modell. Diese Tests laufen bei jedem Commit.
  2. Erste Eval-Suite anlegen. 20 bis 50 echte Fälle, je mit Eingabe und Erfolgskriterium. Für jeden Fall entscheiden Sie: Prüfung per Code, per Modell-Grader oder per Stichprobe durch einen Menschen.
  3. Wiederholen und Kennzahl festlegen. Jeden Fall mehrfach laufen lassen und festlegen, ob pass@k oder pass^k zählt. Für Abläufe mit Schreibzugriff setzen Sie eine Mindestquote, unter der kein Release erfolgt.
  4. In die CI einbinden. Die schnelle Regressions-Suite läuft bei jeder Änderung an Prompt, Modellversion, Tool-Schema oder Abrufkonfiguration. Größere Suiten mit vielen Wiederholungen laufen nächtlich oder vor einem Release, damit Zeit und API-Kosten im Rahmen bleiben.
  5. Fehler aus dem Betrieb zurückführen. Jede falsche Antwort im Betrieb wird mit ihrer Aufzeichnung zum Testfall. So wächst die Suite entlang der tatsächlichen Schwachstellen.

Zwei Arten von Evals sollten Sie dabei bewusst trennen. Anthropic unterscheidet Fähigkeits-Evals, die mit niedriger Erfolgsquote starten, von Regressions-Evals, die nahezu immer bestehen sollten. Fähigkeits-Evals zeigen, woran Sie arbeiten. Regressions-Evals schützen, was schon funktioniert. Sobald ein Fähigkeits-Eval zuverlässig besteht, wandert es in die Regressions-Suite.

Ein Tipp aus unserem eigenen Betrieb: Lesen Sie am Anfang die Aufzeichnungen fehlgeschlagener Läufe selbst, bevor Sie die Grader anpassen. Oft liegt der Fehler nicht beim Agenten, sondern beim Grader, der eine gültige Lösung ablehnt. Anthropic betont denselben Punkt: Ob Ihre Grader richtig arbeiten, sehen Sie nur, wenn Sie Aufzeichnungen und Bewertungen vieler Läufe lesen.

Wo liegen die Grenzen und Risiken?

Tests senken das Risiko, schließen Fehler aber nicht aus. Eine Eval-Suite misst nur die Fälle, die in ihr stehen; seltene Eingaben, neue Anfragearten und schleichend veränderte Daten bleiben unsichtbar. Dazu kommen Kosten für wiederholte Modellaufrufe und die Gefahr, dass Grader selbst falsch bewerten.

  • Abdeckung: Eine Suite aus 50 Fällen sagt wenig über Fall Nummer 51. Ergänzen Sie Tests deshalb um Überwachung im Betrieb: Stichproben, Rückmeldungen von Nutzern, Alarme bei ungewöhnlichen Tool-Aufrufen – wie das im laufenden Betrieb aussieht, beschreibt AgentOps: KI-Agenten zuverlässig betreiben.
  • Grader-Fehler: Modellbasierte Grader können zu großzügig oder zu streng sein. Gleichen Sie sie regelmäßig mit menschlichen Bewertungen ab.
  • Überanpassung: Wer Prompts so lange dreht, bis genau die Testfälle bestehen, verbessert die Suite, nicht den Agenten. Halten Sie einen Teil der Fälle zurück, der nicht zum Tuning verwendet wird.
  • Kosten und Laufzeit: Viele Wiederholungen mit großen Modellen kosten Geld und Zeit. Trennen Sie schnelle Suiten für jeden Commit von großen Suiten für Releases.
  • Veraltete Testsysteme: Nachgebaute Schnittstellen und Sandboxes weichen mit der Zeit vom echten System ab. Ein grüner Integrationstest gegen eine veraltete Attrappe ist trügerisch.
  • Wechsel der Modellversion: Ein neues Modell kann insgesamt besser abschneiden und trotzdem einzelne Fälle verlieren, die vorher sicher waren. Genau dafür gibt es die Regressions-Suite; führen Sie sie vor jedem Modellwechsel vollständig aus.

Wann der Aufwand nicht passt: Bei einem Prototyp, der nur Entwürfe für Menschen erzeugt und in wenigen Wochen wieder verworfen wird, genügen Unit-Tests für die Tools und eine Handvoll manueller Prüfungen. Eine vollständige Pyramide lohnt sich, sobald der Agent dauerhaft läuft oder in Systeme schreibt.

Wie fange ich an?

Fangen Sie mit dem Agenten an, der am häufigsten läuft oder in die wichtigsten Systeme schreibt. Sammeln Sie dafür eine Woche lang echte Eingaben und die Fälle, in denen Nutzer korrigieren mussten. Daraus entstehen die ersten Unit-Tests für die Fehlerpfade und die ersten zwanzig Eval-Fälle.

Ein pragmatischer erster Tag sieht so aus:

  1. Aufzeichnung aller Agentenläufe einschalten, falls sie noch fehlt.
  2. Die drei wichtigsten Tools mit Unit-Tests abdecken, einschließlich ungültiger Argumente.
  3. Zehn echte Fälle mit klarem Erfolgskriterium aufschreiben und jeden fünfmal laufen lassen.
  4. Die Erfolgsquote pro Fall notieren und die Fälle mit schwankendem Ergebnis zuerst untersuchen.

Danach wächst die Suite mit jedem Fehler aus dem Betrieb. Wie Sie Qualitätskriterien und Grader im Detail definieren, beschreibt der Artikel Evals für KI-Agenten. Wenn Sie erst klären möchten, welcher Agent sich in Ihrem Unternehmen überhaupt lohnt, finden Sie auf der Seite KI-Agenten die typischen Einsatzfelder im Überblick.

Stand der genannten Quellen und Werkzeuge: November 2026.

Häufige Fragen

Reicht es, die Temperatur auf 0 zu setzen, um Agenten deterministisch zu testen?

Darauf sollten Sie sich nicht verlassen. Spätestens eine neue Modellversion, ein geänderter Prompt oder anderer Kontext verändert die Ausgaben, deshalb sollten Tests mit Varianz umgehen, statt sie wegzudefinieren.

Wie viele Testfälle braucht eine erste Eval-Suite?

Anthropic empfiehlt, mit 20 bis 50 einfachen Aufgaben aus echten Fehlern zu beginnen. Wichtiger als die Menge ist, dass die Fälle reale Eingaben abbilden und eindeutig bewertbar sind.

Gehören Evals in die CI-Pipeline?

Die schnelle Regressions-Suite ja, bei jeder Änderung an Prompt, Modell oder Tool-Schema. Größere Fähigkeits-Evals mit vielen Wiederholungen laufen besser nächtlich oder vor einem Release, weil sie Zeit und API-Kosten verursachen.

Soll ich den Weg des Agenten oder nur das Ergebnis prüfen?

In erster Linie das Ergebnis, etwa den Zustand im Zielsystem. Den Weg prüfen Sie nur dort, wo er selbst eine Regel ist, zum Beispiel wenn ein Freigabe-Tool vor dem Buchen aufgerufen werden muss.

Quellen

  1. Anthropic Engineering: Demystifying evals for AI agents (Januar 2026) anthropic.com
  2. Yao et al.: τ-bench – A Benchmark for Tool-Agent-User Interaction in Real-World Domains arxiv.org
  3. promptfoo: Assertions and metrics promptfoo.dev
  4. promptfoo: Command line promptfoo.dev
  5. pytest: How to monkeypatch/mock modules and environments docs.pytest.org