💻 computer science

Learning Correct Behavior from Examples: Validating Sequential Execution in Autonomous Agents

Cet article présente un nouvel algorithme qui valide le comportement séquentiel des agents autonomes en apprenant des modèles de vérité terrain généralisés à partir de seulement 2 à 10 traces d'exécution, en exploitant l'analyse des dominateurs et des grands modèles de langage multimodaux pour atteindre une haute précision dans la détection de bugs et la validation explicable à travers divers domaines.

Auteurs originaux : Reshabh K Sharma, Gaurav Mittal, Yu Hu

Publié 2026-05-06

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Reshabh K Sharma, Gaurav Mittal, Yu Hu

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous enseigniez à un assistant robot très intelligent, mais légèrement chaotique, comment préparer une tasse de café.

Autrefois, si vous vouliez vérifier si le robot avait bien fait le travail, vous deviez rédiger un manuel de règles strict : « D'abord, saisissez la tasse. Ensuite, appuyez sur le bouton. Ensuite, attendez exactement 3 secondes. Ensuite, versez. » Si le robot saisissait la tasse, appuyait sur le bouton et versait en 2 secondes parce que la machine était plus rapide ce jour-là, votre manuel de règles strict hurlerait : « ERREUR ! Vous n'avez pas attendu 3 secondes ! » et échouerait le robot, même si le café est parfait.

C'est le problème avec les tests des agents d'IA modernes. Ils sont flexibles. Parfois, ils prennent un raccourci ; parfois, ils attendent plus longtemps. Ils ne suivent pas exactement le même chemin à chaque fois, même lorsqu'ils accomplissent correctement la tâche.

Ce papier introduit une nouvelle façon de tester ces agents, moins semblable à un manuel de règles strict et plus à un mentor intelligent.

L'Idée de Base : Apprendre des « Bons Jours »

Au lieu d'écrire des règles, le système demande à l'agent d'accomplir la tâche avec succès seulement 2 à 10 fois. Il observe ces « bons jours » et construit une carte mentale de ce qui doit se produire par rapport à ce qui peut changer.

Pensez-y comme à observer un groupe d'amis naviguer dans une ville pour se rendre à un restaurant spécifique :

L'ami A prend le métro, descend à la station principale, traverse le parc et arrive.
L'ami B prend un bus, descend à deux pâtés de maisons, passe devant une boulangerie et arrive.
L'ami C prend le métro, descend à la station principale, traverse le parc, mais s'arrête pour attacher sa chaussure avant d'arriver.

Un testeur strict dirait : « L'ami B a échoué car il n'a pas pris le métro ! » ou « L'ami C a échoué car il s'est arrêté ! »

Mais ce nouveau système est plus intelligent. Il examine les trois parcours et réalise :

Les Arrêts Essentiels (L'Arbre « Dominator ») : Tout le monde doit commencer à la maison et doit finir au restaurant. Ce sont les points de contrôle non négociables.
Les Arrêts Optionnels : Le parc, la boulangerie et l'attache de la chaussure ne sont que des variations. Ils sont agréables, mais pas obligatoires.

Comment Cela Fonctionne (Les Trois Étapes)

1. L'« Album Photo » (Capturer les Traces)
Le système prend des captures d'écran (ou enregistre des actions) de l'agent accomplissant la tâche correctement quelques fois. Il transforme cela en un organigramme, comme un livre « Choisissez votre propre aventure » où chaque chemin qui a fonctionné est enregistré.

2. La « Fusion Intelligente » (Trouver le Modèle)
C'est la partie magique. Le système utilise deux outils pour déterminer ce qui compte :

L'Œil (Métriques Visuelles) : Il examine les captures d'écran. Si deux écrans se ressemblent à 99 %, il les traite comme la même étape.
Le Cerveau (Analyse par LLM) : Parfois, les écrans semblent différents mais signifient la même chose (par exemple, une fenêtre est légèrement plus grande, ou l'heure sur l'horloge a changé). Le système demande à un puissant modèle de langage d'IA : « Ces différences sont-elles importantes, ou juste cosmétiques ? » Si l'IA dit : « Non, c'est juste une police différente », le système l'ignore.

En fusionnant ces parcours, le système construit un « Arbre Dominator ». C'est une carte simplifiée montrant uniquement les étapes critiques que chaque tentative réussie a traversées. Il filtre le bruit (comme les écrans de chargement qui apparaissent parfois mais pas d'autres fois).

3. La « Liste de Contrôle » (Valider les Nouvelles Exécutions)
Lorsque l'agent tente la tâche à nouveau, le système ne vérifie pas s'il a suivi exactement le même chemin. Au lieu de cela, il demande : « Avez-vous atteint tous les points de repère critiques dans le bon ordre ? »

Si l'agent a sauté la « Fenêtre Principale » et est allé directement aux « Résultats », le système dit : « ÉCHEC. » (Vous avez manqué un arrêt critique).
Si l'agent a sauté l'« Écran de Chargement » (qui est optionnel), le système dit : « SUCCÈS. » (Vous avez fait le travail efficacement).

Pourquoi Cela Compte

Le papier a testé cela sur un agent informatique qui devait ouvrir un éditeur de code et rechercher du texte.

L'Ancienne Méthode (Auto-déclaration) : L'agent disait souvent : « Je l'ai fait ! » même lorsqu'il échouait, ou disait : « J'ai échoué ! » alors qu'il avait en réalité réussi, car il était confus par des problèmes de synchronisation. Il n'était précis qu'à environ 82 %.
La Nouvelle Méthode : En utilisant l'« Arbre Dominator » appris à partir de seulement 3 exemples réussis, le système a atteint 100 % de précision. Il pouvait distinguer quand l'agent cassait réellement le logiciel (un bug produit) par rapport au moment où l'agent trébuchait simplement à cause d'une connexion internet lente (un problème d'agent).

Le Conclusion

Ce papier présente un outil qui apprend à une IA comment se noter elle-même. Au lieu de nécessiter des milliers d'exemples ou un manuel de règles rigide, il apprend le « squelette » d'une tâche correcte à partir d'une poignée de bons exemples. Il comprend que, bien que le parcours puisse varier, la destination et les points de repère clés doivent rester les mêmes. Cela rend les tests des agents autonomes beaucoup plus fiables et moins sujets aux fausses alertes.

Résumé Technique : Apprentissage du Comportement Correct à partir d'Exemples pour les Agents Autonomes

Énoncé du Problème

À mesure que les agents autonomes (par exemple, les agents d'utilisation d'ordinateur, les agents de codage) deviennent plus sophistiqués, la validation de leur comportement séquentiel présente un défi majeur en raison du non-déterminisme. Contrairement aux logiciels traditionnels, les systèmes autonomes suivent rarement exactement la même séquence d'états et d'actions entre les exécutions. Les variations proviennent de différences de timing, de facteurs environnementaux et de chemins alternatifs légitimes (par exemple, l'apparition ou la disparition d'un écran de chargement, ou différents chemins d'interface utilisateur atteignant le même objectif).

Les approches de validation existantes souffrent de limitations critiques dans ce contexte :

Tests basés sur des assertions : Nécessite une spécification manuelle pour chaque vérification, manque les problèmes d'état visuel et ne peut pas gérer les chemins alternatifs.
Enregistrement et rejeu : Fragile ; échoue sur de légères différences de rendu ou des variations de timing.
Tests de régression visuelle : Compare des captures d'écran de manière isolée sans comprendre le flux d'exécution ou le sens sémantique.
Oracles d'apprentissage automatique : Nécessitent des milliers d'exemples d'entraînement et manquent d'explicabilité.

Le problème central est de distinguer entre les variations acceptables (états non essentiels) et les échecs réels (états essentiels sautés) sans spécification manuelle.

Méthodologie

L'article propose un algorithme novateur qui apprend automatiquement un modèle de vérité terrain généralisé à partir d'un petit nombre de traces d'exécution réussies (2 à 10) et valide les nouvelles exécutions par rapport à ce modèle. L'approche se compose de trois phases :

Phase 1 : Capture et Construction d'Arbre de Préfixes

Le système collecte des traces d'exécution à partir d'exécutons connus comme corrects. Chaque trace comprend des observations d'état séquentielles (par exemple, des captures d'écran pour les agents d'interface utilisateur) et des actions (par exemple, des clics, des frappes au clavier). Ces traces sont converties en Accepteurs d'Arbres de Préfixes (PTA), des graphes orientés où les nœuds représentent des états observables et les arêtes représentent des actions.

Phase 2 : Fusion et Généralisation

Cette phase fusionne plusieurs PTA pour gérer le non-déterminisme et identifier les états essentiels par rapport aux états optionnels.

Détection d'Équivalence d'États à Niveaux Multiples : Pour déterminer si différentes captures d'écran représentent le même état logique, le système utilise une approche à trois niveaux :
- Niveau 1 (Métriques Visuelles) : Utilise le hachage perceptuel, l'indice de similarité structurelle (SSIM) et les ratios de changement de pixels.
- Niveau 2 (Analyse Sémantique) : Si les métriques visuelles sont ambiguës, un Grand Modèle de Langage (LLM) multimodal effectue une comparaison côte à côte pour distinguer les différences sémantiquement significatives (par exemple, des erreurs de formulaire) des différences sans importance (par exemple, les décorations de fenêtre, les horodatages).
- Niveau 3 (Fusion Intelligente) : Construit un graphe unifié capturant les branches pour les chemins alternatifs (par exemple, avec/sans écrans de chargement) et les points de convergence.
Extraction des Dominants : En utilisant l'analyse des dominants issue de la théorie des compilateurs, le système identifie les états qui "dominent" d'autres (c'est-à-dire que chaque chemin de l'état initial vers un état spécifique doit passer par le dominant). En remontant depuis les états terminaux jusqu'à l'état initial, le système extrait un arbre de dominants contenant uniquement les états essentiels (par exemple, "Fenêtre Principale", "Dialogue de Recherche") tout en filtrant les variations optionnelles (par exemple, "Écran de Chargement").

Phase 3 : Validation par Correspondance de Sous-séquence Topologique

Lorsqu'une nouvelle trace de test arrive, le système vérifie si sa séquence d'états contient une sous-séquence topologique correspondant à un chemin dans l'arbre de dominants appris.

Logique de Correspondance : Si les états de référence sont $A \to B \to C \to D$ et que la trace de test est $A \to X \to B \to Y \to C \to D$ , c'est une CORRESPONDANCE car les états essentiels apparaissent dans le bon ordre, avec $X$ et $Y$ traités comme des éléments supplémentaires autorisés.
Métriques : Le système calcule la couverture ( $\frac{\text{états correspondants}}{\text{états de référence totaux}}$ ) et vérifie si l'état terminal correspond.
Sortie : Les résultats sont SUCCÈS ou ÉCHEC, accompagnés de métriques explicables (pourcentage de couverture, états manquants) plutôt que de classifications boîte noire.

Contributions Clés

Algorithme en Trois Phases : Une intégration novatrice des Accepteurs d'Arbres de Préfixes et de l'analyse des dominants pour identifier automatiquement les états essentiels par rapport aux états optionnels à partir de 2 à 10 traces d'exemple.
Détection d'Équivalence à Niveaux Multiples : Un système hybride combinant des métriques visuelles avec une analyse sémantique par LLM multimodal pour gérer robustement le comportement non déterministe et distinguer l'équivalence fonctionnelle du bruit visuel.
Correspondance de Sous-séquence Topologique : Un mécanisme de validation qui vérifie la correction de l'exécution tout en tolérant les variations acceptables, fournissant des métriques de couverture explicables.

Résultats Expérimentaux

Les auteurs ont mené une étude de cas contrôlée utilisant un scénario de détection de bogues d'extension VS Code synthétique avec 28 exécutions d'agent (3 pour l'entraînement, 25 pour le test).

Précision : Le système a atteint une précision de 100 % dans la détection des bogues produits (11/11), des problèmes d'agent (3/3), des faux succès (1/1) et des bogues manqués (1/1).
Comparaison : Comparé à une base de référence où l'Agent d'Utilisation d'Ordinateur (CUA) signale lui-même le succès/échec, l'approche proposée a nettement surpassé la base de référence :
- Précision : 100 % contre 82,2 % (+17,8 points de pourcentage).
- Rappel : 100 % contre 60,0 % (+40,0 points de pourcentage).
- Score F1 : 100 % contre 69,8 % (+30,2 points de pourcentage).
Analyse des Causes Racines : Le système a démontré sa capacité à distinguer entre les "erreurs d'exécution de l'agent" et les "bogues produits", atteignant un score F1 de 52,2 % pour identifier les scénarios "pas un bogue" (où l'agent a trébuché mais le produit était correct), alors que la base de référence CUA a échoué à identifier ces scénarios entièrement (score F1 de 0 %).

Importance et Revendications

L'article revendique que la validation comportementale fiable pour les agents autonomes ne nécessite pas de vastes corpus d'entraînement, de spécifications exactes fragiles ou d'assertions manuelles. En apprenant à partir de quelques traces réussies, le système :

Réduit le Coût de Configuration : Élimine le besoin de centaines ou de milliers d'exemples d'entraînement requis par les oracles basés sur l'apprentissage automatique.
Fournit de l'Explicabilité : Génère des arbres de dominants interprétables et des métriques de couverture précises, contrairement aux classificateurs ML boîte noire.
Gère le Non-déterminisme : Tolère avec succès les variations acceptables (comme les écrans de chargement) tout en imposant un comportement structurel essentiel, répondant ainsi à une faiblesse clé des outils d'enregistrement-rejeu et de régression visuelle.
Applicabilité Large : Bien que démontré sur les tests d'interface utilisateur, les auteurs revendiquent que l'approche est applicable aux agents de codage (validation des modèles de développement), à l'automatisation des processus robotiques (points de contrôle de conformité) et à l'apprentissage par renforcement (filtrage des données d'entraînement).

Les auteurs reconnaissent des limitations, notamment la dépendance à la représentation visuelle de l'état (moins efficace pour les services backend), le besoin de traces réussies (ne peut pas apprendre uniquement des échecs) et la dépendance aux LLM pour l'équivalence sémantique. Cependant, ils posent que cette approche offre un mécanisme pratique, à faible tirage et interprétable pour assurer la fiabilité des agents autonomes dans des environnements de production complexes.