Vers l'automatisation de l'ingénierie d'évaluation

Aujourd'hui, nous publions notre Eval Engineering Skill, un skill qui aide les agents de codage à construire des évaluations en utilisant le contexte d'un dépôt et des traces d'agents.

Le skill inspecte la structure d'un agent, extrait des motifs des traces si disponibles, et propose des capacités à tester.

Le skill est conçu pour interviewer l'utilisateur qui peut donner son retour sur les propositions et approuver de manière itérative chaque évaluation. Le produit final est un ensemble d'évaluations exécutables au format Harbor.

Création de l'environnement et de la tâche

Le skill lit d'abord le dépôt et cartographie la surface de l'agent, y compris les prompts, modèles, outils, skills, hooks, etc. Il identifie également les données et services qui soutiennent ces comportements, tels que les appels API.

Les utilisateurs peuvent également orienter l'agent vers des traces qui peuvent être récupérées à l'aide d'outils comme le langsmith-cli. Les traces montrent comment les outils se comportent en pratique, comme leurs arguments, résultats et erreurs. Ces contrats observés aident le skill à reproduire le comportement pertinent de production dans un environnement contrôlé.

L'exploration du dépôt et des traces donne à l'agent une connaissance des capacités importantes pour l'agent lorsqu'il propose des tâches d'évaluation. Nous avons constaté que l'interview de l'utilisateur conduit à une bien meilleure acceptation des évaluations qu'une génération en un seul passage. L'utilisateur choisit parmi les directions d'évaluation proposées et donne des conseils sur des questions telles que quels outils et dépendances doivent être exécutés en direct ou doivent être simulés. Par exemple, les appels d'outils qui entraînent des coûts ou nécessitent des écritures en production peuvent être simulés au lieu d'être exécutés à chaque invocation d'évaluation.

Nous avons testé ce flux sur notre agent de questions-réponses documentaire, chat-langchain. Pour cet agent, l'environnement nécessitait un corpus de données exposé via des outils de recherche d'agent modélisés sur l'agent de production. Les tâches comprenaient une question de documentation réaliste tirée de traces réelles et un vérificateur qui vérifiait la réponse à l'aide d'une chaîne de réponse de référence et de documents cités.

La conception des évaluations est itérative

Nous avons constaté que si les agents sont parfois capables de générer des évaluations en un seul passage, les meilleures évaluations proviennent des utilisateurs qui fournissent des commentaires et spécifient quelles capacités valent la peine d'être mesurées chez les agents. Les agents de codage et les skills offrent une interface naturelle où les connaissances du domaine sur la façon de construire une bonne évaluation sont encodées et les utilisateurs peuvent itérer dessus au fil du temps.

Par exemple, nous avons constaté que lors de la construction de vérificateurs, le premier vérificateur était rarement le final. Une façon utile de l'améliorer était d'exécuter l'évaluation et d'inspecter les deux côtés du résultat :

• la trajectoire de l'agent, y compris ses messages, appels d'outils et actions.
• la trajectoire du vérificateur, les preuves, le raisonnement et le score final.

Cela a permis de révéler si la conception de la tâche ou du vérificateur mesurait ce qui nous importait ou si elle pouvait être reward hacked (détournée par la récompense) où les agents pouvaient prendre des raccourcis. Ces raccourcis pourraient inclure la surcitation de sources non pertinentes pour obtenir un crédit complet sur l'évaluation, revendiquer une action jamais effectuée, exploiter du matériel de réponse exposé, ou satisfaire un proxy sans accomplir la tâche. L'observation des traces de la façon dont les agents résolvent les problèmes révèle souvent la source de ces échecs. La tâche, l'environnement et le vérificateur peuvent ensuite être révisés et exécutés à nouveau.

Les évaluations sont au format Harbor

Le skill construit les évaluations en tant que tâches Harbor :

1. Une instruction : le message donné à l'agent au début décrivant la tâche
2. Un environnement : donné sous forme de Dockerfile contenant la configuration de la tâche, comme les outils à installer ou les données à peupler dans le système de fichiers
3. Un vérificateur qui évalue si l'agent a correctement accompli la tâche.

Le skill assemble ces composants en une tâche Harbor :

1evals/<task-id>/
2├── task.toml
3├── instruction.md
4├── environment/
5└── tests/

Harbor exécute l'agent dans l'environnement et enregistre sa trajectoire, ses artefacts, sa récompense et ses erreurs. La même évaluation peut ensuite être exécutée avec différents modèles, prompts, outils et versions d'agent.

Pourquoi c'est important

L'apprentissage continu peut être considéré comme un problème de data mining continu où les données de production sont utilisées pour construire des évaluations qui améliorent les agents au fil du temps. Les équipes explorent les traces pour trouver des demandes utilisateur récurrentes, des erreurs, des appels d'outils échoués et des changements d'état incorrects, qui deviennent des évaluations afin que le même comportement puisse être mesuré et évité à l'avenir.

Les évaluations sont des données d'entraînement pour les agents. Les équipes peuvent adapter le comportement des agents à celles-ci via l'ingénierie de harnais (harness engineering) comme la modification des prompts et des outils ou le fine-tuning. L'évaluation fournit une cible fixe pour décider si ces changements ont amélioré la capacité visée.

Les évaluations conteneurisées accélèrent ce processus. La tâche et l'environnement restent stables pendant que la configuration de l'agent change, de sorte que les développeurs peuvent échanger des modèles, des outils, des prompts ou des versions complètes d'agent et comparer directement les résultats. Plusieurs configurations peuvent être exécutées en parallèle.

Les environnements reproductibles sont essentiels à ce signal. Lorsqu'une évaluation reflète les outils, données, permissions, état et modes de défaillance pertinents de la production, les développeurs obtiennent un banc d'essai stable qui reste représentatif du fonctionnement de l'agent. Ils peuvent expérimenter rapidement sans dépendre de systèmes de production changeants ou d'écritures dans l'état de production.

La boucle résultante est :

extraire des traces -> identifier un échec -> construire une évaluation -> améliorer l'agent -> réexécuter

Essayez-le dès aujourd'hui

Le Skill Eval Engineering est disponible dans le dépôt langchain-ai/langchain-skills.

Installez le skill dans Codex ou Claude Code, ouvrez le dépôt contenant l'agent que vous souhaitez évaluer, orientez l'agent vers un ensemble de traces si disponibles, et commencez avec un prompt simple :

Nous avons hâte d'étendre ce skill et de construire des outils pour faciliter la construction automatique d'évaluations et l'adaptation des agents à celles-ci de manière autonome.