🤖 AI

daVinci-Agency: Unlocking Long-Horizon Agency Data-Efficiently

Le document présente daVinci-Agency, un cadre efficace en termes de données qui exploite des séquences authentiques de Pull Requests pour synthétiser des données d'entraînement de haute qualité à long horizon pour les grands modèles de langage, permettant des gains de performance significatifs dans des flux de travail agentiques complexes sans coûts d'annotation prohibitifs.

Auteurs originaux : Mohan Jiang, Dayuan Fu, Junhao Shi, Ji Zeng, Weiye Si, Keyu Li, Xuefeng Li, Yang Xiao, Wenjie Li, Dequan Wang, Pengfei Liu

Publié 2026-02-05

📖 6 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Mohan Jiang, Dayuan Fu, Junhao Shi, Ji Zeng, Weiye Si, Keyu Li, Xuefeng Li, Yang Xiao, Wenjie Li, Dequan Wang, Pengfei Liu

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

Le gros problème : La « capacité d'attention limitée » de l'IA

Imaginez que vous avez un étudiant brillant qui est excellent pour répondre à des questions isolées, comme « Combien font 2+2 ? » ou « Écris un poème sur un chat ». Cet étudiant est un Grand Modèle de Langage (LLM).

Cependant, si vous demandez à cet étudiant de construire une maison, il est en difficulté. Il pourrait poser les fondations, puis oublier qu'il a besoin d'un toit, ou bien construire un mur au mauvais endroit sans s'en rendre compte avant la toute fin. Dans le monde de l'IA, c'est ce qu'on appelle une tâche à long horizon. C'est un travail qui nécessite de nombreuses étapes, où des erreurs commises tôt dans le processus peuvent ruiner tout le projet plus tard.

L'article soutient que les modèles d'IA actuels échouent dans ces tâches de longue haleine parce qu'ils n'ont pas été entraînés sur des données qui leur montrent comment planifier à l'avance, rester cohérents et corriger leurs propres erreurs sur une longue période.

La solution : Apprendre de « l'évolution logicielle »

Les auteurs (venant de l'SII, de la SJTU et de la GAIR) ont réalisé que la meilleure façon d'apprendre à une IA à gérer des projets longs et complexes est de regarder comment les humains construisent réellement des logiciels.

L'analogie : La chaîne de « Pull Requests »
Dans le développement de logiciels, lorsqu'un programmeur souhaite ajouter une fonctionnalité ou corriger un bug, il ne se contente pas de livrer le code fini. Il soumet une « Pull Request » (PR).

Étape 1 : Il soumet un petit changement (PR #15).
Étape 2 : Les réviseurs disent : « Cela semble bon, mais vous avez oublié un filet de sécurité. »
Étape 3 : Le programmeur corrige cela et soumet un nouveau changement (PR #21) qui s'appuie sur le premier.
Étape 4 : Cela se poursuit pendant plusieurs cycles jusqu'à ce que la fonctionnalité soit parfaite.

Les auteurs appellent cela une « Chaîne de Pull Requests ». C'est comme une histoire où chaque chapitre dépend du précédent, et où les personnages (le code) évoluent et s'améliorent avec le temps.

L'innovation : daVinci-Agency

L'équipe a créé un nouveau système appelé daVinci-Agency. Au lieu d'inventer des scénarios fictifs ou de payer des humains pour écrire de longues histoires pour l'apprentissage de l'IA (ce qui est coûteux et lent), ils sont allés sur GitHub (une immense bibliothèque de projets logiciels réels) et ont récolté ces « Chaînes de Pull Requests » naturelles.

Ils ont transformé ces histoires de développement réelles en données d'entraînement.

L'entraînement : Ils ont pris un modèle (GLM-4.6) et lui ont présenté ces chaînes.
La leçon : L'IA a appris que pour réussir, elle doit :
- Décomposer : Diviser un objectif immense en petites étapes gérables.
- Rester cohérente : Se souvenir de l'objectif initial même après 50 étapes.
- Affiner : Observer ses propres erreurs (bugs) et les corriger sans repartir de zéro.

Le résultat « magique » : Moins de données, plus de gains

Habituellement, pour rendre une IA plus intelligente, il faut la nourrir avec des millions d'exemples.

L'ancienne méthode : S'entraîner sur 66 000 exemples (comme les autres jeux de données mentionnés dans l'article).
La méthode daVinci : S'entraîner sur seulement 239 exemples.

Le résultat :
Malgré l'utilisation de 200 fois moins de données, le modèle entraîné par daVinci-Agency a obtenu des performances significativement meilleures que les modèles entraînés sur des ensembles de données massifs.

Sur un test appelé Toolathlon (où l'IA doit utiliser des outils pour résoudre des problèmes), le modèle s'est amélioré de 47 %.
Sur SWE-bench (un test pour corriger de vrais bugs logiciels), il a également obtenu un score bien plus élevé.

Pourquoi ? Parce que les 239 exemples étaient de haute qualité. Ils n'étaient pas aléatoires ; ils étaient les récits réels de la résolution de problèmes complexes au fil du temps. L'IA n'a pas seulement mémorisé des faits ; elle a appris l'habitude de la persévérance et de la correction.

Ce que l'IA a réellement appris (les « méta-compétences »)

L'article montre que l'IA n'est pas seulement devenue meilleure en codage ; elle est devenue meilleure pour réfléchir.

Avant : Si l'IA faisait une erreur, elle devenait confuse, s'égarait dans des sujets non pertinents ou abandonnait (ce qu'on appelle l'« escapisme » ou l'évasion).
Après : Lorsqu'elle faisait une erreur, l'IA marquait une pause, réalisait : « Attendez, je fais fausse route », et se corrigeait. Elle a appris à planifier et à rester sur la bonne voie.

Efficacité : Faire plus avec moins

L'article révèle également que la nouvelle IA est plus efficace.

Analogie : Imaginez deux personnes essayant de résoudre un labyrinthe.
- Personne A (Vieille IA) : Se cogne dans chaque impasse, crie et essaie 100 mauvais chemins différents.
- Personne B (IA daVinci) : Regarde la carte, identifie les impasses et prend le chemin direct.
L'IA entraînée par daVinci a utilisé moins de mots (tokens) et moins de clics d'outils pour résoudre les mêmes problèmes. Elle n'a pas gaspillé d'énergie dans la confusion.

La découverte du « passage à l'échelle » (Scaling)

Enfin, les auteurs ont testé ce qui se passe si l'on rend les histoires d'entraînement encore plus longues.

Ils ont découvert que si l'on entraînait l'IA sur des chaînes comportant plus d'étapes (des chaînes de Pull Requests plus longues), l'IA devenait encore meilleure.
Cela suggère que plus l'IA pratique la pensée de « longue distance », plus elle devient performante pour résoudre des problèmes très longs et complexes.

Résumé

daVinci-Agency est une nouvelle façon d'entraîner des agents d'IA. Au lieu de les forcer à mémoriser des millions de tâches courtes et fictives, on leur enseigne en leur montrant de vraies histoires longues de la manière dont les humains construisent des logiciels. En apprenant de ces « chaînes d'événements » naturelles, l'IA apprend à planifier, à rester cohérente et à corriger ses propres erreurs, devenant ainsi beaucoup plus intelligente et efficace avec bien moins de données qu'auparavant.

Résumé Technique : daVinci-Agency – Débloquer l'Agentivité à Longue Horizon de Manière Efficace en Données

1. Énoncé du Problème

Bien que les modèles de langage de grande taille (LLM) aient démontré une certaine compétence dans les tâches à court terme, le passage à l'échelle vers des flux de travail agentiques à longue horizon reste un défi majeur. Le principal goulot d'étranglement est la rareté des données d'entraînement de haute qualité qui capturent des structures de dépendance à long terme authentiques et des dynamiques évolutives inter-étapes.

Les méthodes actuelles de synthèse de données font face à deux limitations critiques :

Trajectoires Synthétiques : Les méthodes reposant sur des scénarios à caractéristique unique ou sur la distillation limitée par un enseignant échouent souvent à capturer les modes de défaillance réalistes, l'accumulation d'erreurs et les modèles de raffinement itératif. Elles traitent les étapes de manière indépendante, manquant les dépendances causales essentielles à un comportement persistant orienté vers un but.
Annotation Manuelle : La supervision de haute fidélité par annotation humaine est excessivement coûteuse et difficile à mettre à l'échelle.

Par conséquent, les modèles actuels peinent à maintenir une direction, à atténuer les erreurs cumulatives et à effectuer un raffinement itératif sur des intervalles d'interaction étendus.

2. Méthodologie : daVinci-Agency

Les auteurs proposent daVinci-Agency, un nouveau paradigme de synthèse de données qui reconceptualise la construction de données d'entraînement à travers le prisme de l'évolution logicielle réelle. L'idée centrale est que les séquences de Pull Requests (PR) sur GitHub incarnent naturellement les signaux de supervision requis pour l'apprentissage à longue horizon.

2.1 Mécanisme Central : Chaîne de PR (Chain-of-PRs)

Contra contrairement aux corrections de problèmes isolés, le développement de logiciels implique une itération continue où de multiples PR s'alignent sur un objectif fonctionnel unique. daVinci-Agency exploite systématiquement la supervision structurée issue de chaînes de PR (des séquences de PR liées sémantiquement où $PR_i$ itère sur, corrige ou étend $PR_{i-1}$ ). Cette structure impose trois mécanismes critiques :

Décomposition Progressive des Tâches : Réalisée via des commits continus et des sous-requêtes qui décomposent des objectifs complexes en unités de soumission vérifiables.
Cohérence à Long Terme : Renforcée par des objectifs fonctionnels unifiés à travers la chaîne, exigeant que l'agent maintienne la cohérence de l'état à mesure que la base de code évolue.
Raffinement Vérifiable : Dérivé d'histoires authentiques de correction de bugs et de boucles de rétroaction, apprenant à l'agent à corriger les erreurs basées sur les états précédents.

2.2 Pipeline de Curage de Données

Le cadre opère via un pipeline rigoureux :

Sourcing de Données : Neuf dépôts GitHub représentatifs et matures (ex: Scipy, Django) ont été sélectionnés sur la base de leur échelle (>7 000 PR), de leur interactivité communautaire et de leur diversité linguistique.
Construction de la Chaîne de PR : En utilisant les métadonnées de l'API GitHub, le système construit des topologies de dépendance où les PR sont liées par des références sémantiques (ex: "fixes #15").
Formulation de Requêtes : Pour chaque PR d'une chaîne, une sous-requête est synthétisée. Crucialement, les détails d'implémentation sont dissimulés pour forcer l'agent à naviguer et localiser le code, tandis qu'un aperçu global de l'ensemble de la chaîne est fourni pour assurer une compréhension macroscopique.
Rollout & Échantillonnage de Rejet : Les agents (utilisant GLM-4.6 comme modèle de rollout) exécutent les tâches séquentiellement à travers la chaîne de PR. Un mécanisme de transition d'état garantit que les changements de code des étapes précédentes se propagent à l'étape suivante. Un processus strict d'échantillonnage de rejet (utilisant un évaluateur avec un seuil $s \ge 0.8$ ) filtre les trajectoires, ne conservant que celles ayant une haute fidélité sémantique par rapport aux patchs de vérité terrain.

3. Contributions Clés

Un Paradigme de Données Évolutif : L'introduction de daVinci-Agency, qui utilise l'évolution réelle des PR pour construire des données d'entraînement à longue horizon vérifiables sans dépendre d'une annotation humaine coûteuse ou d'une synthèse à caractéristique unique.
Efficacité des Données : Démontrer que l'ajustement fin (fine-tuning) sur un ensemble de données remarquablement petit (239 échantillons) produit des améliorations généralisées, surpassant les modèles entraînés sur des ensembles de données ordres de grandeur plus grands (ex: 66k échantillons).
Acquisition de Méta-Compétences : Fournir la preuve que le paradigme enseigne efficacement trois méta-compétences critiques : la décomposition de tâches, la cohérence à long terme et le raffinement itératif.
Lois d'Échelle (Scaling Laws) : Révéler des lois d'échelle de données spécifiques pour les tâches à longue horizon, montrant que l'extension de l'horizon d'entraînement (longueur de la chaîne) et du budget d'interaction au moment de l'inférence améliore significativement la performance de l'agent.

4. Résultats Expérimentaux

Les auteurs ont évalué les modèles affinés (spécifiquement GLM-4.6, série Qwen3) à travers divers benchmarks incluant SWE-bench, Toolathlon, DS-1000, et $\tau^2$ -Bench.

Gains de Performance : L'ajustement fin de GLM-4.6 sur seulement 239 échantillons de daVinci-Agency a entraîné un gain relatif de 47 % sur Toolathlon et une amélioration de 148 % de la performance à long horizon par rapport aux modèles entraînés sur des jeux de données plus larges mais moins structurés.
Comparaison avec les Baselines : Le modèle a surpassé les baselines entraînées sur SWE-Smith (66k échantillons) et CC-Bench (260 échantillons), particulièrement dans les tâches nécessitant une évolution inter-étapes.
Études d'Ablation :
- La suppression de l'évolution inter-étapes (variante SinglePR) a entraîné une baisse de performance, confirmant la nécessité des chaînes multi-PR.
- Les chaînes ordonnées chronologiquement sans liens sémantiques (TemporalChain) ont montré des bénéfices limités, soulignant que la logique évolutive intrinsèque est plus critique que la simple longueur de séquence.
Efficacité : Les modèles entraînés sur daVinci-Agency ont démontré une réduction significative de la consommation de tokens (ex: 113,6K tokens de moins sur SWE-bench pour GLM-4.6) et de l'usage d'outils, indiquant une densité d'information par token plus élevée et une meilleure gestion du contexte.
Analyse de Mise à l'Échelle : L'extension des trajectoires d'entraînement de ~59k à ~85k tokens (en complétant des chaînes de PR plus longues) a généré des gains de performance supplémentaires, validant le potentiel de mise à l'échelle des structures séquentielles à longue horizon.

5. Signification et Revendications

Le papier affirme que daVinci-Agency établit une voie fondée sur des principes pour débloquer le potentiel intrinsèque à long horizon des agents. Sa signification réside dans :

Surmonter la Rareté des Données : Il démontre que la modélisation des trajectoires évolutives du monde réel offre une alternative scalable aux données synthétiques ou annotées manuellement.
Internalisation du Comportement : Les résultats suggèrent que les agents peuvent internaliser des comportements complexes et persistants orientés vers un but (planification, cohérence, correction d'erreurs) lorsqu'ils sont exposés à des données structurelles de haute qualité, plutôt qu'à de simples motifs de surface.
Potentiel de l'Auto-Distillation : Étant donné que les trajectoires d'entraînement ont été générées par le modèle lui-même (GLM-4.6), les gains de performance sont attribués à l'auto-exploration et à l'optimisation du modèle au sein d'un environnement curaté, plutôt qu'à la distillation de connaissances provenant d'un "enseignant" supérieur.

Les auteurs concluent que bien que les implémentations actuelles soient limitées à des chaînes allant jusqu'à 5 PR en raison des contraintes de taux de succès, les lois d'échelle observées suggèrent que l'extension de ces chaînes est une direction viable et prometteuse pour la recherche future dans les systèmes agentiques à longue horizon.