𝗦𝗰𝗼𝗿𝗶𝗻𝗴 𝗔𝗜 𝗔𝗴𝗲𝗻𝘁𝘀: 𝗗𝗲𝘁𝗲𝗿𝗺𝗶𝗻𝗶𝘀𝘁𝗶𝗰 𝗠𝗲𝘁𝗿𝗶𝗰𝘀 + 𝗮𝗻 𝗟𝗟𝗠 𝗝𝘂𝗱𝗴𝗲

You run many small AI agents. You have agents for backend, frontend, mobile, and devops. Each agent has one job.

When you have many agents, you face a problem. You do not know if they are good. You do not know if a prompt edit makes them better or worse. Saying "it looks fine" does not work at scale.

I built a framework to solve this. It uses numbers to measure performance and improves prompts automatically.

The Strategy

Measure what you can measure with math first. Use an LLM judge only when you must. Deterministic metrics are fast and free. An LLM judge is slow and costs money.

How the system works:

• The harness runs each agent as a separate process. • It feeds a task to the agent. • It captures the output. • It scores the result against expected data.

The agent only needs to read from stdin and write to stdout. It can be Python or a shell script. The harness does not care.

Five core metrics to track:

• Accuracy: Does the output match the goal?
• Fuzzy score: How similar is the text to the target?
• Timeout rate: How often does the agent fail to finish?
• Safety violations: Does the output match unsafe patterns?
• Reproducibility variance: Does the agent give the same answer every time?

If an agent is correct but inconsistent, it is a bug.

The LLM Judge

Some things are hard to measure with math. You need to know if an agent stayed in its role or followed constraints.

For these cases, an LLM judge reviews the work. It receives a rubric and the agent output. It returns a structured verdict. I validate this verdict against a JSON schema so it does not break the report.

The judge does more than just grade. It must suggest fixes. A critique like "this is weak" is useless. A critique like "add a JSON block to the prompt" is actionable.

The Improvement Loop

Failures go into a file. This file feeds an automated loop. The system looks at the weakest part of a prompt and tries to fix it. It keeps a pool of good candidates. It writes the best versions back to the code.

A single score is a snapshot. Use history to track trends. This tells you if you are getting better over time.

Build your foundation on deterministic metrics. Use the judge as a scalpel, not a hammer.

Évaluer les agents IA : Métriques déterministes vs un juge LLM

L'évaluation des agents IA est un défi de taille. Contrairement aux modèles de langage (LLM) classiques qui génèrent du texte, les agents effectuent des actions, utilisent des outils et interagissent avec des environnements. Cela rend la mesure de leur performance beaucoup plus complexe.

Il existe deux approches principales pour évaluer les agents : les métriques déterministes et l'utilisation d'un LLM comme juge (LLM-as-a-Judge).

Métriques déterministes

Les métriques déterministes reposent sur des règles fixes et des comparaisons directes. Elles sont idéales pour vérifier si un agent a respecté un format ou une instruction spécifique.

Exemples de métriques déterministes :

• Correspondance exacte (Exact Match) : Vérifie si la sortie de l'agent correspond exactement à une valeur attendue.
• Expressions régulières (Regex) : Utilisées pour vérifier si la sortie suit un format spécifique (par exemple, une adresse e-mail ou un numéro de téléphone).
• Validation de schéma JSON : S'assure que la sortie de l'agent est un JSON valide et conforme à un schéma prédéfini.
• Vérification des appels d'outils (Tool Call Verification) : Vérifie si l'agent a appelé la bonne fonction avec les bons arguments.

Avantages :

• Rapidité : L'exécution est quasi instantanée.
• Coût quasi nul : Ne nécessite pas d'appels API coûteux.
• Reproductibilité : Le résultat est toujours le même pour une entrée donnée.

Inconvénients :

• Rigidité : Ne peut pas capturer la nuance ou la sémantique.
• Sensibilité au formatage : Un simple espace ou une majuscule peut faire échouer une métrique de correspondance exacte.

LLM-as-a-Judge

L'approche LLM-as-a-Judge consiste à utiliser un modèle de langage puissant (comme GPT-4o) pour évaluer la qualité des réponses d'un agent. Le juge reçoit la question, la réponse de l'agent et, parfois, une réponse de référence, puis attribue une note ou un commentaire.

Pourquoi utiliser un LLM comme juge ?

Les LLM peuvent comprendre le contexte, la nuance et la pertinence sémantique, ce que les métriques déterministes ne peuvent pas faire.

Avantages :

• Nuance sémantique : Peut évaluer si une réponse est correcte même si elle n'utilise pas les mots exacts.
• Évaluation qualitative : Peut fournir des explications sur la raison pour laquelle une réponse est bonne ou mauvaise.
• Flexibilité : Peut évaluer des tâches ouvertes où il n'y a pas de "bonne" réponse unique.

Inconvénients :

• Coût élevé : Nécessite des appels API à des modèles performants.
• Lenteur : L'évaluation prend beaucoup plus de temps que les tests déterministes.
• Biais du juge : Les LLM peuvent présenter des biais (par exemple, préférer les réponses plus longues ou être influencés par le format de la question).

Comparaison rapide

Caractéristique	Métriques Déterministes	LLM-as-a-Judge
Vitesse	Très rapide	Lente
Coût	Très faible / Gratuit	Élevé
Nuance	Faible	Élevée
Fiabilité	Élevée (pour le format)	Variable (sujet aux biais)
Complexité de mise en œuvre	Simple	Modérée

Conclusion

Pour une évaluation robuste des agents IA, la meilleure stratégie est souvent une approche hybride. Utilisez des métriques déterministes pour valider la structure et le format (le "comment"), et utilisez un LLM comme juge pour évaluer la qualité et la pertinence du contenu (le "quoi").