Reinforced Agent : retour d'information à l'inférence pour les agents à appel d'outils

Capture des ID de tokens pendant les interactions à base d'agents pour améliorer l'apprentissage par renforcement

Anthropic a présenté Turnstile, un petit proxy écrit en langage Rust destiné à résoudre un problème technique précis dans l'entraînement des modèles de langage par apprentissage par renforcement (RL). Pour progresser sur des tâches complexes et prolongées, comme écrire du code, naviguer sur un site web ou mener une recherche en plusieurs étapes, un modèle est encadré par un harnais logiciel qui lui permet d'appeler des outils, d'observer les résultats et de décider de l'étape suivante. L'entraînement RL consiste à faire tenter de nombreuses tâches au modèle, à noter chaque tentative, puis à ajuster ses paramètres vers les choix qui ont fonctionné. Le problème vient du fait que les modèles ne traitent pas le texte tel quel, mais sous forme de tokens, des unités numérotées par un tokenizer propre à chaque modèle. Un simple changement de mise en forme, un espace en trop ou une manière différente d'écrire un appel d'outil en JSON peut modifier les identifiants de tokens sans changer le texte apparent, un phénomène qu'Anthropic appelle la dérive de retokenisation ou la dérive du template de conversation. Turnstile s'installe entre le harnais de l'agent et le système qui fait tourner le modèle, et enregistre l'historique exact, token par token, de chaque requête au moment précis de sa génération, le seul instant où cette information est garantie exacte. Cette précision compte parce que les mathématiques du RL par gradient de politique ne fonctionnent correctement que si l'entraînement optimise le comportement du modèle par rapport au contexte réellement vu par la version du modèle qui a produit la tentative, appelée la politique comportementale. Si le contexte est légèrement redessiné lors de la relecture, le modèle est entraîné sur un contexte qu'il n'a jamais réellement rencontré, ce qui dégrade le signal d'apprentissage de façon souvent invisible, le modèle semblant continuer à progresser normalement. Le problème s'aggrave avec des harnais complexes, qui peuvent compacter d'anciens messages pour économiser du contexte, relancer un appel d'outil mal formé, créer des sous-agents puis fusionner leurs résultats, ou résumer l'historique en cours de route, autant d'opérations qui peuvent introduire un décalage entre ce que le modèle a vu et ce que l'entraîneur croit qu'il a vu. Turnstile exporte ces trajectoires token par token dans un format générique, indépendant de tout framework, compatible avec n'importe quelle pile d'entraînement RL existante. Anthropic affirme avoir utilisé cet outil pour de véritables campagnes d'entraînement, avec deux agents différents, un agent de codage purement textuel et un agent multimodal capable d'utiliser un ordinateur, qui ont tous deux progressé de façon régulière au fil de leurs sessions de RL, sans qu'aucune modification du harnais d'origine ne soit nécessaire. Cette publication s'inscrit dans un effort plus large de l'industrie pour fiabiliser l'entraînement des agents IA, à mesure que les tâches confiées aux modèles deviennent plus longues et plus complexes, et que la moindre incohérence dans les données d'entraînement peut se traduire par des gains de performance illusoires ou instables.

💬 Turnstile, c'est le genre d'outil qui ne fera jamais la une, mais qui règle un vrai bug de fond : quand ton harnais d'agent reformate un appel d'outil ou compacte l'historique, le modèle s'entraîne sur un contexte qu'il n'a jamais vu, et ça pourrit le RL sans que personne s'en aperçoive. Le fait qu'Anthropic sorte un proxy Rust juste pour ça montre à quel point l'entraînement des agents devient une affaire de plomberie fine, pas de nouvelles architectures. Ce genre de correction invisible en dit plus sur la maturité d'un labo que ses derniers benchmarks.

Quantification de l'incertitude pour l'appel de fonctions dans les LLM

Les modèles de langage (LLM) sont de plus en plus déployés pour accomplir de manière autonome des tâches concrètes, notamment grâce au paradigme dit du "function calling", qui leur permet d'appeler des outils externes pour agir sur le monde réel. Ce mécanisme est aujourd'hui largement utilisé pour doter les LLM de capacités d'usage d'outils, que ce soit pour interroger une base de données, exécuter du code ou déclencher une action dans une application tierce. Le problème soulevé par des chercheurs est qu'un appel de fonction incorrect peut avoir des conséquences graves, en particulier lorsque l'action déclenchée est irréversible, comme un virement bancaire ou la suppression de données. Face à ce risque, les auteurs proposent d'évaluer la confiance du modèle dans la justesse d'un appel de fonction avant même de l'exécuter, via des méthodes de quantification de l'incertitude, ou "Uncertainty Quantification" (UQ). Cette approche change la donne pour les entreprises qui intègrent des agents IA autonomes dans leurs systèmes de production. Plutôt que de laisser un modèle exécuter aveuglément chaque action qu'il génère, la quantification de l'incertitude permettrait de détecter en amont les appels de fonction douteux et de les soumettre à une validation humaine ou de les bloquer purement et simplement. Pour les secteurs sensibles comme la finance, la santé ou la gestion de données critiques, ce type de garde-fou pourrait devenir un prérequis avant tout déploiement à grande échelle d'agents capables d'agir sans supervision constante. Cette recherche s'inscrit dans un mouvement plus large de la communauté IA visant à rendre les agents autonomes plus fiables et plus sûrs, alors que leur adoption s'accélère dans les entreprises. Les mécanismes de function calling, bien que puissants, restent une source de fragilité: un modèle peut mal interpréter une requête, halluciner des paramètres ou choisir le mauvais outil. En couplant ces systèmes à des méthodes de quantification de l'incertitude, les chercheurs espèrent ouvrir la voie à des agents capables d'évaluer eux-mêmes leur propre fiabilité, une étape jugée essentielle avant de leur confier des tâches à fort enjeu.

« IA sans environnement : génération de données synthétiques pour agents d'appel API »

L'entraînement d'agents basés sur des grands modèles de langage (LLM) capables d'appeler des API nécessite d'énormes volumes de trajectoires d'interaction de haute qualité. Jusqu'à présent, la collecte de ces données à grande échelle imposait de disposer d'environnements entièrement fonctionnels, avec des API exécutables et des bases de données backend réalistes et pré-remplies, un obstacle majeur qui limitait fortement la scalabilité du processus. Pour contourner cette contrainte, une équipe de recherche propose une nouvelle approche de génération de données synthétiques ne nécessitant aucun environnement réel, en exploitant les LLM eux-mêmes comme des modèles du monde numérique générés à la volée. En ne partant que des spécifications des API, sans backend ni base de données préexistante, la méthode produit des trajectoires simulant fidèlement les interactions entre un agent et un environnement à état, c'est-à-dire un système qui évolue et garde en mémoire les effets des actions précédentes. Cette avancée change potentiellement la donne pour le développement d'agents IA capables d'utiliser des outils et des API externes, une capacité de plus en plus centrale dans les architectures d'agents autonomes. En supprimant le besoin de construire et maintenir des environnements de test complexes et coûteux, cette méthode pourrait considérablement réduire le temps et les ressources nécessaires pour entraîner de tels agents, tout en permettant de générer des données d'entraînement plus diversifiées et à moindre coût. Pour les équipes de recherche et les entreprises qui développent des assistants IA orientés action, cela représente un gain potentiel important en termes de rapidité de développement et de couverture des cas d'usage. Le goulot d'étranglement identifié par les auteurs, la nécessité de bases de données backend réalistes pour chaque scénario testé, est un frein connu dans le domaine de l'entraînement d'agents IA, où la qualité des données d'apprentissage détermine directement la fiabilité des systèmes déployés en production. Cette approche s'inscrit dans une tendance plus large consistant à utiliser les LLM non seulement comme agents mais aussi comme simulateurs de leur propre environnement d'entraînement, une piste qui pourrait s'étendre à d'autres domaines nécessitant des données d'interaction complexes, comme la navigation web ou l'automatisation de tâches multi-étapes.

OSGym : une infrastructure open source pour agents informatiques, gérant plus de 1 000 répliques à 0,23 $/jour

Une équipe de chercheurs issue du MIT, de l'UIUC, de CMU, USC, UVA et UC Berkeley a publié OSGym, un nouveau framework d'infrastructure conçu pour entraîner des agents IA capables d'utiliser un ordinateur comme le ferait un humain. Ces agents, appelés "computer use agents", observent une capture d'écran du bureau, décident d'une action (cliquer, taper du texte, ouvrir un fichier) et l'exécutent via clavier et souris. OSGym permet de gérer plus de 1 000 répliques d'environnements OS simultanément, pour un coût d'environ 0,23 dollar par réplique et par jour, contre environ 300 dollars par jour pour 128 répliques avec une approche naïve, soit une réduction de coût d'un facteur proche de 100. L'enjeu est considérable pour la recherche académique, qui ne dispose pas des budgets des grands laboratoires commerciaux. Entraîner un agent à naviguer dans un vrai système d'exploitation nécessite des centaines, voire des milliers d'environnements virtuels tournant en parallèle, chacun avec son propre disque bootable (environ 24 Go), son allocation CPU et RAM, et sa pile graphique. OSGym résout deux problèmes majeurs : le coût prohibitif de ces environnements, et leur instabilité (crashs, sessions qui expirent, applications gelées). En utilisant des conteneurs Docker plutôt que des machines virtuelles complètes, et en optimisant la densité de répliques par serveur, le système exploite un insight clé : au-delà d'un certain seuil, le goulot d'étranglement passe du CPU à la RAM, qui coûte dix à vingt fois moins cher. Chaque réplique dispose par ailleurs de son propre gestionnaire d'état, exposant une API inspirée d'OpenAI Gym (reset, step, shutdown), ce qui évite qu'une panne en cascade paralyse l'ensemble du système. Les agents de type "computer use" constituent l'une des frontières les plus actives de la recherche en IA. Des modèles commerciaux comme Claude Computer Use d'Anthropic ou Operator d'OpenAI ont montré que la direction est prometteuse, tandis que des projets académiques comme UI-TARS, Agent-S2 ou CogAgent repoussent les limites techniques. Mais l'accélération de ces travaux bute depuis longtemps sur un mur infrastucturel : générer suffisamment de données d'interaction réelles dans des environnements OS complets est trop coûteux pour la plupart des équipes universitaires. OSGym s'attaque directement à ce verrou en proposant une infrastructure open source et économiquement viable. Si le framework tient ses promesses à grande échelle, il pourrait démocratiser significativement la recherche sur les agents autonomes et accélérer le développement de systèmes capables d'exécuter des tâches complexes sur ordinateur sans intervention humaine.