Ihre Agenten evaluieren: Metriken und Benchmarks
Auf dieser Seite
Ihre Agenten evaluieren: Metriken und Benchmarks
Ein Agent, der in der Entwicklung funktioniert, kann in der Produktion versagen. Systematische Evaluation ist der einzige Weg, um Qualität vor und nach dem Einsatz zu garantieren. In dieser Lektion erfahren Sie, wie Sie Metriken definieren, Testsuiten erstellen und die Evaluation automatisieren.
Warum evaluieren?
Ohne formelle Evaluation fliegen Sie im Blindflug. Sie formulieren eine Anweisung neu, weil sich ein Nutzer beschwert hat, aber nichts sagt Ihnen, ob der Agent sich verbessert hat oder ob Sie einfach drei andere Szenarien kaputt gemacht haben. Sie zögern zwischen Terra und Luna für Ihren Anwendungsfall – oder zwischen zwei Denkstufen desselben Modells – und ohne Messung beruht die Entscheidung auf einem Bauchgefühl nach fünf manuellen Versuchen. Sie ändern ein Tool-Schema, der Agent ruft es in einem bestimmten Fall nicht mehr auf, und niemand merkt es, bis die Ticketzahlen ansteigen. Eine Evaluationssuite verwandelt jede dieser Situationen in eine vergleichbare Zahl von einer Version zur nächsten.
Kernmetriken
Genauigkeit
Die erste Frage ist die direkteste: Gibt der Agent die richtige Antwort? Sie spielen eine Reihe von Fragen nach, bei denen Sie die Antwort kennen, und überprüfen deren Vorhandensein in der Ausgabe. Fallunabhängige Teilstring-Übereinstimmung ist absichtlich grob – sie toleriert „The Pro laptop costs €1,299 incl. tax”, wo eine strikte Gleichheit scheitern würde –, aber sie reicht für überprüfbare Fakten aus und berechnet sich in einer Sekunde.
from agents import Agent, Runner
async def evaluate_accuracy(agent, test_cases):
results = []
for case in test_cases:
result = await Runner.run(agent, case["question"])
# Automatische oder LLM-basierte Verifizierung
is_correct = case["expected_answer"].lower() in result.final_output.lower()
results.append({
"question": case["question"],
"answer": result.final_output,
"expected": case["expected_answer"],
"correct": is_correct,
})
rate = sum(1 for r in results if r["correct"]) / len(results)
print(f"Genauigkeit: {rate:.1%} ({sum(1 for r in results if r['correct'])}/{len(results)})")
return results
# Testsuite
test_cases = [
{"question": "What is the price of the Pro laptop?", "expected_answer": "1299"},
{"question": "How many laptops are in stock?", "expected_answer": "45"},
{"question": "What is the cheapest product?", "expected_answer": "tablet"},
]
Korrekte Tool-Nutzung
Eine richtige Antwort, die zufällig zustande kommt, bleibt ein Problem. Ein Agent, der einen memorisierten Preis rezitiert, anstatt den Katalog abzufragen, besteht heute den Genauigkeitstest und liefert morgen einen veralteten Satz. Die zweite Metrik betrachtet daher den Weg, nicht das Ergebnis: Ruft der Agent die richtigen Tools mit den richtigen Argumenten auf? Sie lesen die Aufrufe in raw_responses, filtern nach function_call-Ausgaben, und der Vergleich verwendet Mengen, um unabhängig von der Reihenfolge zu bleiben.
async def evaluate_tools(agent, test_cases):
results = []
for case in test_cases:
result = await Runner.run(agent, case["question"])
# Aus den rohen Antworten aufgerufene Tools extrahieren
called_tools = []
for response in result.raw_responses:
for output in getattr(response, "output", []):
if hasattr(output, "type") and output.type == "function_call":
called_tools.append(output.name)
tools_correct = set(case["expected_tools"]) == set(called_tools)
results.append({
"question": case["question"],
"called_tools": called_tools,
"expected_tools": case["expected_tools"],
"correct": tools_correct,
})
rate = sum(1 for r in results if r["correct"]) / len(results)
print(f"Korrekte Tools: {rate:.1%}")
return results
tool_cases = [
{
"question": "What is the price of the laptop?",
"expected_tools": ["search_product"],
},
{
"question": "Price of the laptop with 10% discount",
"expected_tools": ["search_product", "calculate_discount"],
},
]
Der zweite Testfall ist der lehrreichste: Die Frage erfordert das Verkettieren zweier Tools, und genau diese Art von Komposition kann durch eine Änderung der Beschreibung stumm unterbrochen werden.
Latenz und Kosten
Schließlich gibt es die operative Dimension. Ein Durchschnitt sagt nichts über die reale Erfahrung aus: Es ist der Schwanz der Verteilung, der Nutzer wegbekommt, wenn eine von hundert Anfragen zwanzig Sekunden dauert. Durch mehrfaches Wiederholen jeder Nachricht erhalten Sie eine nutzbare Verteilung und lesen den Median als typisches Verhalten und die P99 als Ihren üblichen Worst-Case-Szenario.
import time
async def evaluate_performance(agent, messages, iterations=10):
latencies = []
for message in messages:
for _ in range(iterations):
start = time.perf_counter()
result = await Runner.run(agent, message)
duration = time.perf_counter() - start
latencies.append(duration)
import statistics
print(f"Durchschnittliche Latenz: {statistics.mean(latencies):.2f}s")
print(f"P50 Latenz: {statistics.median(latencies):.2f}s")
print(f"P99 Latenz: {sorted(latencies)[int(len(latencies) * 0.99)]:.2f}s")
LLM-Evaluation (LLM-as-Judge)
Diese drei Metriken lassen alles außer Acht, was keine einzelne richtige Antwort hat: eine Erklärung einer Rückgabepolitik, eine Umschreibung eines Verkaufsarguments, eine Entschuldigungsmitteilung. Für diese offenen Antworten verwenden Sie ein Modell, um die Qualität zu bewerten. Der Richter erhält die Frage und die Antwort, wendet Kriterien an, die Sie geschrieben haben – Genauigkeit, Relevanz, Professionalität – und gibt dank eines Pydantic output_type eine strukturierte Punktzahl zurück. Die Formatbeschränkung ist es, was den Prozess nutzbar macht: Sie erhalten eine aggregierbare ganze Zahl, keinen Kommentar, den Sie erneut lesen müssen.
from pydantic import BaseModel
class Evaluation(BaseModel):
score: int # 1-5
reason: str
is_correct: bool
is_relevant: bool
is_professional: bool
evaluator_agent = Agent(
name="Evaluator",
instructions="""Evaluate the quality of the agent's response.
Criteria:
- Accuracy: Is the response factual and correct?
- Relevance: Does the response answer the question asked?
- Professionalism: Is the tone appropriate?
Score from 1 (very poor) to 5 (excellent).""",
model="gpt-5.6-sol",
output_type=Evaluation,
)
async def evaluate_quality(question, agent_response):
prompt = f"""Question asked: {question}
Agent response: {agent_response}
Evaluate this response."""
result = await Runner.run(evaluator_agent, prompt)
return result.final_output
Das Feld reason verdient Ihre Aufmerksamkeit während der Reviews: Hier erklärt der Richter, warum er eine 3 von 5 gegeben hat, und es ist oft die Formulierung eines Mangels, den Sie nicht benennen konnten.
Strukturierte Testsuiten
Eine Evaluation, die nicht reproduzierbar ist, ist nutzlos. Ordnen Sie Ihre Testfälle in einem stabilen Format an, bei dem jeder Eintrag eine ID, eine Kategorie, die Frage, die erwartete Antwort, die erwarteten Tools und qualitative Kriterien trägt. Die Kategorie erledigt hier die ganze Arbeit: Ein Gesamtscore von 4,2 von 5 ist irreführend beruhigend, wohingegen ein detaillierter Score zeigt, dass die Kategorie „Lagerbestand” auf 2,8 zusammenbricht, während „Preis” den Durchschnitt nach oben zieht.
import json
# evaluation_dataset.json
DATASET = [
{
"id": "test_001",
"category": "price",
"question": "What is the price of the Pro laptop?",
"expected_answer": "€1,299",
"expected_tools": ["search_product"],
"criteria": ["contains_price", "professional_tone"],
},
{
"id": "test_002",
"category": "stock",
"question": "Is the Tablet Air in stock?",
"expected_answer": "yes",
"expected_tools": ["search_product"],
"criteria": ["clear_answer", "stock_information"],
},
]
async def run_complete_evaluation(agent):
results = []
for case in DATASET:
result = await Runner.run(agent, case["question"])
eval_result = await evaluate_quality(case["question"], result.final_output)
results.append({
**case,
"agent_response": result.final_output,
"score": eval_result.score,
"evaluation": eval_result.reason,
})
# Bericht
average_score = sum(r["score"] for r in results) / len(results)
print(f"\nDurchschnittlicher Score: {average_score:.1f}/5")
for cat in set(r["category"] for r in results):
cat_scores = [r["score"] for r in results if r["category"] == cat]
print(f" {cat}: {sum(cat_scores)/len(cat_scores):.1f}/5")
return results
Führen Sie diese Evaluation in Ihrer Continuous-Integration-Pipeline durch, genau wie Ihre Unit-Tests, und setzen Sie eine Schwelle, unterhalb derer die Lieferung blockiert wird. Ab dann vergleicht jede Änderung – neues Modell, angepasste Anweisungen, hinzugefügtes Tool – mit der vorherigen auf denselben Fällen, und die Diskussion dreht sich nicht mehr um Eindrücke.
Kernaussagen
- Evaluieren Sie Genauigkeit, Tool-Nutzung, Latenz und Kosten
- LLM-Evaluation (LLM-as-Judge) bewältigt offene Antworten
- Erstellen Sie strukturierte und reproduzierbare Testsuiten
- Automatisieren Sie die Evaluation in Ihrem CI/CD, um Regressionen zu erkennen
- Vergleichen Sie Änderungen systematisch (Modell, Anweisungen, Tools)