Résumé Technique : UI-KOBE

Énoncé du Problème

Les récents progrès des agents d'interface graphique (GUI) mobiles ont démontré un potentiel significatif pour l'automatisation des tâches, mais les systèmes efficaces reposent actuellement fortement sur des modèles vision-langage (VLM) à grande échelle pour la compréhension des captures d'écran et la planification à long terme. Cette dépendance présente deux défis pratiques principaux :

1. Contraintes de Déploiement : Les grands modèles open-source nécessitent des ressources informatiques substantielles, rendant le déploiement sur appareil difficile, tandis que les modèles propriétaires entraînent des coûts d'API élevés.
2. Limitations des Capacités : Les modèles plus petits adaptés au déploiement sur appareil (par exemple, à l'échelle de 4 milliards de paramètres) éprouvent souvent des difficultés avec le raisonnement et la planification à long terme lorsqu'ils sont chargés d'exécuter des interfaces graphiques de bout en bout à partir de captures d'écran uniquement. Cela impose une charge excessive à leur capacité limitée, conduisant à une exécution de tâches peu fiable.

Bien que les agents légers offrent des coûts d'inférence réduits et une meilleure préservation de la vie privée en maintenant les données sensibles locales, leur capacité à effectuer des tâches GUI complexes reste un défi ouvert.

Méthodologie : UI-KOBE

Les auteurs proposent UI-KOBE (Exploration de Comportements Orientée Connaissance), un cadre conçu pour découpler l'acquisition des connaissances d'une application de l'exécution des tâches. Au lieu de s'appuyer uniquement sur un raisonnement de bout en bout au moment de l'exécution, UI-KOBE construit un graphe de connaissances réutilisable et spécifique à l'application par une exploration autonome, qui guide ensuite un agent léger lors de l'exécution de la tâche.

1. Représentation par Graphe

UI-KOBE modélise une application comme un graphe orienté $G_A = (V, E)$ :

• Nœuds ($V$) : Représentent des états d'interface utilisateur (UI) sémantiques distincts (par exemple, une « page de recherche » ou une « page de paramètres ») plutôt que des captures d'écran individuelles. Un nœud inclut une description sémantique de la page, un schéma d'état (valeurs dynamiques visibles), une capture d'écran de référence et des éléments interactables. Cette abstraction permet à différentes captures d'écran ayant le même rôle fonctionnel de mapper vers le même nœud.
• Arêtes ($E$) : Représentent les transitions exécutables observées entre les états de l'interface utilisateur. Chaque arête stocke les nœuds source et cible, l'action exécutée (JSON), une instruction en langage naturel et une observation cible. Les arêtes peuvent être :
  • Transitions : Déplacements entre différents nœuds (par exemple, de la page de recherche à la page de résultats).
  • Boucles de rétroaction (Self-loops) : Actions modifiant l'état de l'écran actuel sans changer le modèle d'interface utilisateur (par exemple, mettre à jour un champ de requête), enregistrées avec un delta de schéma.

2. Exploration Autonome

Le cadre emploie une boucle itérative observer-identifier-planifier-agir pour construire le graphe :

• Observation et Identification : L'agent observe un écran, génère une description sémantique et la compare aux embeddings de nœuds existants. Si une correspondance est trouvée (vérifiée par comparaison de captures d'écran pour éviter les erreurs sémantiques), le nœud est mis à jour ; sinon, un nouveau nœud est créé.
• Planification et Exécution d'Actions : L'agent sélectionne des interactions non explorées basées sur la page actuelle et les transitions existantes, ancrant une instruction en langage naturel dans une seule action d'appareil (taper, écrire, balayer).
• Enregistrement des Transitions : La transition résultante est enregistrée comme une arête. Le graphe est sauvegardé de manière incrémentielle pour permettre la reprise après des interruptions.
• Raffinement : Un audit postérieur fusionne les nœuds dupliqués, signale les arêtes peu fiables et normalise les instructions concrètes en modèles réutilisables (par exemple, abstraire « Tapez Starbucks » en « Saisir la requête »). Une ré-exploration orientée vers la couverture garantit que les nœuds sous-explorés sont visités.

3. Agent d'Exécution Guidé par le Graphe

Au moment de l'exécution, un agent GUI léger utilise le graphe préconstruit comme source de connaissances externe pour remplacer la planification ouverte par une prise de décision guidée :

• Récupération de Nœuds : Étant donné une tâche et une capture d'écran actuelle, l'agent récupère des nœuds candidats via un embedding visuel et sélectionne la meilleure correspondance en utilisant une vérification sémantique basée sur un modèle.
• Prise de Décision : Une fois le nœud actuel identifié, l'agent sélectionne l'action suivante parmi un ensemble contraint d'options prises en charge par le graphe :
  1. Terminaison de la Tâche : Arrêter l'exécution.
  2. Actions de Boucle de Rétroaction : Modifier l'état de l'écran actuel.
  3. Transitions Voisines : Passer aux nœuds adjacents.
  4. Actions Libres : Une option de repli pour les actions non couvertes par le graphe.
• Mécanisme de Repli : Si l'écran ne peut pas être associé à un nœud ou si l'action requise est absente, l'agent invoque un planificateur naïf pour une seule étape, assurant la robustesse sans revenir à un raisonnement de bout en bout complet.
• Mémoire : Un module de mémoire léger suit les progrès de la tâche (par exemple, instructions terminées, faits extraits) pour éviter les actions redondantes et aider à déterminer la terminaison de la tâche.

Contributions Clés

1. Changement de Paradigme : Propose de découpler l'acquisition des connaissances d'une application de l'exécution des tâches, permettant des agents GUI mobiles guidés par graphe pour des modèles légers.
2. Cadre UI-KOBE : Introduit une méthode pour construire des graphes de connaissances d'applications réutilisables via une exploration autonome, avec des définitions principielles des états d'interface utilisateur sémantiques (nœuds) et des transitions exécutables (arêtes).
3. Agent Guidé par Graphe : Conçoit un agent d'exécution qui exploite le contexte local du graphe pour remplacer la planification de bout en bout par une prise de décision guidée, améliorant substantiellement la capacité et la fiabilité des petits agents GUI.

Résultats Expérimentaux

Le cadre a été évalué sur deux benchmarks : AndroidWorld (automatisation de tâches interactives sur Android) et A3 (tâches réalistes d'applications mobiles en ligne avec des états d'interface utilisateur dynamiques).

• Gains de Performance : UI-KOBE a constamment amélioré les taux de réussite des tâches à travers différentes échelles de modèles (Qwen3.5-4B, 9B et Plus).
  • Sur AndroidWorld, UI-KOBE avec un modèle 4B a atteint un taux de réussite de 70,7 %, surpassant significativement le même modèle de base sans guidage par graphe (58,6 %) et dépassant de nombreux agents mono-modèles plus grands (par exemple, UI-TARS-72B à 46,6 %).
  • Sur A3, UI-KOBE avec un modèle 4B a atteint un Taux de Réalisation d'État Essentiel (ESAR) de 71,5 % et un Taux de Succès Global (SR) de 61 %, contre 43,7 % pour l'ESAR et 26 % pour le SR du modèle de base 4B.
• Évolutivité : Les bénéfices se sont étendus aux modèles plus grands (9B et Plus), UI-KOBE + Qwen3.5-Plus atteignant les taux de réussite globaux les plus élevés (77,6 % sur AndroidWorld, 78 % sur A3), surpassant des cadres agentiques puissants comme T3A.
• Efficacité des Coûts : La construction du graphe a engendré un coût unique (moyenne de 6,2 $ et 3,2 heures par application), qui est amorti sur les exécutions de tâches répétées.

Importance et Revendications

L'article revendique que UI-KOBE offre une étape pratique vers des agents GUI sur appareil efficaces, interprétables et respectueux de la vie privée. En réduisant la charge de la planification de bout en bout, le cadre permet aux modèles légers d'exécuter des tâches GUI mobiles de manière plus fiable. L'approche améliore l'interprétabilité en ancrant chaque action dans des structures de graphe explicites et soutient la réutilisation entre les tâches sans exploration répétée. Les auteurs soutiennent que les connaissances d'applications réutilisables constituent une direction prometteuse pour construire des agents GUI à la fois déployables sur des appareils aux ressources contraintes et efficaces dans des scénarios complexes à long terme.

Limites

Les auteurs reconnaissent plusieurs limites :

• Dépendance à la Version : Le graphe dépend de la version de l'application et peut nécessiter une réparation incrémentielle ou une ré-exploration si l'interface utilisateur change de manière significative.
• Contraintes de Déploiement : Bien que visant des agents sur appareil, le système actuel repose sur un modèle d'embedding externe pour la récupération du graphe, empêchant un déploiement entièrement local.
• Portée : Les expériences sont limitées aux applications mobiles ; l'efficacité sur les sites web et les applications PC reste à vérifier.