Technische Samenvatting: Agent JIT-compilatie voor Latentie-geoptimaliseerde Webagent-planning en -scheduling

Probleemstelling

Computer-use agents (CUAs) automatiseren webgebaseerde taken die in natuurlijke taal zijn gespecificeerd (bijvoorbeeld "bestel het goedkoopste item bij Taco Bell") door sequenties van tooloproepen te genereren, zoals klikken, typen en scrollen. Huidige implementaties volgen doorgaans een sequentieel fetch-screenshot-execute-lus, waarbij elke iteratie een Large Language Model (LLM)-oproep vereist. Deze architectuur lijdt onder twee primaire beperkingen:

1. Hoge Latentie en Kosten: De noodzaak van een LLM-oproep bij elke stap creëert significante uitvoeringsvertragingen en hoge inferentiekosten.
2. Nauwkeurigheid en Foutpercentages: Naïeve toepassing van geavanceerde LLM's leidt tot frequente fouten, vaak voortkomend uit onjuiste volgorde van toolgebruik (bijvoorbeeld klikken op het verkeerde element of typen in het verkeerde veld) en een gebrek aan optimalisatie in uitvoerscheduling.

Bestaande pogingen om prestaties te verbeteren, zoals agressieve DOM-filtering of versterkt leren van kleinere modellen, vertrouwen nog steeds op statische toolsets en sequentiële uitvoering. Hierdoor wordt het volledige spectrum van uitvoerschema's (inclusief parallelisme en request hedging) niet verkend, en worden niet-deterministische LLM-oproepen tussen tooloproepen niet geëlimineerd.

Methodologie: Agent JIT-compilatie

De auteurs stellen Agent Just-In-Time (JIT)-compilatie voor, een systeem dat hoogwaardige instructies in natuurlijke taal vertaalt naar geoptimaliseerde, uitvoerbare code op het moment van plansynthese. In tegenstelling tot standaard agents die een lus van "observeren-denken-handelen" uitvoeren, compileert dit systeem een taak tot een statische codegrafiek die tooloproepen en inferentie orchestreert, waarbij de vertaling met de laagste geschatte kosten wordt geselecteerd. De architectuur bestaat uit drie kerncomponenten:

1. Invariant-afdwingend Toolprotocol

Om de correctheid van gegenereerde codeplannen te waarborgen, introduceert het systeem een protocol waarbij elke tool precondities en postcondities (state-invarianten) specificeert.

• Structuur: Tools definiëren verwachte staten voor uitvoering (pre), gegarandeerde staten na uitvoering (post), en optionele runtime-predicaten (pre_check, post_check) voor debugging.
• Verificatie: Dit maakt compositional verificatie op compilatietijd mogelijk. Een tooloproep is alleen geldig als de huidige staat aan de preconditie voldoet. Deze statische controle elimineert een grote klasse fouten veroorzaakt door onjuiste actieseries (bijvoorbeeld proberen een item te bestellen voordat naar de detailpagina is genavigeerd).
• Voordeel: Het protocol verschuift de latentie-nauwkeurigheid Pareto-grens, waardoor het percentage geldige plangeneratie aanzienlijk toeneemt.

2. Kostenoptimaliserende Planner (JIT-Planner)

De planner genereert meerdere kandidaat-codeplannen parallel, valideert deze tegen het toolprotocol en selecteert de kandidaat met de minimale kosten.

• Parallelle Generatie: Meerdere workers bemonsteren gelijktijdig codeplannen uit een LLM.
• CFG-gebaseerde Validatie: Elk plan wordt omgezet in een Control Flow Graph (CFG). Het systeem traverseert de grafiek om de staatstroom te verifiëren (waarbij post van stap $i$ aan pre van stap $i+1$ moet voldoen) en de kosten te schatten.
• Kostenmodel: Kosten worden opgebouwd op basis van tooloproepen en AI-evaluatie (ai_eval) oproepen. Een nestingsstraf ($\gamma$) wordt toegepast om geneste lussen die dure LLM-oproepen bevatten, te ontmoedigen.
• Uitkomst: De planner selecteert het geldige plan met de laagste geschatte kosten, waarbij vaak onnodige LLM-oproepen worden vervangen door pure code-logica (bijvoorbeeld het berekenen van de minimumprijs in code in plaats van de LLM te vragen).

3. Kostenbewuste Scheduler (JIT-Scheduler)

De scheduler bepaalt de optimale uitvoerstrategie voor een gegeven plan op basis van geleerde latentieverdelingen. Het evalueert drie strategieën:

• Serieel: Sequentiële uitvoering.
• Parallel: Taakparallelisme over $n$ workers.
• Hedge: Speculatieve parallelle uitvoering waarbij $n$ redundante workers dezelfde taak uitvoeren en het eerste geldige resultaat wordt teruggegeven.
• Mechanisme: Met behulp van Monte Carlo-kostenschatting bemonstert de scheduler uit geleerde latentieverdelingen van specifieke DOM-elementen (offline verzameld). Het voorspelt met welke elementen een plan zal interageren en schat de verwachte latentie voor elke strategie, waarbij die met de minimale gemiddelde latentie wordt geselecteerd.

Offline Caching

Het systeem vertrouwt op een offline proces om twee caches te vullen:

1. Planner Cache: Koppelt hoogwaardige acties aan herbruikbare, protocol-conforme toolcode (gesynthetiseerd uit uitvoertraces).
2. Scheduler Cache: Koppelt pagina-schema-elementen aan latentieverdelingen (gefit uit historische uitvoertraces).

Belangrijkste Bijdragen

1. Invariant-afdwingend Toolprotocol: Breidt standaard toolinterfaces uit met state-invarianten, waardoor statische verificatie van toolseries mogelijk wordt en generatiefouten worden verminderd.
2. Kostenoptimaliserende Planning: Introduceert een planner die parallelle kandidaten genereert, deze valideert via CFG-traversie en het uitvoerpad met de laagste kosten selecteert, waardoor redundante LLM-oproepen effectief worden geëlimineerd.
3. Kostenbewuste Scheduling: Implementeert een scheduler die dynamisch kiest tussen seriële, parallelle en hedging-strategieën op basis van Monte Carlo-simulaties van geleerde latentieverdelingen.
4. End-to-End Systeem: Integreert deze componenten in een JIT-compiler die taken in natuurlijke taal vertaalt naar geoptimaliseerde uitvoerbare code, verdergaand dan de standaard agent-lus.

Resultaten

Het systeem werd geëvalueerd over 37 taken op vijf webapplicaties (Dashdish, GitLab, Gomail, Omnizon, Reddit) met behulp van diverse geavanceerde LLM's.

• JIT-Planner Prestaties:

  • Bereikte een 10,4× snelheidswinst ten opzichte van de standaard Browser-Use-baseline.
  • Verbeterde de nauwkeurigheid met +28% ten opzichte van Browser-Use.
  • Toonde aan dat kostenschatting plannen effectief rangschikt: het verschil tussen de beste-kosten- en slechtste-kosten-kandidaat was een 5,3× variantie in latentie.
  • Het invariantprotocol verlaagde het faalpercentage van plangeneratie van 80% naar 43% en verschuift de dominante faalmodus van toolvolgorde-overtredingen naar andere typen.

• JIT-Scheduler Prestaties:

  • Bereikte een 2,4× snelheidswinst en een +9% verbetering in nauwkeurigheid ten opzichte van OpenAI's CUA.
  • Presteerde beter dan vaste schedulingstrategieën (Serieel, Parallel, Hedge) door adaptief de optimale strategie per taak te selecteren. Bijvoorbeeld, het identificeerde correct dat taken met hoog-variabele UI-elementen (bijvoorbeeld het vinden van een specifieke knop) profiteren van hedging, terwijl eenvoudige opzoekingen profiteren van seriële uitvoering.

• Complexiteitsanalyse:

  • Snelheidswinsten waren consistent over taakcardinaliteit (laag, medium, hoog) en lengte, wat aangeeft dat de voordelen voornamelijk voortkomen uit het elimineren van per-stap LLM-inferentie in plaats van taakspecifieke heuristieken.
  • Applicaties met complexe navigatiepatronen (bijvoorbeeld Reddit) zagen de hoogste snelheidswinsten (tot 18,9×), terwijl die met eenvoudigere flows lagere maar nog steeds significante winsten zagen.

Betekenis en Claims

Het artikel claimt dat Agent JIT-compilatie een veelbelovende richting biedt voor het verbeteren van de efficiëntie en betrouwbaarheid van computer-use agents. Door agent-planning te behandelen als een compilatieprobleem, doet het systeem het volgende:

1. Ontkoppelt Planning van Uitvoering: Het maakt optimalisatie van het volledige uitvoeringsgrafiek mogelijk vóór runtime, in plaats van greedy, stap-voor-stap beslissingen te nemen.
2. Vermindert Non-determinisme: Door state-invarianten af te dwingen en taken te compileren naar code, wordt de afhankelijkheid van non-deterministische LLM-oproepen tijdens uitvoering verminderd, wat leidt tot hogere nauwkeurigheid.
3. Optimaliseert Resourcegebruik: Door kostenbewuste scheduling past het zich aan aan de specifieke latentiekenmerken van webinteracties, waardoor de afweging tussen latentie en nauwkeurigheid effectiever wordt gebalanceerd dan met statische strategieën.

De auteurs merken op dat de aanpak het meest geschikt is voor applicaties die een agent herhaaldelijk zal afhandelen, omdat het een offline setupkosten vereist (tool-synthese en trace-verzameling) om de benodigde caches te bouwen. Zij erkennen beperkingen met betrekking tot UI-wijzigingen (die gecachte tools kunnen breken) en sterk stochastische omgevingen (bijvoorbeeld CAPTCHA's), maar stellen dat het invariantprotocol een mechanisme biedt voor runtime-detectie en fallback.