🤖 AI

OpenComputer: Verifiable Software Worlds for Computer-Use Agents

L'article présente OpenComputer, un cadre ancré sur la vérification qui construit des mondes logiciels vérifiables pour les agents d'utilisation d'ordinateurs en intégrant des vérificateurs d'état spécifiques à l'application, une couche de vérification auto-évolutive, un pipeline de génération de tâches et un dispositif d'évaluation pour révéler des écarts significatifs dans la robustesse des agents de pointe actuels et open source, malgré leurs progrès partiels.

Auteurs originaux : Jinbiao Wei, Qianran Ma, Yilun Zhao, Xiao Zhou, Kangqi Ni, Guo Gan, Arman Cohan

Publié 2026-05-20

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Jinbiao Wei, Qianran Ma, Yilun Zhao, Xiao Zhou, Kangqi Ni, Guo Gan, Arman Cohan

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 robot à effectuer vos tâches quotidiennes, comme organiser vos fichiers numériques, modifier une photo ou envoyer un courriel. Vous voulez que le robot soit parfait, mais comment savoir s'il a réellement accompli la tâche correctement ?

C'est le problème que l'article OpenComputer aborde. Les auteurs ont construit une nouvelle « salle de sport d'entraînement » pour les agents d'IA utilisant des ordinateurs, mais avec une particularité très spécifique : ils ne se contentent pas d'examiner le travail du robot ; ils vérifient les devoirs du robot d'un œil strict et ininterrompu.

Voici comment OpenComputer fonctionne, expliqué par de simples analogies :

1. Le Problème : Le Piège du « Fais semblant jusqu'à ce que tu y arrives »

Par le passé, tester une IA sur un ordinateur revenait à noter la copie d'un élève en ne regardant que la page de couverture. Si la couverture était jolie, le professeur (un juge IA) pouvait attribuer un A. Mais l'élève avait peut-être laissé la copie réelle vide ou remplie de charabia.

Dans le monde numérique, une IA peut prendre une capture d'écran d'un document qui semble terminé, mais si le fichier à l'intérieur est en réalité vide ou si les paramètres sont incorrects, le « Juge IA » peut passer à côté de l'erreur car il ne voit que l'image, pas les données.

2. La Solution : L'« Inspecteur Numérique »

OpenComputer change la donne en construisant un monde logiciel vérifiable. Au lieu de simplement regarder l'écran, il installe une équipe d'« Inspecteurs » spécialisés (appelés Vérificateurs) à l'intérieur de chaque application utilisée par l'IA.

Le Travail de l'Inspecteur : Imaginez un bibliothécaire qui ne se contente pas de regarder la couverture du livre. Il ouvre le livre, vérifie les numéros de page, confirme le nom de l'auteur et s'assure que le texte correspond à la base de données de la bibliothèque.
Comment cela fonctionne : Pour chaque application (comme un navigateur web, un éditeur de photos ou un tableur), OpenComputer construit un script personnalisé capable de « parler » directement au cerveau de l'application. Il pose des questions comme : « Le fichier est-il réellement enregistré ? » « L'utilisateur a-t-il vraiment cliqué sur ce bouton ? » « Le texte est-il dans la bonne cellule ? »

3. Le Processus de Construction en Quatre Étapes

L'article décrit une chaîne de montage en quatre étapes pour construire ces scénarios de test parfaits :

Étape 1 : Construire les Inspecteurs. Ils créent une « clé » pour chaque application permettant au système de jeter un coup d'œil à l'état caché du logiciel (fichiers, paramètres, historique) plutôt que de simplement deviner à partir de l'écran.
Étape 2 : La Boucle d'Auto-amélioration. Ils testent ces inspecteurs avec une IA « puissante ». Si l'inspecteur dit « Bon travail » mais que l'IA a en réalité fait une erreur, le système détecte l'erreur. Il corrige ensuite le code de l'inspecteur, le rendant plus intelligent pour la prochaine fois. C'est comme un entraîneur qui observe un joueur s'entraîner, puis ajuste l'équipement d'entraînement pour plus de précision.
Étape 3 : Créer les Tâches. Une fois les inspecteurs fiables, le système génère 1 000 tâches réalistes (comme « organisez ces 50 fichiers » ou « modifiez cette photo »). Parce que les inspecteurs sont prêts, chaque tâche possède des critères de réussite ou d'échec clairs et vérifiables par machine.
Étape 4 : L'Examen Final. Ils font fonctionner les agents IA dans une pièce numérique fraîche et propre. Les agents tentent de résoudre les tâches, et les Inspecteurs les notent instantanément en se basant sur les données réelles, et non pas seulement sur les images.

4. Ce qu'ils ont Découvert

Lorsqu'ils ont testé les meilleurs modèles d'IA (comme GPT-5.4 et Claude) dans cette nouvelle salle de sport, ils ont découvert des choses surprenantes :

Le Problème du « Presque » : Même les IA les plus intelligentes peinent à terminer une tâche entière parfaitement. Elles parviennent souvent à 80 % du chemin mais échouent sur les tout petits détails finaux (comme enregistrer le fichier dans le mauvais dossier).
Le Succès « Faux » : L'ancienne méthode de jugement (utilisant une IA pour regarder des captures d'écran) était trop indulgente. Elle attribuait de hautes notes à des agents qui semblaient avoir réussi mais qui échouaient en réalité aux vérifications de données. Le nouveau « Vérificateur Codé en Dur » était beaucoup plus strict et mieux aligné avec ce qu'un humain dirait.
Le Fossé du Logiciel Libre : Certains modèles open-source qui semblaient excellents sur d'autres tests ont soudainement très mal performé ici. Cela suggère qu'ils étaient bons pour « deviner » la bonne réponse sur des tests simples, mais qu'ils ne pouvaient pas gérer la complexité des logiciels informatiques réels et désordonnés.

5. La Grande Conclusion

OpenComputer n'est pas juste une liste de tâches ; c'est une nouvelle norme pour la vérité.

Pensez-y comme au passage d'un examen « sur l'honneur » (où l'IA dit : « Je l'ai fait ! ») à un examen « surveillé » où un surveillant robot vérifie chaque réponse contre la clé de réponses. L'article conclut que, bien que l'IA s'améliore pour regarder les écrans, elle a encore un long chemin à parcourir avant de pouvoir effectuer de manière fiable des tâches informatiques complexes et réelles sans commettre d'erreurs subtiles mais critiques.

En résumé : OpenComputer a construit une aire de jeux numérique où les règles sont vérifiées par du code, et non par des suppositions, révélant que les agents IA d'aujourd'hui apprennent encore à devenir de véritables travailleurs numériques fiables.

Résumé Technique : OpenComputer

Énoncé du Problème

La mise à l'échelle des agents d'utilisation d'ordinateur est actuellement limitée par deux défis critiques : le coût élevé de la construction d'environnements de bureau réalistes et reproductibles, et la difficulté de vérifier la réussite des tâches dans des états logiciels complexes. La création traditionnelle de tâches nécessite une conception manuelle des objectifs utilisateurs et de l'initialisation de l'environnement (par exemple, peupler des fichiers, configurer des paramètres), ce qui est fastidieux et non standardisé. De plus, l'évaluation repose souvent sur le « LLM comme juge » ou l'inspection visuelle de captures d'écran, ce qui échoue à détecter des erreurs subtiles dans les états d'application sous-jacents, les métadonnées de fichiers ou les effets secondaires persistants qui ne sont pas visuellement apparents. Les benchmarks existants sont largement curatés par des humains, limités en échelle et manquent souvent de signaux de récompense fiables et vérifiables par machine.

Méthodologie : Le Cadre OpenComputer

OpenComputer est un cadre ancré sur la vérification, conçu pour synthétiser des mondes logiciels vérifiables pour les agents d'utilisation d'ordinateur. Il traite la vérification non pas comme une étape d'évaluation en aval, mais comme le principe organisateur de la construction de l'environnement et des tâches. Le cadre se compose de quatre composants étroitement couplés :

1. Vérificateurs d'État Spécifiques aux Applications

OpenComputer construit une pile de vérification où chaque application prise en charge est appariée à un module vérificateur Python synthétique s'exécutant dans un bac à sable.

Canaux d'Inspection : Les vérificateurs utilisent les canaux d'inspection les plus fiables spécifiques à l'application disponibles, tels que les protocoles de débogage des navigateurs (CDP), D-Bus, les bases de données de profils basées sur SQLite, les API d'accessibilité (AT-SPI) et l'analyse directe de fichiers (par exemple, pour Inkscape, VS Code ou Blender).
Construction des Points de Terminaison : Le système génère des sous-commandes CLI avec des sorties JSON qui exposent des surfaces d'état structurées (contenu, préférences, historique, métadonnées).
Protocole de Test : Les vérificateurs subissent une boucle stricte de débogage-correction-nouvelle tentative avec des tests unitaires et d'intégration pour s'assurer qu'ils inspectent de manière fiable l'état logiciel réel plutôt que de s'appuyer sur un appariement heuristique.

2. Couche de Vérification Auto-Évolutive

Pour répondre aux erreurs résiduelles des vérificateurs (par exemple, hypothèses de schéma fragiles ou couverture incomplète), OpenComputer implémente une boucle d'évolution autonome :

Calibration : Un petit ensemble de tâches faciles à moyennes est exécuté par un agent performant dans un bac à sable.
Diagnostic des Désaccords : Un évaluateur LLM et le vérificateur programmatique produisent indépendamment des verdicts sur l'état final. Les désaccords attribués à des erreurs de vérificateur (plutôt qu'à des échecs d'agent) sont identifiés.
Raffinement : Le code du vérificateur, les points de terminaison ou la documentation sont affinés sur la base de cette rétroaction. Ce processus itère jusqu'à ce que le vérificateur s'aligne sur le jugement de référence ou qu'un budget soit épuisé.

3. Pipeline de Génération de Tâches

Les tâches sont synthétisées via un processus conscient du vérificateur :

Proposition : Le système propose des objectifs utilisateurs réalistes sans conditionnement sur les vérificateurs existants pour assurer la diversité.
Filtrage : Les propositions sont filtrées selon la complexité et la générabilité des données, en priorisant les flux de travail multi-étapes.
Ancrage : Les tâches sont ancrées dans la pile de vérification. Si un état est inspectable mais manque d'un point de terminaison, un nouveau point de terminaison est généré.
Synthèse : Le système matérialise la tâche en générant les fichiers, configurations et profils requis, en produisant une instance de tâche $\tau = (x, e, c)$ où $x$ est l'instruction, $e$ est l'initialisation de l'environnement et $c$ est le critère de réussite vérifiable par machine.

4. Arme d'Évaluation

L'arme exécute des agents dans de nouveaux bacs à sable de bureau, enregistrant les trajectoires complètes d'actions et de captures d'écran. La réussite est calculée en exécutant les commandes de vérification de la tâche contre l'état logiciel final. La récompense est la fraction de vérifications réussies ( $R = N_{pass}/N_{total}$ ), permettant un crédit partiel tout en maintenant des conditions de réussite exactes et vérifiables par machine.

Contributions Clés

Cadre OpenComputer : Un système ancré sur la vérification pour générer automatiquement des mondes logiciels réalistes, des descriptions de tâches et des vérificateurs sans construction manuelle.
Validation de la Fiabilité : Des preuves empiriques montrant que les vérificateurs codés en dur s'alignent plus étroitement sur l'adjudication humaine que l'évaluation par « LLM comme juge », en particulier pour les états d'application fins.
Benchmark à Grande Échelle : Une publication comprenant 33 applications de bureau et 1 000 tâches finalisées couvrant des navigateurs, des outils de bureautique, des logiciels créatifs, des environnements de développement et des applications de communication.

Résultats Expérimentaux

Les auteurs ont évalué des agents de pointe et open-source sur le benchmark OpenComputer :

Performance de Pointe : GPT-5.4 a atteint la performance la plus élevée avec un taux de réussite totale de tâche de 68,3 % et une récompense moyenne de 88,4 %. Claude-Sonnet-4.6 (64,4 %) et Kimi-K2.6 (58,8 %) ont suivi. Malgré des progrès partiels élevés, une complétion fiable de bout en bout reste difficile.
Écart Open-Source : Les modèles open-source ont présenté des baisses de performance significatives par rapport à leurs scores rapportés sur des benchmarks existants comme OSWorld. Par exemple, GUI-OWL-1.5-8B est passé d'un score OSWorld de 52,3 % à 5,7 % sur OpenComputer.
Efficacité : GPT-5.4 a été le plus efficace, avec une moyenne de 19,0 étapes par tâche, en partie grâce à sa capacité à combiner des opérations et à éviter de longues traces de raisonnement dans la sortie.
Alignement de Vérification : Dans une comparaison de 120 tâches, les vérificateurs codés en dur ont correspondu aux verdicts humains dans 94,1 % des cas, contre 79,2 % pour un juge LLM. Le vérificateur s'est avéré particulièrement supérieur pour détecter des erreurs dans les journaux de terminal, les panneaux réduits et les métadonnées de fichiers précises que les captures d'écran manquent.
Impact de l'Évolution Autonome : La couche de vérification auto-évolutive a réparé 89,4 % des erreurs côté vérificateur dans les tâches de calibration, améliorant l'accord humain-vérificateur de 85,2 % à 94,1 %.

Importance et Revendications

L'article revendique qu'OpenComputer fournit une infrastructure fondamentale pour la mise à l'échelle de la recherche sur l'utilisation d'ordinateurs en couplant des mondes logiciels réalistes à des retours vérifiables par machine. Les auteurs soutiennent que :

La Vérification est Critique : La synthèse évolutive pour les agents doit être couplée à une inspection fiable plutôt qu'à des évaluations par proxies faibles comme les juges LLM ou les captures d'écran.
Limitations Actuelles : Même les agents de pointe peinent à réaliser une complétion de bout en bout dans des flux de travail de bureau réalistes, exposant un écart dans l'automatisation informatique robuste.
Utilité Future : Le cadre soutient non seulement l'évaluation mais aussi les pipelines d'entraînement (par exemple, SFT, RL) en fournissant des récompenses auditable et ancrées. Il sert de point de départ contrôlé pour étudier la fiabilité des agents et les modes de défaillance dans des environnements logiciels complexes.

Les auteurs reconnaissent des limitations concernant les tâches nécessitant des jugements visuels ou géométriques (par exemple, la mise en page spatiale dans Draw.io) qui ne peuvent pas être entièrement réduites à des vérifications programmatiques ; de telles tâches sont exclues du benchmark principal pour maintenir la reproductibilité mais sont publiées pour de futures recherches sur la vérification hybride.