Nous entraînons Composer sur des tâches à long horizon à l’aide d’un processus d’apprentissage par renforcement appelé auto-synthèse. En faisant de l’auto-synthèse un élément de l’entraînement de Composer, nous pouvons obtenir un signal d’apprentissage à partir de trajectoires bien plus longues que la fenêtre de contexte maximale du modèle. Composer peut ainsi apprendre à s’attaquer à des tâches de codage difficiles nécessitant des centaines d’actions.

#Les limites des techniques de compactage

Dans CursorBench, notre suite de benchmarks interne, nous observons que de meilleures performances sur des tâches réelles complexes de codage sont directement corrélées à une réflexion plus poussée et à une exploration plus approfondie de la base de code. À mesure que les utilisateurs travaillent avec des agents sur des tâches plus difficiles et plus ambitieuses, nous nous attendons à ce que les bénéfices de la réflexion et de l’exploration augmentent davantage.

Un défi majeur, toutefois, est que les trajectoires des agents s’allongent plus vite que la longueur de contexte des modèles. De nombreux frameworks d’agents tentent de contourner ce problème en utilisant le compactage comme étape intermédiaire dans le workflow de l’agent. Lorsqu’un agent atteint sa limite de contexte, le framework réduit le contexte à une longueur plus courte, puis poursuit la génération de l’agent là où elle s’était arrêtée.

En pratique, le compactage est généralement géré par le framework de l’une des deux façons suivantes : soit dans l’espace textuel, via un modèle de synthèse guidé par prompt, soit au moyen d’une fenêtre de contexte glissante dans laquelle le modèle abandonne le contexte plus ancien. Les chercheurs ont également commencé à explorer des méthodes de compactage dans l’espace latent, où le modèle mémorise le contexte sous forme de vecteurs plutôt que de texte, bien qu’à l’heure actuelle ces approches soient beaucoup plus lentes que les méthodes fondées sur le texte.

Ces approches du compactage ont en commun un inconvénient : elles peuvent amener le modèle à oublier des informations critiques du contexte, ce qui réduit son efficacité à mesure qu’il progresse dans des tâches de longue haleine.

#L’auto-résumé comme comportement appris

Composer est un modèle spécialisé conçu pour le codage agentique et entraîné par apprentissage par renforcement dans l’infrastructure d’agent de Cursor. Cela lui permet d’être entraîné avec une compaction dans la boucle, améliorant sa capacité à déterminer quelles sont les informations les plus critiques à résumer et à préserver.

À mesure que Composer traite une tâche, il se rapproche d’un seuil fixe de longueur de contexte, auquel il s’interrompt pour résumer son propre contexte avant de poursuivre. Plus précisément, le processus d’auto-résumé fonctionne comme suit :

1. Composer génère à partir d’un prompt jusqu’à atteindre un seuil fixe de longueur en tokens.

2. Nous insérons une requête synthétique demandant au modèle de résumer le contexte actuel.

3. Le modèle dispose d’un espace de brouillon pour réfléchir au meilleur résumé, puis génère un contexte condensé.

4. Composer revient à l’étape 1 avec le contexte condensé, qui inclut le résumé ainsi que l’état de la conversation (état du plan, tâches restantes, nombre de résumés précédents, etc.).

Pour permettre à Composer de bien faire cela au moment de l’inférence, nous intégrons la même procédure de résumé à l’entraînement. Chaque rollout d’entraînement peut impliquer plusieurs générations chaînées par des résumés, plutôt qu’une seule paire prompt-réponse. Cela signifie que les auto-résumés eux-mêmes font partie des éléments récompensés.

D’un point de vue technique, cela ne nécessite pas de changements majeurs dans l’entraînement. Nous utilisons la récompense finale pour tous les tokens produits par le modèle dans la chaîne. Cela augmente le poids des réponses de l’agent dans les bonnes trajectoires, mais aussi des auto-résumés qui les ont rendues possibles. À l’inverse, les mauvais résumés qui ont fait perdre des informations critiques voient leur poids réduit. À mesure que Composer s’entraîne, il apprend à utiliser ce processus d’auto-résumé pour construire un contexte plus long. Pour les exemples difficiles, il s’auto-résume souvent plusieurs fois.

#Compactage économe en tokens

Pour tester l’auto-résumé, nous le comparons à une approche de référence de compactage par prompts, hautement optimisée. Nous étudions ce problème sur un ensemble de tâches difficiles d’ingénierie logicielle tout en faisant varier le seuil de déclenchement du compactage.

Dans l’approche de référence de compactage, le prompt de résumé compte des milliers de tokens et comprend près d’une douzaine de sections soigneusement formulées décrivant le contenu à préserver dans le résumé. Le contexte compacté produit en sortie dépasse lui aussi en moyenne 5 000 tokens et contient de nombreuses sections structurées décrivant des informations critiques issues du contexte.

À l’inverse, comme Composer est entraîné à s’auto-résumer, il n’a besoin que d’un prompt très court, qui ne contient guère plus que « Veuillez résumer la conversation ». Les résumés qu’il produit ne font en moyenne qu’environ 1 000 tokens, car il apprend, en fonction du contexte, à déterminer quelles informations à forte valeur il faut conserver.

Nous testons Composer dans deux environnements de test à contexte contraint afin de mesurer l’impact de l’auto-résumé, l’un avec un déclencheur à 80k tokens et l’autre avec un déclencheur à 40k (ce qui signifie des résumés plus fréquents). Dans les deux scénarios, l’auto-résumé produit des résultats nettement meilleurs sur CursorBench avec des compactages bien plus économes en tokens. Il réduit systématiquement de 50 % l’erreur liée au compactage, y compris par rapport à l’approche de référence ciblée, tout en utilisant un cinquième des tokens et en réutilisant le cache KV (les calculs intermédiaires stockés des tokens précédents).

#Résoudre des problèmes difficiles

La promesse plus large de la compaction est de permettre aux modèles de résoudre d’un seul coup des problèmes difficiles qui exigent de longues chaînes de raisonnement. Dans l’entraînement actuel de Composer 2, nous avons souvent vu cela se produire. Comme étude de cas, nous examinons un problème de Terminal-Bench 2.0 connu sous le nom de make-doom-for-mips. Le problème est aussi concis que difficile :

J’ai fourni /app/doomgeneric/, le code source de doom. J’ai aussi écrit un doomgeneric_img.c spécial que je veux que vous utilisiez, qui écrira chaque image générée dans /tmp/frame.bmp. J’ai enfin fourni vm.js, qui attendra un fichier appelé doomgeneric_mips et l’exécutera. À vous de trouver le reste…

Bien que facile à décrire, ce problème est suffisamment difficile pour que plusieurs modèles puissants ne parviennent pas à le résoudre correctement dans les résultats officiels publiés.

En testant un checkpoint de recherche précoce de Composer, nous avons constaté qu’il était capable de résoudre correctement ce problème. La solution a nécessité de concevoir et de tester une quantité importante de code, ainsi que d’explorer plusieurs implémentations alternatives. Voici une image générée au cours de la résolution du problème :

Au total, Composer a travaillé pendant 170 étapes pour trouver une solution exacte, en créant au passage des auto-synthèses sous une forme compacte, lisible par des humains et structurée. Il a synthétisé plus de 100 000 tokens pour les ramener aux 1 000 qui, selon lui, l’aideraient le plus à résoudre le problème :

#Vers un avenir à long horizon

En intégrant le compactage dans la boucle d’entraînement, Composer apprend un mécanisme explicite pour conserver et transmettre efficacement les informations critiques, et devient plus performant sur des tâches difficiles. Nos travaux sur l’auto-synthèse constituent une étape vers notre objectif plus large : entraîner Composer sur des processus encore plus longs et complexes, comme la coordination multi-agent. Nous continuons de constater qu’un meilleur entraînement des modèles améliore la portée et l’intelligence de ces systèmes agentiques.

Nous partagerons également bientôt plus d’informations sur la prochaine version de Composer.