🤖 machine learning

Agent JIT Compilation for Latency-Optimizing Web Agent Planning and Scheduling

Dieser Beitrag stellt die Agent-JIT-Kompilierung vor, ein Framework, das aus einem Planer, einem Scheduler und einem Invarianten-erzwingenden Protokoll besteht und natürliche Sprachaufgaben in ausführbaren Code umwandelt, um im Vergleich zu herkömmlichen sequenziellen Web-Agent-Schleifen erhebliche Beschleunigungen und Genauigkeitsverbesserungen zu erzielen.

Ursprüngliche Autoren: Caleb Winston, Ron Yifeng Wang, Azalia Mirhoseini, Christos Kozyrakis

Veröffentlicht 2026-05-21

📖 5 Min. Lesezeit🧠 Tiefgang

CC BY 4.0

Ursprüngliche Autoren: Caleb Winston, Ron Yifeng Wang, Azalia Mirhoseini, Christos Kozyrakis

Originalarbeit lizenziert unter CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dies ist eine KI-generierte Erklärung des untenstehenden Papers. Sie wurde nicht von den Autoren verfasst oder gebilligt. Für technische Genauigkeit konsultieren Sie das Originalpaper. Vollständigen Haftungsausschluss lesen

Stellen Sie sich vor, Sie versuchen, einem Roboter einen komplexen Auftrag zu erteilen, wie zum Beispiel „Bestellen Sie das billigste Taco bei Taco Bell".

Derzeit arbeiten die meisten Roboter wie ein sehr vorsichtiger, langsamer menschlicher Assistent. Sie schauen auf den Bildschirm, fragen ein superintelligentes Gehirn (eine KI) nach dem nächsten Schritt, klicken auf einen Button, warten, bis sich der Bildschirm ändert, fragen das Gehirn erneut, tippen ein Wort ein, warten und fragen wieder. Diese „Schauen-Denken-Handeln"-Schleife wiederholt sich immer wieder. Sie ist langsam, teuer (weil das KI-Gehirn jedes Mal Geld kostet, wenn man es fragt) und fehleranfällig, da der Roboter möglicherweise auf das Falsche klickt, wenn der Bildschirm nur geringfügig anders aussieht.

Diese Arbeit stellt eine neue Methode vor, um diese Roboter schneller und intelligenter zu machen, genannt Agent JIT Compilation. Man kann sich das vorstellen wie den Wechsel von einer „Schritt-für-Schritt-Anleitung" zum „Schreiben eines benutzerdefinierten Software-Skripts", noch bevor der Roboter überhaupt in Bewegung setzt.

So funktioniert es, aufgeteilt in drei einfache Teile:

1. Der „Pre-Flight"-Planer (JIT-Planner)

Anstatt bei jedem einzelnen Schritt die KI zu fragen „Was soll ich als Nächstes tun?", generiert das System zunächst Ihre Anfrage („Bestellen Sie das billigste Taco") und erstellt sofort mehrere verschiedene Computerprogramme (Code), die das Problem lösen könnten.

Die Analogie: Stellen Sie sich vor, Sie müssen von New York nach Boston fahren.
- Alter Weg: Sie halten an jeder Tankstelle an und fragen einen Einheimischen: „Wie komme ich nach Boston?" Sie fahren eine Meile, fragen erneut, fahren eine weitere Meile, fragen wieder.
- Neuer Weg: Bevor Sie losfahren, bitten Sie eine Karten-App, drei verschiedene Routen zu generieren. Sie prüft den Verkehr, die Straßenverhältnisse und die Entfernung. Sie wählt die absolut schnellste Route aus und schreibt die GPS-Koordinaten einmalig in das Navigationssystem Ihres Autos. Dann fahren Sie einfach los.
Der Zauber: Das System überprüft diese generierten Routen, um sicherzustellen, dass sie logisch sind (z. B. können Sie nicht auf „Bestellen" klicken, bevor Sie nicht auf „In den Warenkorb" geklickt haben). Es wählt diejenige aus, die die geringste Menge an „Gehirnkraft" (KI-Aufrufe) und Zeit benötigt.

2. Der „Verkehrspolizist" (JIT-Scheduler)

Sobald der Roboter einen Plan hat, muss er entscheiden, wie er ihn ausführt. Soll er alles nacheinander erledigen? Soll er versuchen, drei Dinge gleichzeitig zu tun? Oder soll er dieselbe Aufgabe dreimal parallel versuchen und einfach die erste verwenden, die fertig wird?

Die Analogie: Stellen Sie sich vor, Sie bestellen Essen für eine Party.
- Seriell (Eins nach dem anderen): Sie rufen ein Restaurant an, warten auf die Antwort, rufen das nächste an, warten...
- Parallel: Sie rufen drei Restaurants gleichzeitig an.
- Absicherung (Hedging): Sie rufen drei Restaurants an, aber es interessiert Sie nur der erste, der abhebt. Wenn einer langsam ist, warten Sie nicht; Sie nehmen einfach die Antwort von dem schnellen.
Der Zauber: Das System betrachtet die spezifische Aufgabe und nutzt vergangene Daten, um zu erraten, welche Strategie am besten ist. Wenn die Aufgabe einfach ist, geht es eins nach dem anderen vor. Wenn die Aufgabe knifflig ist und stecken bleiben könnte, versucht es mehrere Pfade gleichzeitig (Absicherung), um sicherzustellen, dass sie schnell abgeschlossen wird. Es wählt die Strategie aus, die die meiste Zeit spart.

3. Das „Regelwerk" (Invariant-Enforcing Protocol)

Um sicherzustellen, dass der Roboter nicht abstürzt oder auf den falschen Button klickt, kommt jedes Werkzeug, das der Roboter verwendet (wie „Button klicken" oder „Text tippen"), mit einem strengen Regelwerk.

Die Analogie: Denken Sie an einen Automaten.
- Alter Weg: Sie drücken einfach zufällig auf Tasten. Manchmal drücken Sie auf „Imbiss", wenn der Automat leer ist, und nichts passiert.
- Neuer Weg: Der Automat hat einen Sensor. Er prüft: „Ist der Automat an? Ist Geld eingeworfen? Ist die Tür geschlossen?" Wenn die Bedingungen nicht erfüllt sind, verweigert der Automat das Drücken der Taste.
Der Zauber: Bevor der Roboter den Code ausführt, prüft er diese Regeln. Wenn ein Plan versucht, zu „Bestellen", wenn der „Warenkorb" leer ist, fängt das System diesen Fehler bevor der Roboter überhaupt beginnt, ab und verhindert so Fehler und Zeitverschwendung.

Die Ergebnisse

Die Autoren testeten dies auf fünf verschiedenen Websites (wie Lieferdienste für Essen, E-Mail- und Einkaufsseiten). Die Ergebnisse waren beeindruckend:

Geschwindigkeit: Ihre neue Methode war 10-mal schneller als die Standardmethode „KI bei jedem Schritt fragen".
Genauigkeit: Sie war auch 28 % genauer, was bedeutet, dass sie tatsächlich 28 % öfter das richtige Taco bekam.
Vergleich: Selbst im Vergleich zu anderen fortschrittlichen KI-Agenten (wie denen von OpenAI oder Anthropic) war ihre Methode 2,4-mal schneller und 9 % genauer.

Zusammenfassung

Kurz gesagt besagt diese Arbeit: Fragen Sie die KI nicht, das Auto Schritt für Schritt zu steuern. Lassen Sie stattdessen die KI die gesamte Fahrstrecke als Skript schreiben, prüfen Sie, ob die Route sicher ist, wählen Sie den schnellsten Weg, sie zu fahren, und führen Sie dann einfach das Skript aus. Dies verwandelt ein langsames, stotterndes Gespräch in eine reibungslose, hochgeschwindigkeitsfähige Ausführung.

Technische Zusammenfassung: Agent-JIT-Kompilierung für latenzoptimierte Web-Agenten-Planung und -Steuerung

Problemstellung

Computer-Nutzungs-Agenten (CUAs) automatisieren webbasierte Aufgaben, die in natürlicher Sprache spezifiziert sind (z. B. „bestelle den günstigsten Artikel bei Taco Bell"), indem sie Sequenzen von Tool-Aufrufen wie Klick, Eingabe und Scrollen generieren. Aktuelle Implementierungen folgen typischerweise einer sequenziellen Fetch-Screenshot-Ausführungs-Schleife, wobei jede Iteration einen Aufruf eines Large Language Model (LLM) erfordert. Diese Architektur leidet unter zwei Hauptbeschränkungen:

Hohe Latenz und Kosten: Die Notwendigkeit eines LLM-Aufrufs bei jedem Schritt erzeugt erhebliche Ausführungsverzögerungen und hohe Inferenzkosten.
Genauigkeit und Fehlerraten: Die naive Anwendung fortschrittlicher LLMs führt zu häufigen Fehlern, die oft auf falsche Sequenzen von Tool-Aufrufen zurückzuführen sind (z. B. Klicken auf das falsche Element oder Eingabe in das falsche Feld) sowie auf mangelnde Optimierung der Ausführungsplanung.

Bestehende Versuche zur Leistungsverbesserung, wie aggressives DOM-Filtern oder Reinforcement Learning kleinerer Modelle, verlassen sich weiterhin auf statische Tool-Sets und sequenzielle Ausführung. Sie versagen darin, den gesamten Raum der Ausführungspläne (einschließlich Parallelisierung und Request-Hedging) zu erschließen oder nicht-deterministische LLM-Aufrufe zwischen Tool-Invokationen zu eliminieren.

Methodik: Agent-JIT-Kompilierung

Die Autoren schlagen Agent Just-In-Time (JIT) Compilation vor, ein System, das hochrangige Anweisungen in natürlicher Sprache zur Plan-Synthesezeit in optimierten, ausführbaren Code übersetzt. Im Gegensatz zu Standard-Agenten, die eine Schleife aus „Beobachten-Denken-Handeln" ausführen, kompiliert dieses System eine Aufgabe in einen statischen Code-Graphen, der Tool-Aufrufe und Inferenz orchestriert und die Übersetzung mit den niedrigsten geschätzten Kosten auswählt. Die Architektur besteht aus drei Kernkomponenten:

1. Invarianten erzwingendes Tool-Protokoll

Um die Korrektheit generierter Code-Pläne sicherzustellen, führt das System ein Protokoll ein, bei dem jedes Tool Vorbedingungen und Nachbedingungen (Zustandsinvarianten) spezifiziert.

Struktur: Tools definieren erwartete Zustände vor der Ausführung (pre), garantierte Zustände nach der Ausführung (post) und optionale Laufzeitprädikate (pre_check, post_check) zur Fehleranalyse.
Verifikation: Dies ermöglicht eine kompositionelle Verifikation zur Kompilierungszeit. Ein Tool-Aufruf ist nur gültig, wenn der aktuelle Zustand seine Vorbedingung erfüllt. Diese statische Prüfung eliminiert eine große Klasse von Fehlern, die durch falsche Aktionssequenzen verursacht werden (z. B. der Versuch, einen Artikel zu bestellen, bevor zur Detailseite navigiert wurde).
Vorteil: Das Protokoll verschiebt die Latenz-Genauigkeits-Pareto-Grenze und erhöht signifikant die Rate der Generierung valider Pläne.

2. Kostenoptimierender Planer (JIT-Planner)

Der Planer generiert parallel mehrere Kandidaten-Code-Pläne, validiert sie gegen das Tool-Protokoll und wählt den Kandidaten mit den minimalen Kosten aus.

Parallele Generierung: Mehrere Worker sampeln gleichzeitig Code-Pläne aus einem LLM.
CFG-basierte Validierung: Jeder Plan wird in einen Kontrollflussgraphen (CFG) umgewandelt. Das System durchläuft den Graphen, um den Zustandsfluss zu verifizieren (sicherstellen, dass post von Schritt $i$ pre von Schritt $i+1$ erfüllt) und die Kosten abzuschätzen.
Kostenmodell: Kosten werden basierend auf Tool-Aufrufen und KI-Bewertungsaufrufen (ai_eval) akkumuliert. Eine Verschachtelungsstrafe ( $\gamma$ ) wird angewendet, um verschachtelte Schleifen zu vermeiden, die teure LLM-Aufrufe beinhalten.
Ergebnis: Der Planer wählt den gültigen Plan mit den niedrigsten geschätzten Kosten aus und ersetzt oft unnötige LLM-Aufrufe durch reine Code-Logik (z. B. Berechnung des Mindestpreises im Code statt Anfrage an das LLM).

3. Kostenbewusster Scheduler (JIT-Scheduler)

Der Scheduler bestimmt die optimale Ausführungsstrategie für einen gegebenen Plan basierend auf erlernten Latenzverteilungen. Er bewertet drei Strategien:

Serial: Sequenzielle Ausführung.
Parallel: Aufgabenparallelismus über $n$ Worker.
Hedge: Spekulative parallele Ausführung, bei der $n$ redundante Worker dieselbe Aufgabe ausführen und das erste gültige Ergebnis zurückgegeben wird.
Mechanismus: Mithilfe von Monte-Carlo-Kostenschätzung sampelt der Scheduler aus erlernten Latenzverteilungen spezifischer DOM-Elemente (offline gesammelt). Er sagt voraus, mit welchen Elementen ein Plan interagieren wird, und schätzt die erwartete Latenz für jede Strategie, wobei diejenige mit der minimalen mittleren Latenz ausgewählt wird.

Offline-Caching

Das System verlässt sich auf einen Offline-Prozess zur Befüllung zweier Caches:

Planner-Cache: Ordnet hochrangige Aktionen wiederverwendbare, protokollkonforme Tool-Code-Stücken zu (synthetisiert aus Ausführungs-Traces).
Scheduler-Cache: Ordnet Seitenschema-Elementen Latenzverteilungen zu (angepasst an historische Ausführungs-Traces).

Hauptbeiträge

Invarianten erzwingendes Tool-Protokoll: Erweitert Standard-Tool-Schnittstellen um Zustandsinvarianten, ermöglicht statische Verifikation von Tool-Sequenzen und reduziert Generierungsfehler.
Kostenoptimierte Planung: Führt einen Planer ein, der parallele Kandidaten generiert, diese via CFG-Durchlauf validiert und den kostengünstigsten Ausführungspfad auswählt, wodurch redundante LLM-Aufrufe effektiv eliminiert werden.
Kostenbewusste Steuerung: Implementiert einen Scheduler, der dynamisch zwischen seriellen, parallelen und Hedging-Strategien basierend auf Monte-Carlo-Simulationen erlernter Latenzverteilungen wählt.
End-to-End-System: Integriert diese Komponenten in einen JIT-Compiler, der natürliche Sprachaufgaben in optimierten ausführbaren Code übersetzt und über die Standard-Agentenschleife hinausgeht.

Ergebnisse

Das System wurde über 37 Aufgaben hinweg auf fünf Webanwendungen (Dashdish, GitLab, Gomail, Omnizon, Reddit) unter Verwendung verschiedener fortschrittlicher LLMs evaluiert.

Leistung des JIT-Planners:
- Erzielte eine 10,4-fache Beschleunigung gegenüber dem Standard-Browser-Use-Baseline.
- Verbesserte die Genauigkeit um +28 % gegenüber Browser-Use.
- Zeigte, dass die Kostenschätzung Pläne effektiv rankt: Der Unterschied zwischen den Kandidaten mit den besten und schlechtesten Kosten betrug eine Latenzvarianz von 5,3-fach.
- Das Invarianten-Protokoll reduzierte die Ausfallrate der Planerstellung von 80 % auf 43 % und verschob den dominanten Ausfallmodus von Verletzungen der Tool-Reihenfolge zu anderen Fehlertypen.
Leistung des JIT-Schedulers:
- Erzielte eine 2,4-fache Beschleunigung und eine +9 %ige Genauigkeitsverbesserung gegenüber OpenAIs CUA.
- Übertraf feste Steuerungsstrategien (Serial, Parallel, Hedge) durch die adaptive Auswahl der optimalen Strategie pro Aufgabe. Beispielsweise identifizierte es korrekt, dass Aufgaben mit hochvarianzen UI-Elementen (z. B. das Finden eines bestimmten Buttons) von Hedging profitieren, während einfache Suchen von serieller Ausführung profitieren.
Komplexitätsanalyse:
- Die Beschleunigungen waren konsistent über die Kardinalität der Aufgaben (niedrig, mittel, hoch) und die Länge hinweg, was darauf hindeutet, dass die Vorteile primär aus der Eliminierung der LLM-Inferenz pro Schritt resultieren und nicht aus aufgabenspezifischen Heuristiken.
- Anwendungen mit komplexen Navigationsmustern (z. B. Reddit) verzeichneten die höchsten Beschleunigungen (bis zu 18,9-fach), während solche mit einfacheren Abläufen niedrigere, aber dennoch signifikante Gewinne erzielten.

Bedeutung und Behauptungen

Die Arbeit behauptet, dass Agent JIT Compilation eine vielversprechende Richtung zur Verbesserung der Effizienz und Zuverlässigkeit von Computer-Nutzungs-Agenten darstellt. Indem die Agentenplanung als Kompilierungsproblem behandelt wird, ermöglicht das System:

Entkopplung von Planung und Ausführung: Es erlaubt die Optimierung des gesamten Ausführungsgraphen vor der Laufzeit, anstatt gierige, schrittweise Entscheidungen zu treffen.
Reduzierung von Nicht-Determinismus: Durch die Erzwingung von Zustandsinvarianten und die Kompilierung von Aufgaben in Code wird die Abhängigkeit von nicht-deterministischen LLM-Aufrufen während der Ausführung reduziert, was zu höherer Genauigkeit führt.
Optimierung der Ressourcennutzung: Durch kostenbewusste Steuerung passt es sich an die spezifischen Latenzeigenschaften von Web-Interaktionen an und balanciert den Trade-off zwischen Latenz und Genauigkeit effektiver aus als statische Strategien.

Die Autoren stellen fest, dass der Ansatz am besten für Anwendungen geeignet ist, die ein Agent wiederholt handhabt, da er Offline-Einrichtungskosten (Tool-Synthese und Trace-Sammlung) erfordert, um die notwendigen Caches zu erstellen. Sie erkennen Einschränkungen bezüglich UI-Änderungen (die gecachte Tools brechen können) und hochstochastischer Umgebungen (z. B. CAPTCHAs) an, betonen jedoch, dass das Invarianten-Protokoll einen Mechanismus für die Laufzeiterkennung und Fallback bietet.