Évaluer vos agents : métriques et benchmarks

Un agent qui fonctionne en développement peut échouer en production. L’évaluation systématique est la seule façon de garantir la qualité avant et après le déploiement. Dans cette leçon, vous apprendrez à définir des métriques, créer des jeux de test, et automatiser l’évaluation.

Pourquoi évaluer ?

Sans évaluation formelle, vous volez à l’aveugle :

Comment savoir si un changement d’instructions améliore ou dégrade l’agent ?
Comment comparer GPT-5.3 vs o4-mini pour votre cas d’usage ?
Comment détecter une régression après un changement de tool ?

Les métriques fondamentales

Exactitude (Accuracy)

L’agent donne-t-il la bonne réponse ?

from agents import Agent, Runner

async def evaluer_exactitude(agent, cas_de_test):
    resultats = []
    for cas in cas_de_test:
        result = await Runner.run(agent, cas["question"])
        # Vérification automatique ou par LLM
        est_correct = cas["reponse_attendue"].lower() in result.final_output.lower()
        resultats.append({
            "question": cas["question"],
            "reponse": result.final_output,
            "attendu": cas["reponse_attendue"],
            "correct": est_correct,
        })

    taux = sum(1 for r in resultats if r["correct"]) / len(resultats)
    print(f"Exactitude : {taux:.1%} ({sum(1 for r in resultats if r['correct'])}/{len(resultats)})")
    return resultats

# Jeu de test
cas_de_test = [
    {"question": "Quel est le prix du laptop pro ?", "reponse_attendue": "1299"},
    {"question": "Combien de laptops en stock ?", "reponse_attendue": "45"},
    {"question": "Quel est le produit le moins cher ?", "reponse_attendue": "tablet"},
]

Utilisation correcte des tools

L’agent appelle-t-il les bons tools avec les bons arguments ?

async def evaluer_tools(agent, cas_de_test):
    resultats = []
    for cas in cas_de_test:
        result = await Runner.run(agent, cas["question"])

        # Extraire les tools appelés depuis les raw responses
        tools_appeles = []
        for response in result.raw_responses:
            for output in getattr(response, "output", []):
                if hasattr(output, "type") and output.type == "function_call":
                    tools_appeles.append(output.name)

        tools_corrects = set(cas["tools_attendus"]) == set(tools_appeles)
        resultats.append({
            "question": cas["question"],
            "tools_appeles": tools_appeles,
            "tools_attendus": cas["tools_attendus"],
            "correct": tools_corrects,
        })

    taux = sum(1 for r in resultats if r["correct"]) / len(resultats)
    print(f"Tools corrects : {taux:.1%}")
    return resultats

cas_tools = [
    {
        "question": "Quel est le prix du laptop ?",
        "tools_attendus": ["rechercher_produit"],
    },
    {
        "question": "Prix du laptop avec 10% de remise",
        "tools_attendus": ["rechercher_produit", "calculer_remise"],
    },
]

Latence et coût

import time

async def evaluer_performance(agent, messages, iterations=10):
    latences = []
    for message in messages:
        for _ in range(iterations):
            debut = time.perf_counter()
            result = await Runner.run(agent, message)
            duree = time.perf_counter() - debut
            latences.append(duree)

    import statistics
    print(f"Latence moyenne : {statistics.mean(latences):.2f}s")
    print(f"Latence P50 : {statistics.median(latences):.2f}s")
    print(f"Latence P99 : {sorted(latences)[int(len(latences) * 0.99)]:.2f}s")

Évaluation par LLM (LLM-as-Judge)

Pour les réponses ouvertes, utilisez un modèle pour évaluer la qualité :

from pydantic import BaseModel

class Evaluation(BaseModel):
    score: int  # 1-5
    raison: str
    est_correct: bool
    est_pertinent: bool
    est_professionnel: bool

agent_evaluateur = Agent(
    name="Évaluateur",
    instructions="""Évaluez la qualité de la réponse de l'agent.
    Critères :
    - Exactitude : la réponse est-elle factuelle et correcte ?
    - Pertinence : la réponse répond-elle à la question posée ?
    - Professionnalisme : le ton est-il approprié ?
    Score de 1 (très mauvais) à 5 (excellent).""",
    model="gpt-5.4",
    output_type=Evaluation,
)

async def evaluer_qualite(question, reponse_agent):
    prompt = f"""Question posée : {question}
    Réponse de l'agent : {reponse_agent}
    Évaluez cette réponse."""

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

Jeux de test structurés

Organisez vos cas de test dans un format reproductible :

import json

# evaluation_dataset.json
DATASET = [
    {
        "id": "test_001",
        "categorie": "prix",
        "question": "Quel est le prix du laptop pro ?",
        "reponse_attendue": "1299€",
        "tools_attendus": ["rechercher_produit"],
        "criteres": ["contient_prix", "ton_professionnel"],
    },
    {
        "id": "test_002",
        "categorie": "stock",
        "question": "Le tablet air est-il en stock ?",
        "reponse_attendue": "oui",
        "tools_attendus": ["rechercher_produit"],
        "criteres": ["reponse_claire", "information_stock"],
    },
]

async def run_evaluation_complete(agent):
    resultats = []
    for cas in DATASET:
        result = await Runner.run(agent, cas["question"])
        eval_result = await evaluer_qualite(cas["question"], result.final_output)
        resultats.append({
            **cas,
            "reponse_agent": result.final_output,
            "score": eval_result.score,
            "evaluation": eval_result.raison,
        })

    # Rapport
    score_moyen = sum(r["score"] for r in resultats) / len(resultats)
    print(f"\nScore moyen : {score_moyen:.1f}/5")
    for cat in set(r["categorie"] for r in resultats):
        scores_cat = [r["score"] for r in resultats if r["categorie"] == cat]
        print(f"  {cat} : {sum(scores_cat)/len(scores_cat):.1f}/5")

    return resultats

Points clés à retenir

Évaluez l’exactitude, l’utilisation des tools, la latence et le coût
L’évaluation par LLM (LLM-as-Judge) gère les réponses ouvertes
Créez des jeux de test structurés et reproductibles
Automatisez l’évaluation dans votre CI/CD pour détecter les régressions
Comparez systématiquement les changements (modèle, instructions, tools)