Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Evalueer uw agents: metrieken en benchmarks

Les 22 van 25 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Evalueer uw agents: metrieken en benchmarks
  2. Waarom evalueren?
  3. Kernmetrieken
  4. LLM-evaluatie (LLM-as-Judge)
  5. Gestructureerde testsuites
  6. Belangrijkste punten

Evalueer uw agents: metrieken en benchmarks

Een agent die in de ontwikkelomgeving werkt, kan in productie falen. Systematische evaluatie is de enige manier om kwaliteit te garanderen, zowel voor als na de implementatie. In deze les leert u hoe u metrieken definieert, testsuites maakt en evaluatie automatiseert.

Waarom evalueren?

Zonder formele evaluatie vliegt u blind. U herformuleert een instructie omdat een gebruiker klaagde, maar niets vertelt u of de agent daadwerkelijk is verbeterd of dat u juist drie andere scenario’s hebt verbroken. U twijfelt tussen Terra en Luna voor uw use case—of tussen twee redeneerniveaus op hetzelfde model—en zonder meting berust de beslissing op een onderbuikgevoel na vijf handmatige proeven. U wijzigt een toolschema, de agent roept het in een specifiek geval niet meer aan, en niemand merkt het totdat het aantal tickets explodeert. Een evaluatiesuite zet elk van deze situaties om in een vergelijkbaar getal van de ene versie naar de andere.

Kernmetrieken

Nauwkeurigheid

De eerste vraag is het meest direct: geeft de agent het juiste antwoord? U speelt een reeks vragen af waarvan u het antwoord kent en verifieert de aanwezigheid ervan in de output. Hoofdletterongevoelige substring-matching is bewust grof—het tolereert “De Pro-laptop kost € 1.299 incl. btw” waar strikte gelijkheid zou falen—maar het volstaat voor verifieerbare feiten en berekent binnen een seconde.

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 of op LLM gebaseerde verificatie
        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"Nauwkeurigheid: {rate:.1%} ({sum(1 for r in results if r['correct'])}/{len(results)})")
    return results

# Testsuite
test_cases = [
    {"question": "Wat is de prijs van de Pro-laptop?", "expected_answer": "1299"},
    {"question": "Hoeveel laptops zijn er op voorraad?", "expected_answer": "45"},
    {"question": "Wat is het goedkoopste product?", "expected_answer": "tablet"},
]

Correct toolgebruik

Een correct antwoord dat bij toeval tot stand komt, blijft een probleem. Een agent die een uit het hoofd geleerde prijs opdreunt in plaats van de catalogus te raadplegen, slaagt vandaag voor de nauwkeurigheidstest en geeft morgen een verouderd tarief. De tweede metriek kijkt daarom naar het pad, niet naar het resultaat: roept de agent de juiste tools aan met de juiste argumenten? U leest de aanroepen in raw_responses, filtert op function_call-outputs, en de vergelijking gebruikt sets om ongevoelig te blijven voor de volgorde.

async def evaluate_tools(agent, test_cases):
    results = []
    for case in test_cases:
        result = await Runner.run(agent, case["question"])

        # Aangeroepen tools extraheren uit ruwe responses
        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"Correcte tools: {rate:.1%}")
    return results

tool_cases = [
    {
        "question": "Wat is de prijs van de laptop?",
        "expected_tools": ["search_product"],
    },
    {
        "question": "Prijs van de laptop met 10% korting",
        "expected_tools": ["search_product", "calculate_discount"],
    },
]

Het tweede testgeval is het meest instructief: de vraag vereist het ketenen van twee tools, en dit is precies het soort compositie dat een wijziging in de beschrijving stilletjes kan breken.

Latentie en kosten

Tot slot is er de operationele dimensie. Een gemiddelde zegt niets over de echte ervaring: het is de staart van de verdeling die gebruikers wegjaagt, wanneer één op de honderd verzoeken twintig seconden duurt. Door elk bericht meerdere keren te herhalen, verkrijgt u een bruikbare verdeling en leest u de mediaan als het typische gedrag, en de P99 als uw gebruikelijke worstcasescenario.

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"Gemiddelde latentie: {statistics.mean(latencies):.2f}s")
    print(f"P50-latentie: {statistics.median(latencies):.2f}s")
    print(f"P99-latentie: {sorted(latencies)[int(len(latencies) * 0.99)]:.2f}s")

LLM-evaluatie (LLM-as-Judge)

Deze drie metrieken laten alles buiten beschouwing waarvoor geen enkel juist antwoord bestaat: een uitleg van een retourbeleid, een herschrijving voor verkoop, een verontschuldigingsbericht. Gebruik voor deze open antwoorden een model om de kwaliteit te evalueren. De rechter ontvangt de vraag en het antwoord, past criteria toe die u hebt geschreven—nauwkeurigheid, relevantie, professionalisme—en retourneert een gestructureerde score dankzij een Pydantic output_type. De formaatbeperking is wat het proces bruikbaar maakt: u krijgt een aggregeerbaar geheel getal, geen commentaar om opnieuw te lezen.

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="""Evalueer de kwaliteit van het antwoord van de agent.
    Criteria:
    - Nauwkeurigheid: Is het antwoord feitelijk en correct?
    - Relevantie: Beantwoordt het antwoord de gestelde vraag?
    - Professionalisme: Is de toon passend?
    Score van 1 (zeer slecht) tot 5 (uitstekend).""",
    model="gpt-5.6-sol",
    output_type=Evaluation,
)

async def evaluate_quality(question, agent_response):
    prompt = f"""Gestelde vraag: {question}
    Antwoord van de agent: {agent_response}
    Evalueer dit antwoord."""

    result = await Runner.run(evaluator_agent, prompt)
    return result.final_output

Het veld reason verdient uw aandacht tijdens reviews: hier legt de rechter uit waarom hij een 3 van de 5 gaf, en het is vaak de formulering van een gebrek dat u niet had kunnen benoemen.

Gestructureerde testsuites

Een evaluatie die niet reproduceerbaar is, is nutteloos. Organiseer uw testgevallen in een stabiel formaat waarbij elke entry een ID, een categorie, de vraag, het verwachte antwoord, de verwachte tools en kwalitatieve criteria bevat. De categorie doet hier al het werk: een totaalscore van 4,2 op 5 is misleidend geruststellend, terwijl een gedetailleerde score onthult dat de categorie “voorraad” instort tot 2,8 terwijl “prijs” het gemiddelde omhoog trekt.

import json

# evaluation_dataset.json
DATASET = [
    {
        "id": "test_001",
        "category": "price",
        "question": "Wat is de prijs van de Pro-laptop?",
        "expected_answer": "€ 1.299",
        "expected_tools": ["search_product"],
        "criteria": ["contains_price", "professional_tone"],
    },
    {
        "id": "test_002",
        "category": "stock",
        "question": "Is de Tablet Air op voorraad?",
        "expected_answer": "ja",
        "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,
        })

    # Rapport
    average_score = sum(r["score"] for r in results) / len(results)
    print(f"\nGemiddelde 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

Voer deze evaluatie uit in uw continuous integration-pipeline, net als uw unit-tests, en stel een drempelwaarde in waaronder oplevering wordt geblokkeerd. Vanaf dat moment vergelijkt elke wijziging—nieuw model, aangepaste instructies, toegevoegde tool—zich met de vorige op dezelfde gevallen, en draait de discussie niet langer om impressies.

Belangrijkste punten

  • Evalueer nauwkeurigheid, toolgebruik, latentie en kosten
  • LLM-evaluatie (LLM-as-Judge) handelt open antwoorden af
  • Maak gestructureerde en reproduceerbare testsuites
  • Automatiseer evaluatie in uw CI/CD om regressies op te sporen
  • Vergelijk wijzigingen (model, instructies, tools) systematisch