RecherchearXiv cs.RO 1 octobre 2026

Redonner vie au « Code as Policy » : des agents de pointe écrivent, appellent et font évoluer les outils robotiques

1 source couvre ce sujet·Source originale ↗·

Résumé IASource uniqueImpact UE

Des chercheurs publient URAI (Universal Robot-Agent Interface), un cadre qui sépare les rôles entre modèles de pointe et code exécutable pour la manipulation robotique. Un agent de programmation écrit des outils robotiques réutilisables ou spécifiques à une tâche à partir de l'intention de la tâche, puis les affine grâce au retour d'exécution et aux consignes humaines. Un agent d'exécution choisit et paramètre ces outils d'après les observations courantes. Chaque appel déroule localement un mouvement complet (approche, saisie, retrait) avant de rendre la main à l'agent. Les révisions validées persistent d'un épisode à l'autre sans toucher aux poids du modèle, et une interface graphique et une API communes donnent aux humains et aux agents accès aux mêmes outils. Sur cinq tâches du banc RoboDojo et quatre agents d'exécution figés, le taux de succès agrégé passe de 18,0 % à 53,0 % par rapport au contrôle direct des bouts de doigts, avec le gain le plus net sur Swap Blocks. Trois agents sur quatre terminent leurs épisodes 1,3 à 1,5 fois plus vite, avec 1,5 à 1,7 fois moins de tokens de sortie. Le coût de DeepSeek-V4-Flash, lui, varie à peine. Le cadre est aussi évalué sur sept tâches réelles avec un robot bimanuel AgileX : manipulation d'objets, pliage de textile et morpion en interaction avec un humain.

L'intérêt tient à l'arbitrage que ce travail rend mesurable. Faire raisonner un modèle de pointe à chaque mouvement élémentaire rend la manipulation lente et gourmande en tokens, ce qui pèse directement sur la latence et le coût d'exploitation d'un déploiement. Ici, le code absorbe les séquences de mouvement, et le modèle ne garde que la décision de haut niveau entre deux appels. Le résultat le plus instructif est la comparaison avec un programme écrit à l'avance : avec les mêmes outils, il n'atteint que 24 %, contre 56 % pour deux agents qui décident après chaque appel. Autrement dit, la boucle de rétroaction au niveau du modèle compte autant que la qualité des outils. À nuancer : les gains de vitesse ne sont pas uniformes, l'évaluation en simulation reste limitée à cinq tâches, et les résultats réels sur sept tâches AgileX sont décrits sans les chiffres détaillés dans le résumé. Pour un intégrateur, l'idée d'une bibliothèque d'outils améliorable sans réentraînement est séduisante, mais sa robustesse en production reste à démontrer.

Ce travail relance l'approche « code as policy », où un modèle de langage génère directement du code de contrôle. Cette approche avait montré ses limites lorsque le programme généré gérait seul toutes les décisions suivantes. URAI y répond en gardant le modèle dans la boucle. Il se place face aux politiques VLA (vision-langage-action) entraînées de bout en bout, comme Pi-0 ou GR00T, qui exigent des données de téléopération et des mises à jour de poids, alors qu'URAI s'appuie sur des modèles génériques figés et sur l'écriture d'outils. Les deux voies pourraient se combiner, des VLA fournissant des primitives que des agents orchestreraient. Il s'agit d'un preprint (arXiv, v1) : aucun produit, calendrier de déploiement ni partenaire industriel n'est annoncé. Les prochaines étapes à surveiller sont une validation sur davantage de tâches réelles, des comparaisons directes avec des VLA, et la reproductibilité sur d'autres matériels que l'AgileX.

Impact France/UE

Pas d\'impact direct sur la France/UE

Dans nos dossiers

IA physique & VLA NVIDIA GR00T Manipulation robotique arXiv cs.RO

À lire aussi

1arXiv cs.RO

Co-évolution d'orchestrateurs de robots et de politiques grâce au déploiement

Des chercheurs proposent Robo-COP, un cadre où un orchestrateur de robot (un modèle vision-langage, ou VLM, qui décide quand appeler la politique, comment la guider par instructions et quand lui préférer des compétences scriptées) et la politique VLA (vision-language-action) qu'il pilote évoluent ensemble pendant le déploiement. Le système extrait des démonstrations de compétences à partir de ses propres exécutions, affine la politique lorsque ces données répondent à des échecs récurrents, et n'adopte la nouvelle version qu'après avoir vérifié qu'elle améliore les compétences pour lesquelles elle a été entraînée. Sur dix tâches simulées RoboLab, le succès moyen sur tâches tenues à l'écart passe de 64,8 % à 73,8 % par rapport au même dispositif avec une politique figée. Un affinage à calendrier fixe, sans vérification, plafonne à 65,8 %. Sur trois tâches réelles, le succès grimpe de 38,3 % à 50,0 %. Les vidéos et le code sont publiés sur robo-cop.pages.dev (travail de recherche, arXiv 2610.09228). L'intérêt tient à un goulot d'étranglement connu des systèmes robotiques « agentiques ». Quand l'orchestrateur est bâti autour d'une politique figée, peu pilotable par le langage, il apprend à contourner ses échecs sans jamais les corriger : la politique plafonne les performances de l'ensemble. Affiner la politique seule ne règle rien, car elle se désaccorde alors d'un orchestrateur calibré sur son ancien comportement. Les résultats donnent un ordre de grandeur utile : la vérification avant adoption pèse autant que l'affinage lui-même, puisque l'affinage aveugle n'apporte qu'un point (65,8 % contre 64,8 %), alors que la version contrôlée en apporte neuf. Pour un intégrateur, cela plaide pour traiter les données de production comme un actif d'apprentissage, à condition de disposer d'un garde-fou de non-régression avant toute mise à jour sur le terrain. Il faut toutefois lire ces chiffres avec prudence. Le gain réel (+11,7 points) repose sur seulement trois tâches, et un taux de 50 % reste très éloigné d'un seuil industriel. Les auteurs ne précisent pas, dans le résumé, le nombre d'essais, la nature des robots ni le coût en données et en calcul. Ce travail s'inscrit dans la montée des architectures où un VLM supervise une politique VLA généraliste, après la vague de modèles comme Pi-0 ou GR00T, dont la généralisation hors domaine d'entraînement reste le point faible en déploiement. La suite logique serait un test sur des flottes réelles, sur la durée, et face à d'autres approches d'apprentissage continu. Aucun pilote commercial ni calendrier n'est annoncé : il s'agit à ce stade d'une démonstration académique.

RecherchePaper

1 source

2arXiv cs.RO

OpenRUA : les agents d'utilisation de robots sont des politiques visuomotrices zero-shot

OpenRUA, un framework publié sur arXiv (code disponible sur GitHub, dépôt terminalworld/OpenRUA), montre qu'un agent de code généraliste peut piloter un robot sans couche d'abstraction sur mesure. Le dispositif se limite à un accès terminal à ROS 2, l'interface logicielle native du robot. L'agent dispose d'un espace de travail minimal contenant la documentation ROS 2 et quelques outils de base, puis organise seul son travail, sans workflow imposé. La perception devient une affaire de lecture de fichiers, la manipulation un exercice de programmation. Avec Claude Code propulsé par Claude Opus 5, les auteurs rapportent 99,0 % de réussite sur CaP-Bench et 87,0 % sur LIBERO-PRO, sans primitives dédiées ni entraînement spécifique aux tâches. Dans 96,80 % des épisodes, l'agent écrit de lui-même des programmes qui traitent les données brutes des capteurs pour en tirer des mesures métriques. Il construit des clients de contrôle moteur, comme la commande de pince, dans 95,87 % des épisodes, et des boucles de contrôle fermées, qui ajustent le mouvement selon le retour capteur, dans 50,13 % des cas. L'intérêt tient à la remise en cause d'une pratique répandue : empiler des harnais complexes, avec workflows prescrits et interfaces maison, autour des modèles pour les faire agir sur du matériel. Si un agent de code du commerce atteint ces scores avec ROS 2 seul, une partie de cette ingénierie pourrait être superflue. Pour les intégrateurs, cela suggère que la valeur se déplace vers la qualité de la documentation, des interfaces standard et des garde-fous, plutôt que vers des SDK propriétaires. C'est aussi une alternative aux VLA (vision-language-action) entraînés de bout en bout, comme Pi-0 ou GR00T, puisqu'ici la politique visuomotrice est produite à la volée sous forme de code. Les réserves sont nombreuses. Les résultats portent sur des benchmarks, très probablement en simulation, et rien n'indique une validation sur robot réel. Le temps de cycle, la latence, le coût en tokens et la sécurité d'un code généré puis exécuté sur un bras ne sont pas détaillés dans le résumé. Le contrôle en boucle fermée n'apparaît que dans la moitié des épisodes, ce qui limite la portée pour les tâches dynamiques. Ces travaux prolongent la montée en puissance des agents de code, d'abord cantonnés au logiciel, puis étendus au monde physique via des approches de type « code as policies », où un modèle de langage écrit des programmes de contrôle. Les travaux antérieurs s'appuyaient sur des harnais spécialisés, que OpenRUA cherche à supprimer. Le concept concurrence les VLA entraînés sur de grandes bases de démonstrations, au prix d'une dépendance à un modèle propriétaire de pointe. Les prochaines étapes à surveiller sont la validation sur matériel réel, la mesure des coûts et de la latence, et la reproduction avec des modèles ouverts, que la publication du code rend désormais possible.

UEPas d\'impact direct sur la France/UE

RecherchePaper

1 source

3arXiv cs.RO

RACaP : raisonnement, action et codage à base d'agents pour un apprentissage robotique évolutif

Des chercheurs ont publié sur arXiv, le 25 septembre 2026 (référence 2609.29394), un article décrivant RACaP (Reasoning, Acting, and Coding as Policies), un framework agentique pour l'apprentissage robotique évolutif. Contrairement aux méthodes Code as Policies (CaP) classiques, qui génèrent et réparent du code au moment de l'exécution au prix d'une latence et d'un mélange entre mécanismes réutilisables et décisions spécifiques à la tâche, RACaP déplace la génération de code vers une phase d'évolution en amont et s'appuie, au déploiement, sur une boucle ReAct qui appelle des API de politiques figées et typées, combinant curriculum d'apprentissage et auto-évolution autonome. Sur les bancs d'essai en simulation LIBERO, RACaP atteint 54,4% de réussite sur LIBERO-90, 45,0% en zero-shot sur LIBERO-PRO et 46,0% sur LIBERO-Long, contre au maximum 4,0% pour les baselines CaP sur les tâches à long horizon, soit 2,5 fois leur taux de réussite sur LIBERO-PRO et un temps de décision médian 1,9 fois plus rapide. Un fine-tuning par échantillonnage par rejet distille ensuite les décisions ReAct de GPT-5.6 dans un modèle compact Qwen3-VL-8B-Instruct, accélérant l'inférence par décision d'un facteur 13,2 et réduisant les appels physiques répétés de 16 à 4. Ce travail cible un problème concret pour les intégrateurs: la latence et la fragilité des approches où un modèle de langage génère et corrige du code de contrôle en direct, ce qui complique la maintenance et le passage à l'échelle sur des tâches longues. En séparant le code réutilisable, figé après évolution, des décisions prises en temps réel via mémoire de travail, mémoire d'expérience et retour visuel, RACaP illustre une piste pour rendre les agents VLA (vision-language-action) plus robustes et plus rapides sans sacrifier l'adaptabilité. La distillation vers un modèle compact comme Qwen3-VL-8B-Instruct répond directement à une contrainte industrielle: les grands modèles comme GPT-5.6 restent trop lents et coûteux pour tourner en boucle fermée sur un robot physique. Ces résultats demeurent toutefois obtenus en simulation sur les bancs académiques LIBERO, et non lors d'un déploiement réel en usine ou en entrepôt, laissant ouvert l'écart classique entre performance simulée et performance en conditions réelles. RACaP s'inscrit dans la lignée des méthodes Code as Policies, qui font piloter des robots par des grands modèles de langage générant directement du code exécutable, une approche dont les limites sur les tâches longues et complexes sont confirmées ici par les scores plafonnés à 4,0% des baselines CaP citées dans l'article. En comparant son architecture à ces méthodes de référence sur les mêmes bancs LIBERO-90, LIBERO-PRO et LIBERO-Long, l'équipe cherche à démontrer qu'une architecture combinant code figé et raisonnement au moment de l'action offre une meilleure transférabilité zero-shot, un critère que surveillent les décideurs avant tout investissement en robotique VLA. L'article, disponible en prépublication sous la référence 2609.29394v1, ne mentionne ni calendrier de déploiement sur robot physique ni partenariat industriel; les prochaines étapes attendues pour ce type de travaux académiques restent une validation sur plateforme réelle et une revue par les pairs.

RechercheActu

1 source

4arXiv cs.RO

Les politiques robotiques compactes exigent des représentations visuelles fines

Des chercheurs proposent CoRP (Compressed Representation Policy), une politique de manipulation multi-tâches volontairement compacte: 48,9 millions de paramètres, sans modèle vision-langage ni prior génératif vidéo. Elle sépare un extracteur de représentation d'un générateur d'actions par flow matching. Elle atteint 97,0 % de réussite sur LIBERO et 75,78 % (Clean) et 73,36 % (Randomized) sur RoboTwin 2.0, soit des scores comparables à ceux de systèmes 40,9 à 163,6 fois plus gros. Il s'agit de résultats de benchmarks en simulation, publiés sous forme de préprint arXiv, sans déploiement réel annoncé. Les auteurs fixent ensuite le générateur d'actions et font varier une seule propriété de l'extracteur à la fois. Un ViT-S/14 initialisé aléatoirement tombe à 78,1 % sur LIBERO, un ResNet-34 pré-entraîné sur ImageNet à 74,5 %, et geler l'encodeur coûte 19,8 points. Rééchantillonner chaque vue à 48 tokens bat le passage de tous les tokens de patchs (97,0 % contre 83,2 %). Le résultat remet en cause une lecture courante du secteur: les gains des VLA (vision-language-action) viendraient surtout de l'échelle ou des priors génératifs. Faute de comparaisons contrôlées, les publications mélangent architecture, taille et pré-entraînement, et ne permettent pas d'isoler ce qui compte. Ici, la représentation visuelle serait le facteur dominant: pré-entraînée, adaptée à la tâche et compressée. Pour un intégrateur ou un décideur, la portée est pratique: une politique de moins de 50 M de paramètres peut tourner sur du matériel embarqué modeste, avec une latence et un coût d'inférence bien plus faibles que des modèles de plusieurs milliards de paramètres. Deux résultats nuancent toutefois cette idée. Un goulot d'information variationnel est pire qu'un budget dur de tokens: il fait chuter LIBERO-Goal de 95,8 % à 33,0 %, car il supprime la sélection de tokens dépendante de l'instruction. Le langage n'aide que si l'observation laisse le but ambigu (LIBERO-Goal passe de 9,2 % à 95,8 %), alors que sur RoboTwin 2.0 sa suppression améliore légèrement le succès. Ce travail s'inscrit dans la course aux grands VLA (Pi-0, GR00T, Helix, entre autres), qui misent sur des backbones vision-langage massifs ou des priors vidéo. CoRP défend la voie inverse, celle de la politique frugale, et ajoute un argument d'ablation à un débat encore ouvert. Les limites sont claires: LIBERO est déjà proche de la saturation, RoboTwin 2.0 reste simulé, et rien ne dit que ces conclusions tiennent sur des tâches longues, du matériel varié ou des environnements industriels non structurés. La suite logique est une validation sur robots réels et la comparaison avec des modèles de grande taille dans les mêmes conditions. Une page projet est disponible à l'adresse corp-policy.github.io.

UEUne politique de manipulation de moins de 50 M de paramètres, validée uniquement en simulation, pourrait à terme permettre aux intégrateurs européens de robots industriels (KUKA, ABB, Universal Robots, Festo) d'embarquer l'IA sur du matériel modeste avec un coût d'inférence réduit, mais sans déploiement réel annoncé l'impact reste prospectif.

RecherchePaper

1 source