Du hast fünfzig Zeilen Python geschrieben. Ein System-Prompt, eine Tool-Liste, ein Model-Call. Dein Agent bucht Meetings, fragt Datenbanken ab, verschickt E-Mails. Läuft wunderbar in deinem Terminal. Ausliefern?

Öffne erst mal deine Testdatei. Na los. Versuch mal, einen Test für etwas zu schreiben, das jedes Mal eine andere Antwort gibt.

Das Nichtdeterminismus-Problem, über das niemand reden will

So sieht ein normaler Python-Test aus:

def test_add():
    assert add(2, 2) == 4  # deterministisch. immer 4.

Und so sieht ein Agent-Test aus:

def test_booking_agent():
    result = agent.run("Book a room for tomorrow 2pm")
    assert result == ???  # was kommt hier hin?
    # Der Agent sagt vielleicht "Done! Booked room A at 2pm"
    # oder "I've reserved conference room A for tomorrow at 14:00"
    # oder "Booked! Room A, April 27, 2:00 PM"
    # Alles korrekt. Alles unterschiedliche Strings.

Ein LLM — das Hirn hinter ChatGPT, Claude, Gemini — ist nichtdeterministisch. Gleicher Input, anderer Output. Jedes Mal. Dein assertEqual ist wertlos. Das ist kein Bug. Das ist die fundamentale Eigenschaft, die Agents überhaupt nützlich macht. Und genau sie macht es nahezu unmöglich, Agents mit den Werkzeugen zu testen, auf die sich Entwickler seit Jahrzehnten verlassen.

Drei SDKs in einem Monat. Null Test-Commands.

Drei große Agent-SDKs — Baukästen zum Erstellen von KI-Agenten — sind im April erschienen. Anthropic startete die Managed Agents API am 8. April. OpenAI aktualisierte ihr Agents SDK am 15. April. Google lieferte ADK 1.0 zusammen mit Agent Simulation auf der Cloud Next am 22. April. Alle drei geben dir Build-and-Run-Primitives an die Hand. Keines enthält einen Test-Command.

Das ist kein Vergleich dreier Anbieter. Das ist ein Muster. Die gesamte Branche — jedes große KI-Labor — hat entschieden, dass Testen dein Problem ist.

Was sie stattdessen anbieten

Google kam am nächsten. Auf der Cloud Next kündigten sie Agent Evaluation an — einen Cloud-Service, der deinen Agent nach Task-Completion, Tool-Nutzung und Safety bewertet. Ernsthaft nützlich für systemweite Metriken. Aber es läuft auf Vertex AI, kostet je nach Komplexität ungefähr $0,50–2,00 pro Evaluation und braucht Minuten. Lass das mal pro Pull Request in einem aktiven Repo laufen, und du schaust auf $300+ pro Monat an Eval-Gebühren — vor den eigentlichen API-Kosten. Das ist kein Unit-Test. Das ist ein Abrechnungsereignis.

Anthropics Managed Agents API bietet Tracing — ein Protokoll jedes Schritts, den dein Agent gemacht hat — aber null Test-Utilities. Kein Mock-Model, keine Response-Aufzeichnung, keine Assertion-Helpers.

OpenAI bietet einen seed-Parameter für partielle Reproduzierbarkeit, aber "partiell" heißt "manchmal der gleiche Output, manchmal nicht." Versuch mal, CI/CD — automatisierte Deployment-Pipelines — auf "manchmal" aufzubauen.

Das Behavioral-Assertion-Pattern

Die Community hat einen Workaround gefunden. Statt auf exakten Text zu prüfen, prüfst du auf Verhaltensmuster — welche Tools der Agent aufgerufen hat, in welcher Reihenfolge, und ob er aufgehört hat, als er sollte:

def test_booking_agent_behavior(recorded_responses):
    trace = agent.run("Book a room for tomorrow 2pm")
    
    # Assert auf Tool Calls, nicht auf Text-Output
    assert trace.tool_calls[0].name == "check_availability"
    assert trace.tool_calls[1].name == "create_booking"
    assert "room" in trace.tool_calls[1].args
    assert trace.completed  # keine Endlosschleife

Open-Source-Projekte wie DeepEval und Promptfoo treiben diesen Ansatz voran. Keines davon integriert sich nativ mit einem der drei SDKs. Du klebst dir das selbst zusammen.

Jeder Workaround hat seinen Preis

Model mocken? Dann verlierst du das LLM-Reasoning, das Agents wertvoll macht — du testest eine Marionette, keinen Agent. Snapshot-Tests — eine exakte Antwort aufzeichnen und später dagegen vergleichen? Die brechen bei jedem Model-Update oder Prompt-Tweak. Cloud-Evaluations? Minuten und Dollar pro Pull Request. Behavioral Assertions? Schwer zu schreiben, noch schwerer zu pflegen, und du bastelst dir im Grunde ein Testing-Framework von Null für jedes Projekt.

Die grundlegende Spannung: Entwickler haben Test-Tools für deterministische Software gebaut. Agents sind weder deterministisch noch, streng genommen, Software im herkömmlichen Sinne. Es sind stochastische Systeme im Software-Kostüm.

Was du jetzt konkret tun kannst

Kein Anbieter wird dich retten. Das hier funktioniert — bei voller Anerkennung der Absurdität, dass du 2026 Test-Infrastruktur erfindest, weil drei Billionen-Dollar-Konzerne keinen Bock hatten:

  1. Echte LLM-Antworten als Golden Fixtures aufzeichnen — gespeicherte, bekannt gute Antworten, die du in Tests abspielst, statt jedes Mal das Model aufzurufen. Ja, du baust dir Test-Klempnerei von Hand, die das SDK hätte mitliefern sollen. Nein, die Ironie geht nicht verloren.

  2. Auf Tool-Call-Sequenzen prüfen, nicht auf den finalen Text. Hat der Agent check_availability vor create_booking aufgerufen? Reicht. Dein assertEqual-trainiertes Hirn wird schreien. Lass es.

  3. Smoke-Tests gegen echte Models per täglichem Cron laufen lassen, nicht pro Pull Request. Model-Drift erkennen, ohne dein CI-Budget zu verbrennen.

  4. Agent-Tests wie Integrationstests behandeln — langsamer, weniger, höherer Wert — nicht wie Unit-Tests. Fünf gute Behavioral-Tests schlagen fünfzig brüchige Snapshot-Tests. Jeder, der dir sagt "schreib einfach mehr Tests", hat noch nie versucht, etwas zu testen, das bei jedem Durchlauf ein anderes Haiku über Raumbuchungen generiert.

# Praxistauglich: Record & Replay Pattern
import json

def record_golden_fixture(agent, prompt, path):
    """Einmal gegen das echte Model laufen, Trace speichern."""
    trace = agent.run(prompt)
    with open(path, "w") as f:
        json.dump(trace.to_dict(), f)
    return trace

def test_from_fixture(mock_agent, fixture_path):
    """Gespeicherten Trace abspielen, auf Struktur prüfen."""
    with open(fixture_path) as f:
        golden = json.load(f)
    mock_agent.load_trace(golden)
    result = mock_agent.replay()
    assert [c["name"] for c in result.tool_calls] == [
        "check_availability", "create_booking"
    ]

Der Anbieter, der agent test als Erster ausliefert, gewinnt

Django hat Web-Entwickler mit manage.py test eingefangen. Rails hat es mit rails test gemacht. Das erste Agent-SDK, das Testing zum Standard-Primitive macht — nicht als Cloud-Upsell für $0,50 pro Durchlauf, nicht als Third-Party-Addon, sondern als lokaler Command, der offline funktioniert — erobert die Entwicklerebene jenseits von Modellqualität und Tool-Anzahl.

Der untestbare Agent ist der neue ungetestete Microservice. Jeder liefert ihn aus. Jeder bereut es sechs Monate später. Gerade existiert dieser agent test-Command in keinem der drei großen SDKs.

Deine Testdatei ist immer noch leer.