Évaluations pour agents IA : évaluation de la summarisation

# Évaluation des agents IA : Approche systématique pour la qualité des résumés de réunions

Les agents IA gérant les réunions produisent souvent des résultats incohérents : hallucinations, tâches oubliées et textes verbeux. Les évaluations corrigent cela en fournissant des métriques objectives de qualité. Ce sont des tests pour des systèmes non déterministes, à l’image des tests unitaires dans le code traditionnel. Ils répondent à des questions clés : où l’agent échoue-t-il, a-t-il progressé après des modifications, et rien de fonctionnel n’a-t-il été cassé ?

Cet article aborde les types d’évaluations, l’analyse d’erreurs, les assertions basées sur du code et les métriques pour les résumés de réunions. L’approche s’inspire d’experts comme Hamel Husain et Eugene Yan.

Types d’évaluations : Des vérifications simples au LLM-juge

Une évaluation est une fonction f(sortie) → score qui note la sortie de l’agent. Trois niveaux de complexité :

• Assertions basées sur du code : Vérifications déterministes pour des propriétés formelles (longueur, structure, mots-clés). Rapides, gratuites, mais limitées.
• Évaluation humaine : Jugement nuancé par des humains. Précis, mais coûteux et non scalable.
• LLM-juge : Notation par un LLM selon des critères. Scalable, économique, nécessite une validation.

La règle d’or : combiner tous les types. Assertions codées pour chaque requête, LLM-juge sur des échantillons, humain pour l’étalonnage.

Pour les résumés de réunions, définissez les métriques par priorité :

• Fidélité : Chaque affirmation étayée par la transcription.
• Précision des actions : Tâches complètes avec responsable et échéance.
• Exhaustivité : Couverture des sujets clés.
• Concision : Longueur <30 % de la transcription, densité 0,15 entités/token.
• Cohérence : Structure logique.

Analyse d’erreurs : La base des évaluations efficaces

L’analyse manuelle des erreurs est la première étape avant l’automatisation. Sans elle, les évaluations sont inutiles : les équipes créent des métriques ignorant les vrais problèmes.

Processus d’analyse d’erreurs

Rassemblez 20–50 paires transcription → résumé de production ou synthétiques. Lisez-les, notez les problèmes sans les classer :

• Hallucination : « Maria s’occupera du refactoring » au lieu de « pourrait examiner ».
• Oubli d’actions à la fin de transcriptions longues.
• Mauvaise compression : résumé plus long que la transcription.

Regroupez en une taxonomie des modes de défaillance :

ÉCHECS DE FIDÉLITÉ :

• Engagements hallucinés.
• Attribution erronée.

ÉCHECS D’EXHAUSTIVITÉ :

• Perte d’actions.
• Décisions manquées.

ÉCHECS DE CONCISION :

• Récit au lieu de résumé.

Comptez les fréquences : 2–3 erreurs principales définissent les priorités d’évaluation. Temps : demi-journée à une semaine, ROI maximal.

Assertions basées sur du code : Vérifications rapides pass/fail

Principe : pass/fail binaire, pas d’échelles 1–5. Force des définitions claires d’acceptabilité.

Exemples pour les résumés de réunions :

interface Transcript {
  text: string;
  duration_minutes: number;
  participants: string[];
}

interface Summary {
  text: string;
  action_items: ActionItem[];
  decisions: string[];
}

interface ActionItem {
  description: string;
  owner?: string;
  deadline?: string;
}

interface AssertionResult {
  name: string;
  pass: boolean;
  reason: string;
}

function runAssertions(transcript: Transcript, summary: Summary): AssertionResult[] {
  const results: AssertionResult[] = [];
  
  // Ratio de compression : résumé < 30 % transcription
  const transcriptTokens = transcript.text.split(' ').length;
  const summaryTokens = summary.text.split(' ').length;
  const ratio = summaryTokens / transcriptTokens;
  results.push({
    name: 'Ratio de compression',
    pass: ratio < 0.3,
    reason: `Ratio : ${ratio.toFixed(2)}`
  });
  
  // Actions complètes avec responsable et échéance
  const aiComplete = summary.action_items.every(ai => ai.owner && ai.deadline);
  results.push({
    name: 'Exhaustivité des actions',
    pass: aiComplete,
    reason: aiComplete ? 'OK' : 'Manque responsable/échéance'
  });
  
  return results;
}

Assertions supplémentaires :

• Présence de la section action_items.
• Pas de bla-bla dans le résumé.
• JSON valide pour sortie structurée.

LLM-juge et scoreurs avancés

Pour les métriques nuancées, utilisez LLM-juge avec des prompts pour fidélité, exhaustivité. Mastra propose 16 scoreurs : fidélité, exhaustivité, concision.

Exemple de prompt fidélité :

Évaluez la fidélité de ce résumé à la transcription. Chaque affirmation doit être étayée. Notez de 0 à 1.
Transcription : [texte]
Résumé : [texte]
Score :```

Intégrez dans le CI : exécutez sur 50 cas de test avant déploiement. Métrique d’amélioration : fidélité de 0,64 à 0,78.

**Points clés :**
- Commencez par l’analyse d’erreurs : 2–3 modes de défaillance couvrent 60 % des problèmes.
- Combinez code (rapide), LLM-juge (scalable), humain (validation).
- Priorités : fidélité > précision actions > exhaustivité.
- Pass/fail binaire pour décisions claires.
- Automatisez dans le CI pour des gains systématiques.

— Editorial Team