💻 computer science

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

AutoRPA is een raamwerk dat de kloof tussen inefficiënte op LLM gebaseerde ReAct-agenten en traditionele RPA overbrugt door interactietrajecten automatisch te distilleren tot robuuste, herbruikbare RPA-functies, waardoor aanzienlijke verminderingen in tokengebruik en runtimekosten worden bereikt terwijl de taakoplossende capaciteiten behouden blijven.

Oorspronkelijke auteurs: Minghao Chen, Xinyi Hu, Zhou Yu, Yufei Yin

Gepubliceerd 2026-05-21

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Minghao Chen, Xinyi Hu, Zhou Yu, Yufei Yin

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een zeer slimme, maar iets dure, persoonlijke assistent hebt met de naam "LLM" (Large Language Model). Deze assistent is briljant in het uitvinden hoe je voor het eerst een computerscherm of telefoonscherm bedient. Als je hen vraagt om "een vlucht te boeken" of "een notitie te verwijderen", kunnen ze naar het scherm kijken, nadenken over wat ze moeten doen, op de juiste knoppen klikken en het werk klaren.

Er is echter een addertje onder het gras: Ze zijn traag en duur om te gebruiken voor repetitieve taken.

Elke keer als je hen vraagt om een vlucht te boeken, moeten ze vanaf nul "nadenken". Ze lezen het scherm, plannen de stappen en klikken. Als je dit 100 keer per dag moet doen, betaal je voor 100 uur "nadenken", wat een verspilling van geld en tijd is.

Aan de andere kant, voordat deze slimme assistenten bestonden, gebruikten mensen "Robotic Process Automation" (RPA). Denk aan RPA als een vooraf opgenomen script. Het is als een robot die blindelings klikt op "Knop 3, typ dan 'Hallo', klik dan op 'Opslaan'". Het is ongelooflijk snel en goedkoop om uit te voeren. Maar het is ook kwetsbaar. Als de ontwerper van de app "Knop 3" naar een andere plek verplaatst, crasht de robot omdat hij niet weet hoe hij zich moet aanpassen. Er is een mens nodig om het script handmatig te herschrijven telkens wanneer het scherm verandert.

Het Probleem

We willen de snelheid en goedkoopheid van de robot (RPA) maar ook de slimme aanpasbaarheid van de assistent (LLM). We willen een oplossing die werkt voor repetitieve taken (zoals elke dag vluchten boeken) zonder dat een mens de code moet herschrijven telkens wanneer de app wordt bijgewerkt.

De Oplossing: AutoRPA

Het artikel introduceert AutoRPA, een systeem dat werkt als een hoofdkok die een rommelige kookdemonstratie omzet in een perfect, herbruikbaar recept.

Zo werkt het, stap voor stap:

1. De "Verkenning" (De Kok Kijkt Toe)

Eerst gebruikt AutoRPA de slimme LLM-assistent om de taak (bijvoorbeeld het boeken van een vlucht) slechts een of een paar keer uit te voeren. De assistent kijkt naar het scherm, denkt na en klikt. Dit is de "ReAct"-fase.

Analogie: De kok kijkt toe hoe een sous-chef voor het eerst een gerecht bereidt en noteert elke beweging.

2. De "Vertaling" (Het Omzetten van Notities in een Recept)

De acties van de assistent zijn meestal "hard-coded" (bijvoorbeeld: "Klik op de knop op pixelcoördinaten 144, 278"). Dit is slecht omdat, als het scherm verschuift, de coördinaten verkeerd zijn.
AutoRPA heeft een speciale Vertaler-Agent die deze acties herschrijft. In plaats van te zeggen "Klik op 144, 278", zegt het "Klik op de knop met de tekst 'Boek Vlucht'".

Analogie: De kok neemt de rommelige notities van de sous-chef ("Druk op de rode stip rechtsboven") en herschrijft ze als een duidelijke instructie ("Druk op de rode 'Start'-knop"). Hierdoor werkt het recept zelfs als de indeling van de keuken iets verandert.

3. De "Bouw" (Het Creëren van het Hoofdschript)

Een Bouwer-Agent neemt deze vertaalde, flexibele instructies en combineert ze tot één robuust computerprogramma (een RPA-functie). Het bekijkt vele verschillende pogingen (trajecten) om de beste manier te bepalen om variaties aan te pakken.

Analogie: De kok schrijft het definitieve, professionele recept dat door iedereen, overal, kan worden gebruikt om dat gerecht perfect te bereiden.

4. De "Hybride Reparatie" (Het Veiligheidsnet)

Soms heeft het nieuwe recept een bug. Als de robot probeert de code uit te voeren en faalt, geeft AutoRPA niet zomaar op. Het heeft een Hybride Reparatiestrategie:

Het pauzeert de robot.
Het roept de slimme LLM-assistent terug om uit te zoeken waarom het mislukte en hoe het vanaf dat exacte punt kan worden opgelost.
Het gebruikt de oplossing van de assistent om het recept bij te werken.

Analogie: Als de robot de toast verbrandt, komt de kok tussenbeide, repareert de toast en werkt vervolgens het recept bij zodat de robot de toast de volgende keer niet opnieuw verbrandt.

De Resultaten

Het artikel testte dit op drie verschillende omgevingen (Android-apps, websites en gesimuleerde webtaken).

Efficiëntie: De nieuwe AutoRPA-code is 82% tot 96% goedkoper om uit te voeren dan het vragen aan de slimme assistent om de taak elke keer opnieuw te doen. Het bespaart een enorme hoeveelheid "token"-gebruik (de valuta van AI-nadenken).
Succespercentage: Het lost taken net zo goed op, of soms zelfs beter dan de slimme assistent alleen, omdat de gegenereerde code stabiel is en niet in de war raakt door kleine schermveranderingen.
Herbruikbaarheid: Zodra de code is gebouwd voor een "type" taak (zoals "een vlucht boeken"), kan het worden hergebruikt voor honderden specifieke gevallen (boeken naar New York, boeken naar Londen) zonder opnieuw na te hoeven denken.

Samenvatting

AutoRPA is een systeem dat kijkt hoe een slimme AI een taak leert, die leerervaring vertaalt naar een flexibel, herbruikbaar script, en dat script vervolgens polijst totdat het perfect is. Het geeft ons het beste van twee werelden: de intelligentie om met nieuwe situaties om te gaan en de efficiëntie van een robot voor repetitief werk.

Technische Samenvatting: AutoRPA

Probleemstelling

Hoewel Agents op basis van Large Language Models (LLM) bekwaamheid hebben getoond in het interageren met Grafische Gebruikersinterfaces (GUI) via het ReAct-paradigma (Redeneren en Handelen), ondervinden ze aanzienlijke inefficiënties bij praktische implementatie. Het merendeel van het bestaande onderzoek optimaliseert voor prestaties op een enkele taak bij nieuwe instanties, waarbij vaak dure LLM-redenering wordt ingeroepen voor elke interactie. Echter, real-world scenario's omvatten frequent herhalende taaktypen (bijvoorbeeld het dagelijks indienen van rapporten of het boeken van vluchten), waarbij het voor elke instantie LLM-redenering inroepen computationeel verspillend en kostbaar is.

Daarentegen biedt traditionele Robotic Process Automation (RPA) hoge runtime-efficiëntie voor repetitieve taken, maar lijdt het aan broosheid. Traditionele RPA vertrouwt op handmatig gemaakte scripts die stijf zijn; ze falen wanneer GUI-indelingen veranderen en vereisen aanzienlijke menselijke inspanning voor ontwikkeling en onderhoud. De kernuitdaging die door dit artikel wordt aangepakt, is hoe men automatisch robuuste, token-efficiënte RPA-functies voor specifieke taaktypen kan synthetiseren met LLM-ondersteuning, waardoor de kloof wordt overbrugd tussen de flexibiliteit van LLM-agents en de efficiëntie van traditionele RPA.

Methodologie: Het AutoRPA-kader

AutoRPA is een kader dat is ontworpen om de beslissingslogica van ReAct-stijl agents te "distilleren" naar uitvoerbare, herbruikbare RPA-code. Het proces is verdeeld in drie hoofdfasen:

1. Verkenningsfase

ReAct-trajectgeneratie: Een ReAct-stijl agent interageert met de GUI-omgeving om een taakinstantie op te lossen. Het observeert screenshots en UI-structuren (DOM/toegankelijkheidsbomen), redeneert door stappen heen en voert acties uit.
Reflectie: Als een traject faalt, laat een reflectiemechanisme de agent toe om het falen te analyseren en opnieuw te proberen (tot $N_{ref}$ keer) om ervoor te zorgen dat succesvolle trajecten worden verzameld.
Vertaling (Hard-naar-Soft Coding): Een dedicated Vertaler-agent converteert de "hard-coded" acties van de agent (bijvoorbeeld click(index=2)) naar "soft-coded" procedures. In plaats van te vertrouwen op vaste indices of coördinaten, genereert de vertaler code die elementen lokaliseert op basis van semantische attributen (bijvoorbeeld tekstinhoud, elementtype, doelbeschrijvingen) met behulp van een find_element-functie. Dit zorgt ervoor dat de resulterende logica robuust is tegen kleine indelingswijzigingen.

2. RPA-Generatiefase

Builder-agent met RAG: Een Builder-agent synthetiseert de definitieve RPA-functie ( $F_k$ ) voor een specifiek taaktype ( $G_k$ ).
Retrieval-Augmented Generation (RAG): Om te voorkomen dat de builder foutieve aannames doet over de interface-status vanwege ontbrekende context, hanteert het kader een boom-georganiseerd retrieval-mechanisme. De builder kan een trajectdatabase bevragen om specifieke interactieblokken (observaties, acties, samenvattingen) op te halen uit eerdere succesvolle verkenningen.
Code-synthese: De builder genereert een Python-functie die logische structuren (lussen, conditionele statements) bevat om taakvariaties te hanteren. Het snoeit overbodige stappen uit het vertaalde traject en integreert noodzakelijke foutafhandeling. De code kan ook calls bevatten naar Multi-Modal LLM's (ask_mllm) voor complexe redeneertaken die niet via statische regels kunnen worden opgelost.

3. Verificatiefase met Hybride Reparaties

Uitvoering en Analyse: De gegenereerde RPA-code wordt uitgevoerd op geziene taakinstanties. Als de uitvoering faalt, identificeert een Analyzer-agent het breekpunt, analyseert de oorzaak van het falen en bepaalt of de taak kan worden hervat of opnieuw moet worden gestart.
Hybride Reparatiestrategie: In plaats van uitsluitend te vertrouwen op codeverfijning, hanteert het systeem een hybride aanpak. Als de code faalt, hervat de ReAct-agent de uitvoering vanaf het breekpunt (of start opnieuw) om een corrigerende demonstratie te produceren. Deze "hybride traject" (code-uitvoering + ReAct-reparatie) wordt teruggevoerd naar de Builder-agent om de code iteratief te verfijnen.
Beëindiging: Het proces gaat door totdat de code alle validatietaken slaagt of een maximum aantal verfijningspogingen ( $M$ ) is bereikt. Als de taak niet kan worden geautomatiseerd, schakelt het systeem over naar het gebruik van de ReAct-agent voor die specifieke instantie.

Belangrijkste Bijdragen

AutoRPA-kader: Een nieuw systeem dat automatisch robuuste RPA-functies genereert voor taaktypen, gericht op repetitieve GUI-automatiseringsscenario's waar traditionele RPA te broos is en ReAct-agents te kostbaar.
Vertaler-Builder-pijplijn: Een tweestapsproces waarbij een vertaler hard-coded ReAct-acties converteert naar soft-coded, op attributen gebaseerde procedures, en een builder robuuste RPA-functies synthetiseert met behulp van boom-gestructureerde trajectretrieval (RAG).
Hybride Reparatiestrategie: Een verificatiemechanisme dat directe code-uitvoering combineert met ReAct-gebaseerde fallback. Dit stelt het systeem in staat om code iteratief te verfijnen door corrigerende demonstraties van de ReAct-agent te integreren wanneer de gesynthetiseerde code faalt.
Efficiëntie en Robuustheid: Het kader reduceert succesvol het tokenverbruik aanzienlijk terwijl het de slagingspercentages behoudt of verbetert in vergelijking met pure LLM-gebaseerde agents.

Experimentele Resultaten

De auteurs hebben AutoRPA geëvalueerd op drie benchmarks: AndroidWorld (real-world Android-apps), WebArena (realistische webtaken) en MiniWoB++ (gesimuleerde webtaken).

Token-efficiëntie: AutoRPA verlaagde het tokenverbruik met 82% tot 96% in vergelijking met ReAct-stijl agents. Bijvoorbeeld, op AndroidWorld met GPT-4o verbruikte AutoRPA slechts 14,7k tokens versus 79,9k voor ReAct.
Slagingspercentages:
- Op AndroidWorld behaalde AutoRPA een slagingspercentage van 37,0% (GPT-4o), wat beter presteerde dan ReAct (35,2%) en SeeAct (15,3%), terwijl het aanzienlijk minder tokens verbruikte.
- Op MiniWoB++ behaalde AutoRPA 91,1% succes op "moeilijke" taken en 95,4% op alle taken, wat beter presteerde dan state-of-the-art-methoden zoals AdaPlanner en AutoManual, terwijl het minder dan 10% van de tokens verbruikte die door ReAct nodig waren.
- Op WebArena kwam AutoRPA overeen met de prestaties van eerdere methoden, maar met een drastische reductie in tokenverbruik.
Ablatiestudies: Experimenten bevestigden dat het verwijderen van de ReAct-verkenningsfase, de vertaler-agent, het RAG-mechanisme of de hybride reparatiestrategie allemaal leidden tot aanzienlijke dalingen in slagingspercentages, wat de noodzaak van elk onderdeel valideert.

Betekenis en Beweringen

Het artikel beweert dat AutoRPA een kritiek praktisch probleem aanpakt: de hoge kosten en inefficiëntie van het draaien van LLM-agents op repetitieve taken versus de hoge onderhoudskosten van traditionele RPA. Door de beslissingslogica van LLM-agents te distilleren naar geverifieerde, herbruikbare code, stelt AutoRPA het volgende in staat:

Token-efficiënte automatisering: Het drastisch verminderen van de computationele kosten van GUI-automatisering voor terugkerende taaktypen.
Robuustheid: Het genereren van code die variaties in omgeving en taakinstructies beter aanpakt dan statische scripts of single-shot LLM-generatie.
Schaalbaarheid: Het bieden van een pad om diverse GUI-taken te automatiseren zonder uitgebreid handmatig scripten of verzorgde expertkennis voor elk nieuw taaktype te vereisen.

De auteurs benadrukken dat hun methode niet afhankelijk is van specifieke ReAct-agents en kan worden aangepast aan verschillende LLM-ruggengraten, waardoor het een generaliseerbare oplossing is voor efficiënte GUI-automatisering.