🤖 machine learning

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

Ce papier présente la compilation JIT d'agents, un cadre comprenant un planificateur, un ordonnanceur et un protocole garantissant les invariants, qui convertit des tâches en langage naturel en code exécutable pour obtenir des accélérations significatives et des améliorations de précision par rapport aux boucles séquentielles traditionnelles d'agents web.

Auteurs originaux : Caleb Winston, Ron Yifeng Wang, Azalia Mirhoseini, Christos Kozyrakis

Publié 2026-05-21

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Caleb Winston, Ron Yifeng Wang, Azalia Mirhoseini, Christos Kozyrakis

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 essayez de faire accomplir à un robot une tâche complexe pour vous, comme « Commander le taco le moins cher chez Taco Bell ».

Actuellement, la plupart des robots fonctionnent comme un assistant humain très prudent et lent. Ils regardent l'écran, demandent à un cerveau surintelligent (une IA) quoi faire ensuite, cliquent sur un bouton, attendent que l'écran change, demandent à nouveau au cerveau, tapent un mot, attendent, et demandent encore. Cette boucle « regarder-penser-agir » se répète encore et encore. C'est lent, coûteux (car le cerveau IA coûte de l'argent à chaque fois que vous le sollicitez), et sujet aux erreurs, car le robot pourrait cliquer sur le mauvais élément si l'écran ressemble légèrement différent.

Ce papier introduit une nouvelle méthode pour rendre ces robots plus rapides et plus intelligents, appelée Compilation JIT d'Agent. Considérez cela comme le passage d'un « manuel d'instructions étape par étape » à la « rédaction d'un script logiciel personnalisé » avant même que le robot ne commence à bouger.

Voici comment cela fonctionne, décomposé en trois parties simples :

1. Le Planificateur « Pré-vol » (JIT-Planner)

Au lieu de demander à l'IA « Que devrais-je faire ensuite ? » à chaque étape, le système prend d'abord votre demande (« Commander le taco le moins cher ») et génère instantanément plusieurs programmes informatiques (codes) différents qui pourraient résoudre le problème.

L'analogie : Imaginez que vous devez conduire de New York à Boston.
- Ancienne méthode : Vous vous arrêtez à chaque station-service pour demander à un local : « Quelle est la direction de Boston ? » Vous conduisez un mile, demandez à nouveau, conduisez un autre mile, demandez encore.
- Nouvelle méthode : Avant de partir, vous demandez à une application de cartes de générer trois itinéraires différents. Elle vérifie le trafic, l'état des routes et la distance. Elle choisit l'itinéraire absolument le plus rapide et inscrit les coordonnées GPS dans le système de navigation de votre voiture une seule fois. Ensuite, vous conduisez simplement.
La magie : Le système vérifie ces itinéraires générés pour s'assurer qu'ils sont logiques (par exemple, vous ne pouvez pas cliquer sur « Commander » avant d'avoir cliqué sur « Ajouter au panier »). Il choisit celui qui utilise le moins de « puissance cérébrale » (appels à l'IA) et de temps.

2. Le « Agent de circulation » (JIT-Scheduler)

Une fois que le robot a un plan, il doit décider comment l'exécuter. Doit-il tout faire un par un ? Doit-il essayer de faire trois choses à la fois ? Ou doit-il essayer la même tâche trois fois en parallèle et simplement utiliser la première qui se termine ?

L'analogie : Imaginez que vous commandez de la nourriture pour une fête.
- Séquentiel (Un par un) : Vous appelez un restaurant, attendez la réponse, appelez le suivant, attendez...
- Parallèle : Vous appelez trois restaurants en même temps.
- Couverture (Hedging) : Vous appelez trois restaurants, mais vous ne vous souciez que du premier qui décroche. Si l'un est lent, vous n'attendez pas ; vous prenez simplement la réponse de celui qui est rapide.
La magie : Le système examine la tâche spécifique et utilise des données passées pour deviner quelle stratégie est la meilleure. Si la tâche est simple, il procède un par un. Si la tâche est délicate et risque de bloquer, il essaie plusieurs chemins à la fois (couverture) pour s'assurer qu'elle se termine rapidement. Il choisit la stratégie qui économise le plus de temps.

3. Le « Code de règles » (Protocole d'application des invariants)

Pour s'assurer que le robot ne plante pas ou ne clique pas sur le mauvais bouton, chaque outil utilisé par le robot (comme « cliquer sur un bouton » ou « taper du texte ») est accompagné d'un code de règles strict.

L'analogie : Pensez à un distributeur automatique.
- Ancienne méthode : Vous appuyez simplement sur les boutons au hasard. Parfois, vous appuyez sur « Snack » alors que la machine est vide, et rien ne se passe.
- Nouvelle méthode : La machine possède un capteur. Elle vérifie : « La machine est-elle allumée ? Y a-t-il de l'argent à l'intérieur ? La porte est-elle fermée ? » Si les conditions ne sont pas remplies, la machine refuse de vous laisser appuyer sur le bouton.
La magie : Avant que le robot n'exécute le code, il vérifie ces règles. Si un plan tente de « Commander » alors que le « Panier » est vide, le système détecte cette erreur avant même que le robot ne commence, empêchant ainsi les erreurs et le temps perdu.

Les Résultats

Les auteurs ont testé cela sur cinq sites web différents (comme des sites de livraison de nourriture, d'e-mail et de shopping). Les résultats étaient impressionnants :

Vitesse : Leur nouvelle méthode était 10 fois plus rapide que la méthode standard « demander à l'IA à chaque étape ».
Précision : Elle était également 28 % plus précise, ce qui signifie qu'elle obtenait réellement le bon taco 28 % plus souvent.
Comparaison : Même par rapport à d'autres agents IA avancés (comme ceux d'OpenAI ou d'Anthropic), leur méthode était 2,4 fois plus rapide et 9 % plus précise.

Résumé

En bref, ce papier dit : Ne demandez pas à l'IA de conduire la voiture étape par étape. Au lieu de cela, faites en sorte que l'IA écrive l'itinéraire complet de conduite sous forme de script, vérifie que l'itinéraire est sûr, choisisse le moyen le plus rapide de le conduire, puis exécutez simplement le script. Cela transforme une conversation lente et saccadée en une exécution fluide et à grande vitesse.

Résumé technique : Compilation JIT d'agents pour la planification et l'ordonnancement d'agents web optimisés en latence

Énoncé du problème

Les agents d'utilisation d'ordinateur (CUA) automatisent des tâches web spécifiées en langage naturel (par exemple, « commander l'article le moins cher chez Taco Bell ») en générant des séquences d'appels d'outils tels que cliquer, taper et faire défiler. Les implémentations actuelles suivent généralement une boucle séquentielle de récupération, capture d'écran et exécution, où chaque itération nécessite un appel à un grand modèle de langage (LLM). Cette architecture souffre de deux limitations principales :

Latence et coût élevés : La nécessité d'un appel LLM à chaque étape crée des délais d'exécution significatifs et des coûts d'inférence élevés.
Précision et taux d'erreur : L'application naïve des LLM de pointe entraîne des erreurs fréquentes, provenant souvent de séquences d'utilisation d'outils incorrectes (par exemple, cliquer sur le mauvais élément ou taper dans le mauvais champ) et d'un manque d'optimisation dans l'ordonnancement de l'exécution.

Les tentatives existantes pour améliorer les performances, telles que le filtrage agressif du DOM ou l'apprentissage par renforcement de modèles plus petits, reposent toujours sur des ensembles d'outils statiques et une exécution séquentielle, échouant à explorer l'espace complet des calendriers d'exécution (y compris le parallélisme et la protection des requêtes) ou à éliminer les appels LLM non déterministes entre les invocations d'outils.

Méthodologie : Compilation JIT d'agents

Les auteurs proposent la Compilation Juste-à-Temps (JIT) d'agents, un système qui traduit des instructions de haut niveau en langage naturel en code exécutable optimisé au moment de la synthèse du plan. Contrairement aux agents standards qui exécutent une boucle « observer-penser-agir », ce système compile une tâche en un graphe de code statique qui orchestre les appels d'outils et l'inférence, sélectionnant la traduction ayant le coût estimé le plus bas. L'architecture se compose de trois composants principaux :

1. Protocole d'outils imposant des invariants

Pour garantir l'exactitude des plans de code générés, le système introduit un protocole où chaque outil spécifie des préconditions et des postconditions (invariants d'état).

Structure : Les outils définissent les états attendus avant l'exécution (pre), les états garantis après l'exécution (post), et des prédicats d'exécution facultatifs (pre_check, post_check) pour le débogage.
Vérification : Cela permet une vérification compositionnelle au moment de la compilation. Un appel d'outil n'est valide que si l'état actuel satisfait sa précondition. Cette vérification statique élimine une grande classe d'erreurs causées par des séquences d'actions incorrectes (par exemple, tenter de commander un article avant de naviguer vers la page de détail).
Avantage : Le protocole déplace la frontière de Pareto latence-précision, augmentant considérablement le taux de génération de plans valides.

2. Planificateur optimisant les coûts (JIT-Planner)

Le planificateur génère plusieurs plans de code candidats en parallèle, les valide par rapport au protocole d'outils et sélectionne le candidat de coût minimal.

Génération parallèle : Plusieurs travailleurs échantillonnent simultanément des plans de code à partir d'un LLM.
Validation basée sur CFG : Chaque plan est converti en un graphe de flux de contrôle (CFG). Le système parcourt le graphe pour vérifier le flux d'état (en s'assurant que le post de l'étape $i$ satisfait le pre de l'étape $i+1$ ) et estime le coût.
Modèle de coût : Les coûts sont accumulés en fonction des appels d'outils et des appels d'évaluation par IA (ai_eval). Une pénalité de nesting ( $\gamma$ ) est appliquée pour décourager les boucles imbriquées impliquant des appels LLM coûteux.
Résultat : Le planificateur sélectionne le plan valide ayant le coût estimé le plus bas, remplaçant souvent les appels LLM inutiles par une logique de code pure (par exemple, calculer le prix minimum dans le code plutôt que de demander au LLM).

3. Ordonnanceur conscient des coûts (JIT-Scheduler)

L'ordonnanceur détermine la stratégie d'exécution optimale pour un plan donné en fonction de distributions de latence apprises. Il évalue trois stratégies :

Série : Exécution séquentielle.
Parallèle : Parallélisme des tâches sur $n$ travailleurs.
Protection (Hedge) : Exécution parallèle spéculative où $n$ travailleurs redondants exécutent la même tâche, et le premier résultat valide est renvoyé.
Mécanisme : En utilisant une estimation de coût par Monte Carlo, l'ordonnanceur échantillonne à partir de distributions de latence apprises d'éléments DOM spécifiques (collectées hors ligne). Il prédit quels éléments un plan interagit et estime la latence attendue pour chaque stratégie, sélectionnant celle ayant la latence moyenne minimale.

Mise en cache hors ligne

Le système repose sur un processus hors ligne pour remplir deux caches :

Cache du planificateur : Mappe les actions de haut niveau vers du code d'outil réutilisable et conforme au protocole (synthétisé à partir de traces d'exécution).
Cache de l'ordonnanceur : Mappe les éléments du schéma de page aux distributions de latence (ajustées à partir de traces d'exécution historiques).

Contributions clés

Protocole d'outils imposant des invariants : Étend les interfaces d'outils standards pour inclure des invariants d'état, permettant la vérification statique des séquences d'outils et réduisant les erreurs de génération.
Planification optimisant les coûts : Introduit un planificateur qui génère des candidats en parallèle, les valide par parcours de CFG et sélectionne le chemin d'exécution de coût le plus bas, éliminant efficacement les appels LLM redondants.
Ordonnancement conscient des coûts : Met en œuvre un ordonnanceur qui sélectionne dynamiquement entre les stratégies série, parallèle et de protection sur la base de simulations de Monte Carlo de distributions de latence apprises.
Système de bout en bout : Intègre ces composants dans un compilateur JIT qui traduit les tâches en langage naturel en code exécutable optimisé, dépassant la boucle d'agent standard.

Résultats

Le système a été évalué sur 37 tâches réparties sur cinq applications web (Dashdish, GitLab, Gomail, Omnizon, Reddit) en utilisant divers LLM de pointe.

Performance du JIT-Planner :
- A réalisé une accélération de 10,4× par rapport à la référence standard Browser-Use.
- A amélioré la précision de +28 % par rapport à Browser-Use.
- A démontré que l'estimation des coûts classe efficacement les plans : la différence entre les candidats de meilleur et de pire coût représentait une variance de latence de 5,3×.
- Le protocole d'invariants a réduit le taux d'échec de la génération de plans de 80 % à 43 % et a déplacé le mode d'échec dominant des violations d'ordre des outils vers d'autres types.
Performance du JIT-Scheduler :
- A réalisé une accélération de 2,4× et une amélioration de précision de +9 % par rapport au CUA d'OpenAI.
- A surpassé les stratégies d'ordonnancement fixes (Série, Parallèle, Protection) en sélectionnant de manière adaptative la stratégie optimale par tâche. Par exemple, il a correctement identifié que les tâches avec des éléments d'interface utilisateur à forte variance (par exemple, trouver un bouton spécifique) bénéficient de la protection, tandis que les recherches simples bénéficient d'une exécution sérielle.
Analyse de complexité :
- Les accélérations étaient cohérentes à travers la cardinalité des tâches (faible, moyenne, élevée) et la longueur, indiquant que les avantages proviennent principalement de l'élimination de l'inférence LLM par étape plutôt que d'heuristiques spécifiques à la tâche.
- Les applications avec des modèles de navigation complexes (par exemple, Reddit) ont connu les accélérations les plus élevées (jusqu'à 18,9×), tandis que celles avec des flux plus simples ont connu des gains plus faibles mais toujours significatifs.

Importance et revendications

L'article revendique que la Compilation JIT d'agents présente une direction prometteuse pour améliorer l'efficacité et la fiabilité des agents d'utilisation d'ordinateur. En traitant la planification d'agents comme un problème de compilation, le système :

Dissocie la planification de l'exécution : Il permet l'optimisation de l'ensemble du graphe d'exécution avant l'exécution, plutôt que de prendre des décisions séquentielles et gourmandes étape par étape.
Réduit le non-déterminisme : En imposant des invariants d'état et en compilant les tâches en code, il réduit la dépendance aux appels LLM non déterministes pendant l'exécution, conduisant à une précision plus élevée.
Optimise l'utilisation des ressources : Grâce à un ordonnancement conscient des coûts, il s'adapte aux caractéristiques de latence spécifiques des interactions web, équilibrant plus efficacement le compromis entre latence et précision que les stratégies statiques.

Les auteurs notent que cette approche convient mieux aux applications qu'un agent traitera de manière répétée, car elle nécessite un coût de configuration hors ligne (synthèse d'outils et collecte de traces) pour construire les caches nécessaires. Ils reconnaissent les limitations concernant les changements d'interface utilisateur (qui peuvent rompre les outils mis en cache) et les environnements hautement stochastiques (par exemple, les CAPTCHA), mais affirment que le protocole d'invariants fournit un mécanisme de détection et de repli au moment de l'exécution.