🤖 AI

PreAct: Computer-Using Agents that Get Faster on Repeated Tasks

PreAct is een systeem dat computergebruikende agenten bij herhaalde taken versnelt door succesvolle executies te compileren naar verifieerbare toestandsmachineprogramma's, wat 8,5–13x snellere replays mogelijk maakt met ingebouwde veiligheidscontroles om correctheid te waarborgen en de accumulatie van foutieve scripts te voorkomen.

Oorspronkelijke auteurs: Bojie Li

Gepubliceerd 2026-06-17

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Bojie Li

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 zeer dure robotassistent hebt. Deze robot kan naar je computerscherm kijken, uitzoeken welke knoppen hij moet klikken en tekst typen om taken te voltooien—zoals het boeken van een afspraak of het toevoegen van een contactpersoon.

Het probleem is dat deze robot verkwistend is. Elke keer dat je hem dezelfde taak twee keer vraagt, vergeet hij alles wat hij net heeft gedaan. Hij moet het scherm opnieuw bekijken, over elke stap nadenken en telkens opnieuw een enorme "denkvergoeding" betalen (door gebruik te maken van dure AI-rekenkracht). Het is alsof je een gids inhuurt die, nadat hij je één keer door het museum heeft geleid, ervoor zorgt dat je de volgende dag weer een compleet nieuwe gids moet betalen om precies hetzelfde museum te laten zien, ook al kent hij de indeling perfect.

PreAct is een nieuw systeem dat deze robot leert om vloeiend te worden in plaats van vergeetachtig. Zo werkt het, met behulp van alledaagse analogieën:

1. Het "Receptenboek" versus de "Chef"

Normaal gesproken gedraagt de robot zich als een chef die bij elke maaltijd elke ingrediënt proeft en het recept opnieuw uitvindt.
PreAct verandert de regels. De eerste keer dat de robot een taak succesvol voltooit (zoals het toevoegen van een contactpersoon), vergeet hij het niet zomaar. In plaats daarvan schrijft hij een perfect, stapsgewijs recept (een "state-machine programma").

De eerste keer: De robot gebruikt zijn dure "denkende brein" om de taak op te lossen en schrijft het recept. Dit kost tijd en geld.
De tweede keer: In plaats van zijn dure brein te gebruiken, leest de robot simpelweg het recept en volgt de instructies. Hij hoeft niet na te denken; hij handelt gewoon. Dit maakt hem 8,5 tot 13 keer sneller en bijna gratis in gebruik.

2. De "Veiligheidscontrole" (Niet blindelings volgen)

Je zou je kunnen afvragen: "Wat als het scherm er anders uitziet? Wat als er een pop-upvenster verschijnt?"
Als de robot het recept blindelings zou volgen, zou hij misschien op de verkeerde knop klikken en dingen kapotmaken.
PreAct is slim genoeg om dit te voorkomen. Voordat de robot elke stap uit het recept uitvoert, werpt hij een blik op het scherm om te controleren of het er precies zo uitziet als het recept verwacht.

Als het overeenkomt: Klikt hij direct op de knop (geen nadenken vereist).
Als het niet overeenkomt: Stopt hij onmiddellijk, zegt "Wacht, er is iets mis" en roept hij het dure robotbrein weer bij hulp om de nieuwe situatie uit te vogelen.
Dit is als een chauffeur die een GPS-route volgt, maar zijn ogen op de weg houdt. Als een weg is afgesloten, rijdt hij niet blindelings een muur in; hij stopt en vraagt om nieuwe aanwijzingen.

3. De "Kwaliteitscontrolepoort" (Het belangrijkste deel)

Hier komt het lastige deel: Wat als de robot een recept schrijft dat er volledig uitziet, maar eigenlijk faalt?
Voorbeeld: Het recept zegt "Typ naam, klik Opslaan." Maar misschien is de robot vergeten de naam daadwerkelijk te typen, waardoor er niets gebeurt wanneer hij op Opslaan klikt. Als de robot dit slechte recept opslaat, zal hij elke keer dat hij het probeert te gebruiken, falen.

PreAct heeft een strikte Kwaliteitscontrolepoort.
Voordat de robot een nieuw recept aan zijn bibliotheek toevoegt, reset hij de computer en voert hij het recept vanaf nul uit om te zien of het daadwerkelijk werkt.

Als het recept werkt: Wordt het aan de bibliotheek toegevoegd.
Als het recept faalt (zelfs als het helemaal tot het einde liep): Wordt het direct weggegooid.

Het onderzoek toonde aan dat zonder deze poort, de bibliotheek van de robot vol raakt met "slechte recepten", waardoor hij bij het uitvoeren van taken zelfs slechter wordt na verloop van tijd. Met deze poort wordt de robot juist beter elke keer dat hij een taak herhaalt.

De Resultaten

De onderzoekers testten dit op telefoons, desktops en websites.

Snelheid: Het herhalen van een taak werd 8,5 tot 13 keer sneller.
Kosten: De robot stopte met het betalen van de dure "denkvergoeding" voor herhaalde taken.
Betrouwbaarheid: Door bij elke stap het scherm te controleren en slechte recepten te filteren, werd het systeem niet alleen sneller, maar ook nauwkeuriger over de tijd.

Kortom: PreAct verandert een robot die telkens het wiel opnieuw uitvindt in een robot die een vaardigheid leert, deze opschrijft en deze vervolgens perfect en direct uitvoert—totdat er iets verandert, waarbij hij opnieuw leert. Het is het verschil tussen een student die een wiskundig probleem één keer uit het hoofd leert en een student die het vergeet en het elke dag opnieuw moet leren.

Technische Samenvatting: PreAct – Computer-gebruikende Agenten die Sneller Worden bij Herhaalde Taken

1. Probleemstelling

Computer-gebruikende agenten (CUAs) bedienen software door schermen te observeren en klikken of toetsaanslagen uit te voeren. Hoewel ze effectief zijn bij het oplossen van taken, zijn ze inherent inefficiënt bij herhaald werk. Huidige agenten behandelen elke taakinstantie als een nieuw probleem: ze lezen het scherm opnieuw, redeneren opnieuw door elke stap, en brengen de volledige kosten van visie-en-taal-inferentie in rekening voor elke uitvoering, zelfs als de taak identiek is aan een eerder opgeloste taak. Deze "herafleiding" voorkomt dat agenten de vloeiendheid verwerven die mensen ontwikkelen door oefening, waarbij initiële bewuste redenering wordt geïnternaliseerd in automatische routines. Bovendien falen bestaande efficiëntieverbeteringen—zoals skill-bibliotheken of record-and-replay-systemen—vaak in het balanceren van snelheid met betrouwbaarheid. Skill-bibliotheken vereisen doorgaans nog steeds een taalmodel (LLM) om opgeslagen gedragingen tijdens runtime uit te voeren, terwijl naïeve record-and-replay-systemen een gebrek aan verificatie hebben, wat leidt tot "blinde" uitvoering die faalt wanneer de omgeving verandert of wanneer de opgeslagen trace gebrekkig is.

2. Methodologie: PreAct Architectuur

PreAct introduceert een systeem dat succesvolle agent-runs compileert naar direct uitvoerbare state-machine-programma's. De kerninnovatie is een "verify-before-store"-discipline toegepast op twee tijdschalen: runtime-verificatie tijdens replay en pre-storage-verificatie voordat een programma wordt opgeslagen.

2.1 Het Artefact: State-Machine Programma's

In plaats van platte scripts of geparametriseerde codefragmenten te bewaren, compileert PreAct een succesvolle taakuitvoering naar een kleine state machine ( $P = (S, T, M, V)$ ):

Toestanden ( $S$ ): Elke toestand bevat een verificatie-predicaat (bijv. een XPath-patroon of een toegankelijkheidsboom-check) dat moet overeenstemmen met het live scherm voordat de agent verder gaat.
Transities ( $T$ ): Acties (klikken, typen, navigaties) die de agent van de ene toestand naar de andere bewegen.
Parameters ( $M$ ): Concreet getypte waarden tijdens de trace (bijv. een specifieke naam of telefoonnummer) worden verheven tot parameters, waardoor hetzelfde programma kan generaliseren over verschillende instanties van dezelfde taakfamilie.
Uitvoering: Tijdens een "warme" run loopt de Replayer door de graaf. Voordat een transitie wordt afgevuurd, controleert de Replayer het live scherm tegen het predicaat van de toestand. Als de controle slaagt, wordt de actie onmiddellijk uitgevoerd zonder een LLM-call. Als het faalt (bijv. er verscheen onverwacht een dialoogvenster), schakelt het systeem over naar de volledige CUA.

2.2 De Loop: Select, Replay, Fall Back, Verify

Het systeem werkt via een compile-extend-replace loop:

Select: Een Program Selector bevraagt de corpus op zoek naar een programma dat overeenkomt met het huidige doel.
Replay: Indien gevonden, voert de Replayer de state machine uit met verificatie per stap.
Fall Back: Als een predicaat faalt of een actie een fout geeft, wordt de controle overgedragen aan de volledige CUA, die de taak vanaf de huidige schermstatus oplost en een nieuwe trace opneemt.
Verify and Store: Bij succes wordt de nieuwe trace gecompileerd naar een kandidaat-programma $P'$ . Cruciaal is dat $P'$ niet onmiddellijk wordt opgeslagen. Het ondergaat een Verify-before-Store Gate.

2.3 De Verify-before-Store Gate

Dit is het primaire mechanisme van het systeem om monotone verbetering te garanderen. Voordat een programma de corpus betreedt:

De omgeving wordt gereset naar een schone begintoestand.
Het kandidaat-programma $P'$ wordt opnieuw gedraaid vanaf het begin.
Een onafhankelijke evaluator controleert of de taak daadwerkelijk is opgelost.
Het programma wordt (of vervangt een oudere versie met dezelfde dedup-signatuur) alleen als de replay succesvol wordt voltooid én de evaluator bevestigt dat de taak is opgelost.

Deze gate vangt specif specifiek "lossy" programma's op die wel naar 100% dekking replayed (alle acties worden uitgevoerd) maar de taak niet behalen (bijv. een contactformulier is ingevuld en opgeslagen, maar een verouderd veld voorkomt dat het contact wordt aangemaakt).

2.4 Fallback Mechanisme

Wanneer de gate alle kandidaat-programma's voor een taak afwijst (waardoor de corpus voor die taak leeg blijft), gebruikt PreAct een fallback: het triggert een frisse CUA-exploratie voor de tweede run. Dit zorgt ervoor dat zelfs als het systeem geen geverifieerd programma kan vinden, het niet simpelweg opgeeft, waardoor de prestatie gelijk blijft aan sterke record-and-replay baselines zoals Muscle-Mem.

3. Belangrijkste Bijdragen

Directe Uitvoering van Geverifieerde State Machines: PreAct verschuift het executieparadigma van LLM-gestuurde redenering naar deterministische graaf-executie voor herhaalde taken, waardoor per-stap LLM-calls worden geëlimineerd.
Verificatie op Twee Tijdschalen: Het systeem past dezelfde "observe-first, then-act" discipline toe tijdens runtime (per stap) en tijdens opslag (pre-storage re-run). Dit voorkomt de accumulatie van gebrekkige programma's die anders de prestaties in de loop van de tijd zouden verslechteren.
Zelf-uitbreidende Corpus: In tegenstelling tot append-only caches is de corpus van PreAct muteerbaar. Nieuwe programma's kunnen oudere vervangen als ze de verificatiegate passeren, waardoor het systeem zijn representatie van taken in de loop van de tijd kan verfijnen.
Empirische Validatie van Efficiëntie: Het artikel stelt "repeated-task efficiency" vast als een belangrijke metriek, waarbij niet alleen succespercentages worden gemeten, maar ook de reductie in wall-clock tijd en LLM-tokenkosten.

4. Experimentele Resultaten

De auteurs evalueerden PreAct op drie benchmarks: AndroidWorld (mobiel), OSWorld (desktop) en WebArena (web).

Snelheid en Kosten: Warme runs (het replaying van opgeslagen programma's) zijn 8,5–13× sneller in wall-clock tijd dan koude runs (het vanaf nul afleiden) en brengen nul per-stap LLM-kosten met zich mee. De eenmalige overhead van het compileren en verifiëren van een programma is ongeveer gelijk aan één extra solve (+162% op Android, +217% op OSWorld), maar dit wordt afgeschreven over opeenvolgende runs.
Monotone Verbetering: Met de verify-gate ingeschakeld, verbeteren of stabiliseren de herhaalde runs consistent in succespercentage.
- AndroidWorld: Gemiddelde verbetering van +1,33 taken (van 15) van koud naar warm.
- OSWorld: Gemiddelde verbetering van +0,2 taken (van 6).
- WebArena: Hoewel de gate zorgt voor een regressie in het ruwe warme succespercentage (door de hoge afwijzing van breekbare web-selectors), is de marginale waarde van de gate positief. Zonder de gate verslechtert de prestatie aanzienlijk (bijv. -5,8 taken op WebArena) naarmate lossy programma's zich ophopen. Met de gate wordt de degradatie verminderd (-4,0 taken).
De Noodzaak van de Gate: Ablatie-studies laten zien dat het uitschakelen van de verify-gate leidt tot een prestatie-instorting over alle platforms. De gate voorkomt de "loopt wel maar werkt niet" modus, waarbij een programma alle stappen uitvoert maar de taak logisch gezien faalt.
Effectiviteit van Fallback: Op WebArena, waar de gate veel programma's afwijst, zorgt het toevoegen van een "cache-miss-to-CUA" fallback ervoor dat PreAct de prestaties van de sterke baseline Muscle-Mem kan evenaren (statistisch ononderscheidbaar, $p \approx 0,84$ ), waardoor de kloof die door agressieve verificatie is ontstaan, wordt gedicht.
Robuustheid: De resultaten zijn robuust tegen de keuze van de LLM voor compilatie (Claude vs. Gemini) en de keuze van de selector (LLM-gebaseerd vs. embedding retriever). Het kernmechanisme, en niet de specifieke modelkeuze, drijft de resultaten.

5. Betekenis en Claims

Het artikel claimt dat PreAct aantoont dat computer-gebruikende agenten continual-learning capaciteiten kunnen verwerven die vergelijkbaar zijn met die van mensen: sneller en goedkoper worden bij herhaalde taken zonder de betrouwbaarheid op te offeren.

Vloeiendheid vs. Blindheid: PreAct bereikt vloeiendheid niet door blinde herhaling, maar door "voorspelling met verificatie". De agent handelt automatisch wanneer het scherm aan de verwachtingen voldoet, maar keert onmiddellijk terug naar deliberatie wanneer dat niet het geval is.
Design boven Tuning: De auteurs benadrukken dat de prestatiewinsten worden gedreven door de systeemarchitectuur (bewaar het programma dat je uitvoert, verifieer voordat je opslaat) in plaats van prompt engineering, runtime guardrails of specifieke modelkeuzes.
Een Nieuwe Evaluatiedimensie: Het artikel beargumenteert dat benchmarking verder moet gaan dan eenvoudige succespercentages en ook de kosten van herhaalde executie moet bevatten. Een agent die elke taak opnieuw afleidt, is minder efficiënt dan een agent die heeft geleerd om de deliberatie over te slaan, zelfs als beide hetzelfde succespercentage behalen.

Samenvattend biedt PreAct een framework waarbij agenten een bibliotheek van geverifieerde, direct uitvoerbare programma's opbouwen, waardoor ze bekende taken kunnen oplossen met de snelheid van een macro en de betrouwbaarheid van een geverifieerde agent, waarmee ze effectief de "herafleidingstaks" van huidige computer-gebruikende agenten oplossen.