Monitorer un Agent IA en Production : Métriques, Alertes, Dérives

Déployer un agent IA sans monitoring, c’est conduire sans tableau de bord. Les problèmes existent — vous les découvrez quand le client se plaint, pas avant. Voici ce que je mets en place systématiquement.

Les 5 Métriques Critiques

1. Nombre de tours par session (steps)

Un agent qui prend 12 tours pour une tâche qui devrait en prendre 3 a un problème — outil cassé, prompt ambigu, ou boucle implicite.

from dataclasses import dataclass, field
import time

@dataclass
class AgentSession:
    session_id: str
    steps: int = 0
    start_time: float = field(default_factory=time.monotonic)
    tool_calls: list[str] = field(default_factory=list)
    hit_max_steps: bool = False

    @property
    def duration(self) -> float:
        return time.monotonic() - self.start_time

Seuil d’alerte : moyenne > 5 steps sur les 30 dernières minutes.

2. Taux de sessions MAX_STEPS

Si plus de 2% des sessions atteignent la limite, il y a un bug structurel dans la logique de l’agent.

3. Latence P95

La latence médiane masque les outliers. Le P95 (95e percentile) vous dit ce que vivent vos utilisateurs les moins chanceux.

4. Taux d’erreur par outil

Chaque outil de l’agent doit avoir son propre compteur d’erreurs. Un outil qui plante 10% du temps dégrade silencieusement l’ensemble.

5. Score de qualité (si évaluable)

Pour les agents avec une sortie structurée vérifiable (extraction, classification), calculez un taux de succès automatique.

Détecter les Dérives

Les LLMs dérivent. Une mise à jour de modèle, un changement de prompt, ou simplement des données d’entrée qui évoluent peuvent dégrader silencieusement les résultats.

import statistics

def detect_drift(recent_scores: list[float], baseline_scores: list[float]) -> bool:
    if not recent_scores or not baseline_scores:
        return False
    recent_mean = statistics.mean(recent_scores)
    baseline_mean = statistics.mean(baseline_scores)
    # Alerte si dégradation > 10%
    return recent_mean < baseline_mean * 0.90

Comparez toujours une fenêtre récente (dernières 24h) à une baseline stable (semaine précédente).

Stack de Monitoring Minimal

import logging
import json

def log_session(session: AgentSession, result: str | None, error: str | None) -> None:
    record = {
        "session_id": session.session_id,
        "steps": session.steps,
        "duration_s": round(session.duration, 2),
        "tools_used": session.tool_calls,
        "hit_max_steps": session.hit_max_steps,
        "success": error is None,
        "error": error,
    }
    logging.info(json.dumps(record))

Un log JSON par session. Ingestible dans n’importe quel outil : Datadog, Grafana, ou même un simple grep sur les erreurs.

Alertes Prioritaires

Alerte	Seuil	Action
Taux MAX_STEPS	> 2% sur 1h	Investiguer la logique agent
Steps moyen	> 5	Vérifier les outils
Taux erreur outil	> 5%	Vérifier l’outil concerné
Latence P95	> 30s	Vérifier les timeouts
Drift qualité	> 10% dégradation	Comparer avec le changelog modèle

Ce que Je Déploie Systématiquement

Sur tous mes agents en production : un dashboard avec ces 5 métriques + une alerte email/Slack sur les deux premières. C’est 2 heures de setup qui évitent des incidents à 2h du matin.