💻 computer science

AutoRPA: Efficient GUI Automation through LLM-Driven Code Synthesis from Interactions

AutoRPA est un cadre qui comble le fossé entre les agents ReAct basés sur les LLM inefficaces et l'automatisation robotisée des processus (RPA) traditionnelle en distillant automatiquement les trajectoires d'interaction en des fonctions RPA robustes et réutilisables, permettant ainsi de réduire considérablement l'utilisation de jetons et les coûts d'exécution tout en maintenant les capacités de résolution de tâches.

Auteurs originaux : Minghao Chen, Xinyi Hu, Zhou Yu, Yufei Yin

Publié 2026-05-21

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Minghao Chen, Xinyi Hu, Zhou Yu, Yufei Yin

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 ayez un assistant personnel très intelligent, mais légèrement coûteux, nommé « LLM » (Large Language Model). Cet assistant est brillant pour comprendre comment utiliser un écran d'ordinateur ou de téléphone pour la première fois. Si vous lui demandez de « réserver un vol » ou de « supprimer une note », il peut regarder l'écran, réfléchir à ce qu'il faut faire, cliquer sur les bons boutons et accomplir la tâche.

Cependant, il y a un hic : Ils sont lents et coûteux à utiliser pour des tâches répétitives.

Chaque fois que vous lui demandez de réserver un vol, il doit « réfléchir » à partir de zéro. Il lit l'écran, planifie les étapes et clique. Si vous devez le faire 100 fois par jour, vous payez pour 100 heures de « réflexion », ce qui est un gaspillage d'argent et de temps.

D'un autre côté, avant l'existence de ces assistants intelligents, les gens utilisaient l'« Automatisation des Processus Robotisés » (RPA). Considérez la RPA comme un script préenregistré. C'est comme un robot qui clique aveuglément sur « Bouton 3, puis tapez 'Bonjour', puis cliquez sur 'Enregistrer' ». C'est incroyablement rapide et peu coûteux à exécuter. Mais c'est aussi fragile. Si le concepteur de l'application déplace le « Bouton 3 » vers un autre endroit, le robot plante car il ne sait pas s'adapter. Il a besoin d'un humain pour réécrire manuellement le script chaque fois que l'écran change.

Le Problème

Nous voulons la rapidité et le faible coût du robot (RPA) mais l'adaptabilité intelligente de l'assistant (LLM). Nous voulons une solution qui fonctionne pour les tâches répétitives (comme réserver des vols tous les jours) sans avoir besoin qu'un humain réécrive le code à chaque mise à jour de l'application.

La Solution : AutoRPA

L'article présente AutoRPA, un système qui agit comme un chef cuisinier qui transforme une démonstration culinaire désordonnée en une recette parfaite et réutilisable.

Voici comment cela fonctionne, étape par étape :

1. L'« Exploration » (Le Chef qui observe)

D'abord, AutoRPA utilise l'assistant LLM intelligent pour effectuer la tâche (par exemple, réserver un vol) une seule fois ou quelques fois. L'assistant regarde l'écran, réfléchit et clique. C'est la phase « ReAct ».

Analogie : Le chef observe un second cuisinier préparer un plat pour la première fois, notant chaque mouvement.

2. La « Traduction » (Transformer les notes en recette)

Les actions de l'assistant sont généralement « codées en dur » (par exemple, « Cliquez sur le bouton aux coordonnées pixels 144, 278 »). C'est problématique car si l'écran se décale, les coordonnées sont fausses.
AutoRPA dispose d'un Agent Traducteur spécial qui réécrit ces actions. Au lieu de dire « Cliquez à 144, 278 », il dit « Cliquez sur le bouton qui indique 'Réserver un vol' ».

Analogie : Le chef prend les notes désordonnées du second cuisinier (« Appuyez sur le point rouge en haut à droite ») et les réécrit sous forme d'instructions claires (« Appuyez sur le bouton 'Démarrer' rouge »). Cela permet à la recette de fonctionner même si la disposition de la cuisine change légèrement.

3. La « Construction » (Créer le script maître)

Un Agent Constructeur prend ces instructions traduites et flexibles et les combine en un seul programme informatique robuste (une fonction RPA). Il examine de nombreuses tentatives différentes (trajectoires) pour déterminer la meilleure façon de gérer les variations.

Analogie : Le chef rédige la carte de recette finale et professionnelle que n'importe qui, n'importe où, peut utiliser pour préparer ce plat parfaitement.

4. La « Réparation Hybride » (Le filet de sécurité)

Parfois, la nouvelle recette peut contenir un bug. Si le robot tente d'exécuter le code et échoue, AutoRPA n'abandonne pas simplement. Il dispose d'une Stratégie de Réparation Hybride :

Il met le robot en pause.
Il rappelle l'assistant LLM intelligent pour déterminer pourquoi il a échoué et comment le corriger à partir de ce point exact.
Il utilise la correction de l'assistant pour mettre à jour la recette.

Analogie : Si le robot brûle le toast, le chef intervient, répare le toast, puis met à jour la carte de recette afin que le robot ne brûle plus le toast la prochaine fois.

Les Résultats

L'article a testé cela sur trois environnements différents (applications Android, sites web et tâches web simulées).

Efficacité : Le nouveau code AutoRPA est 82 % à 96 % moins cher à exécuter que de demander à l'assistant intelligent d'effectuer la tâche à chaque fois. Cela économise une quantité massive d'utilisation de « tokens » (la monnaie de la réflexion de l'IA).
Taux de réussite : Il résout les tâches aussi bien, voire parfois mieux, que l'assistant intelligent seul, car le code généré est stable et ne se perd pas à cause de changements mineurs à l'écran.
Réutilisabilité : Une fois le code construit pour un « type » de tâche (comme « réserver un vol »), il peut être réutilisé pour des centaines d'instances spécifiques (réserver à New York, réserver à Londres) sans avoir besoin de réfléchir à nouveau.

Résumé

AutoRPA est un système qui observe une IA intelligente apprendre une tâche, traduit cet apprentissage en un script flexible et réutilisable, puis polit ce script jusqu'à ce qu'il soit parfait. Il nous offre le meilleur des deux mondes : l'intelligence pour gérer de nouvelles situations et l'efficacité d'un robot pour gérer le travail répétitif.

Résumé Technique : AutoRPA

Énoncé du Problème

Bien que les agents de Modèles de Langage à Grande Échelle (LLM) aient démontré leur compétence à interagir avec des Interfaces Graphiques Utilisateur (GUI) via le paradigme ReAct (Raisonnement et Action), ils rencontrent des inefficacités significatives dans le déploiement pratique. La plupart des recherches existantes optimisent la performance sur des tâches uniques pour des instances nouvelles, invoquant souvent un raisonnement coûteux de LLM pour chaque interaction. Cependant, les scénarios réels impliquent fréquemment des types de tâches répétitifs (par exemple, la saisie de rapports quotidiens, la réservation de vols) où invoquer un raisonnement de LLM pour chaque instance est computationnellement gaspillé et coûteux.

À l'inverse, l'Automatisation Robuste des Processus (RPA) traditionnelle offre une haute efficacité d'exécution pour les tâches répétitives mais souffre de fragilité. La RPA traditionnelle repose sur des scripts conçus manuellement qui sont rigides ; ils échouent lorsque les mises en page des GUI changent et nécessitent un effort humain considérable pour être développés et maintenus. Le défi central abordé par cet article est de savoir comment synthétiser automatiquement des fonctions RPA robustes et économes en tokens pour des types de tâches spécifiques en utilisant l'assistance des LLM, comblant ainsi le fossé entre la flexibilité des agents LLM et l'efficacité de la RPA traditionnelle.

Méthodologie : Le Cadre AutoRPA

AutoRPA est un cadre conçu pour « distiller » la logique de décision des agents de style ReAct en code RPA exécutable et réutilisable. Le processus est divisé en trois phases principales :

1. Phase d'Exploration

Génération de Trajectoires ReAct : Un agent de style ReAct interagit avec l'environnement GUI pour résoudre une instance de tâche. Il observe les captures d'écran et les structures d'interface (DOM/arborescences d'accessibilité), raisonne à travers les étapes et exécute des actions.
Réflexion : Si une trajectoire échoue, un mécanisme de réflexion permet à l'agent d'analyser l'échec et de réessayer (jusqu'à $N_{ref}$ fois) pour s'assurer que des trajectoires réussies sont collectées.
Traduction (Codage Dur vers Codage Doux) : Un Agent Traducteur dédié convertit les actions « codées en dur » de l'agent (par exemple, click(index=2)) en procédures « codées en douceur ». Au lieu de s'appuyer sur des indices fixes ou des coordonnées, le traducteur génère du code qui localise les éléments en fonction d'attributs sémantiques (par exemple, contenu textuel, type d'élément, descriptions cibles) en utilisant une fonction find_element. Cela garantit que la logique résultante est robuste face aux changements mineurs de mise en page.

2. Phase de Génération RPA

Agent Constructeur avec RAG : Un Agent Constructeur synthétise la fonction RPA finale ( $F_k$ ) pour un type de tâche spécifique ( $G_k$ ).
Génération Augmentée par Récupération (RAG) : Pour empêcher le constructeur de faire des hypothèses erronées sur l'état de l'interface en raison d'un contexte manquant, le cadre emploie un mécanisme de récupération organisé en arbre. Le constructeur peut interroger une base de données de trajectoires pour récupérer des blocs d'interaction spécifiques (observations, actions, résumés) provenant d'explorations réussies passées.
Synthèse de Code : Le constructeur génère une fonction Python qui inclut des structures logiques (boucles, conditionnelles) pour gérer les variations de tâches. Il élimine les étapes redondantes de la trajectoire traduite et intègre la gestion d'erreurs nécessaire. Le code peut également inclure des appels aux LLM Multi-Modaux (ask_mllm) pour des tâches de raisonnement complexes qui ne peuvent pas être résolues par des règles statiques.

3. Phase de Vérification avec Réparation Hybride

Exécution et Analyse : Le code RPA généré est exécuté sur des instances de tâches vues. Si l'exécution échoue, un Agent Analyseur identifie le point d'arrêt, analyse la cause de l'échec et détermine si la tâche peut être reprise ou doit être redémarrée.
Stratégie de Réparation Hybride : Plutôt que de s'appuyer uniquement sur l'affinement du code, le système emploie une approche hybride. Si le code échoue, l'agent ReAct reprend l'exécution à partir du point d'arrêt (ou redémarre) pour produire une démonstration corrective. Cette « trajectoire hybride » (exécution de code + réparation ReAct) est renvoyée à l'Agent Constructeur pour affiner le code de manière itérative.
Terminaison : Le processus se poursuit jusqu'à ce que le code passe toutes les tâches de validation ou qu'un nombre maximum de tentatives d'affinement ( $M$ ) soit atteint. Si la tâche reste non automatisable, le système utilise par défaut l'agent ReAct pour cette instance spécifique.

Contributions Clés

Cadre AutoRPA : Un système novateur qui génère automatiquement des fonctions RPA robustes pour des types de tâches, ciblant les scénarios d'automatisation GUI répétitifs où la RPA traditionnelle est trop fragile et les agents ReAct trop coûteux.
Pipeline Traducteur-Constructeur : Un processus en deux étapes où un traducteur convertit les actions ReAct codées en dur en procédures basées sur des attributs et codées en douceur, et un constructeur synthétise des fonctions RPA robustes en utilisant une récupération de trajectoires structurée en arbre (RAG).
Stratégie de Réparation Hybride : Un mécanisme de vérification qui combine l'exécution directe de code avec une solution de repli basée sur ReAct. Cela permet au système d'affiner itérativement le code en intégrant des démonstrations correctives de l'agent ReAct lorsque le code synthétisé échoue.
Efficacité et Robustesse : Le cadre réduit significativement la consommation de tokens tout en maintenant ou en améliorant les taux de réussite par rapport aux agents purement basés sur LLM.

Résultats Expérimentaux

Les auteurs ont évalué AutoRPA sur trois benchmarks : AndroidWorld (applications Android réelles), WebArena (tâches web réalistes) et MiniWoB++ (tâches web simulées).

Efficacité des Tokens : AutoRPA a réduit l'utilisation des tokens de 82 % à 96 % par rapport aux agents de style ReAct. Par exemple, sur AndroidWorld avec GPT-4o, AutoRPA n'a consommé que 14,7k tokens contre 79,9k pour ReAct.
Taux de Succès :
- Sur AndroidWorld, AutoRPA a atteint un taux de réussite de 37,0 % (GPT-4o), surpassant ReAct (35,2 %) et SeeAct (15,3 %), tout en utilisant significativement moins de tokens.
- Sur MiniWoB++, AutoRPA a atteint 91,1 % de réussite sur les tâches « difficiles » et 95,4 % sur toutes les tâches, surpassant des méthodes de pointe comme AdaPlanner et AutoManual, tout en consommant moins de 10 % des tokens requis par ReAct.
- Sur WebArena, AutoRPA a égalé les performances des méthodes antérieures mais avec une réduction drastique de la consommation de tokens.
Études d'Ablation : Les expériences ont confirmé que la suppression de la phase d'exploration ReAct, de l'agent traducteur, du mécanisme RAG ou de la stratégie de réparation hybride entraînait toutes des baisses significatives des taux de réussite, validant la nécessité de chaque composant.

Importance et Revendications

L'article revendique qu'AutoRPA répond à un problème pratique critique : le coût élevé et l'inefficacité de l'exécution d'agents LLM sur des tâches répétitives par rapport au coût de maintenance élevé de la RPA traditionnelle. En distillant la logique de décision des agents LLM en code vérifié et réutilisable, AutoRPA permet :

Automatisation Économe en Tokens : Réduire drastiquement le coût computationnel de l'automatisation GUI pour les types de tâches récurrents.
Robustesse : Générer du code qui gère mieux les variations de l'environnement et des instructions de tâche que les scripts statiques ou la génération LLM en un seul coup.
Évolutivité : Fournir une voie pour automatiser diverses tâches GUI sans nécessiter de scripts manuels étendus ou de connaissances d'experts soigneusement sélectionnées pour chaque nouveau type de tâche.

Les auteurs soulignent que leur méthode ne dépend pas d'agents ReAct spécifiques et peut être adaptée à diverses bases de LLM, en faisant une solution généralisable pour une automatisation GUI efficace.