Composer 2 : performances, tarifs et comparatif

Cursor a lancé Composer 2 le 19 mars 2026, troisième génération de son modèle de programmation propriétaire. Cette sortie intervient six semaines seulement après Composer 1.5, qui avait multiplié par 20 l’apprentissage par renforcement (RL) sur le même modèle de base, sans changer l’architecture sous-jacente. Cette montée en charge RL a même dépassé le budget de calcul du pré-entraînement initial, signe que l’équipe avait poussé l’existant à sa limite. Composer 2 change d’approche : d’abord un pré-entraînement continu pour renforcer la base, puis du RL par-dessus. C’est ce qui explique l’ampleur du saut sur les benchmarks malgré l’écart de temps réduit.

Il arrive également avec une fenêtre de contexte de 200 000 tokens et deux variantes tarifaires : Standard à 0,50 $ par million de tokens en entrée (environ 86 % moins cher que Composer 1.5) et Fast pour les sessions interactives en temps réel.

Dans cet article, nous expliquons ce qu’est Composer 2, comment il se compare à Composer 1.5 en termes de benchmarks et de coût, et comment il se positionne face à Claude Opus 4.6 et GPT-5.4. Nous verrons aussi comment l’utiliser dans Cursor et quelles sont ses limites connues.

Si vous vous intéressez aux modèles de pointe face auxquels Composer 2 se mesure, consultez nos guides :

• Gemini 3.1
• Claude Code

Qu’est-ce que Composer ?

Composer est la famille de modèles d’IA propriétaires de Cursor dédiée au codage agentique dans l’IDE Cursor. À la différence de modèles généralistes comme Claude Opus 4.6 ou GPT-5.4, les modèles Composer sont conçus spécifiquement pour l’édition multi-fichiers, l’exécution de commandes terminal et le refactoring à l’échelle d’un codebase. Ils ne sont pas faits pour rédiger des emails, répondre à des quiz, ou accomplir des tâches non liées au code.

La lignée a commencé avec un prototype interne baptisé Cheetah, puis a évolué via trois sorties publiques :

Chaque génération s’est appuyée sur la précédente, mais Composer 2 marque le plus grand virage architectural à ce jour.

Visualisation de la chronologie d’évolution des modèles Composer. Image de l’auteur.

Qu’est-ce que Composer 2 ?

Composer 2 est la troisième génération du modèle de codage agentique propriétaire de Cursor, et le premier de la famille à bénéficier d’un pré‑entraînement continu.

Architecture et approche d’entraînement

Les versions précédentes de Composer étaient obtenues en superposant de l’apprentissage par renforcement à un modèle de base gelé. En d’autres termes, on enseigne de nouvelles compétences sans améliorer la compréhension fondamentale. Composer 2 change la donne : il met d’abord à jour les poids fondamentaux du modèle de base avec des données orientées code, puis applique le RL par-dessus.

Le modèle utilise une architecture Mixture‑of‑Experts (MoE), ce qui signifie qu’un sous‑ensemble seulement des paramètres s’active pour une entrée donnée. On conserve ainsi une inférence rapide tout en gardant un nombre total de paramètres élevé. Cursor n’a pas publié le compte exact de paramètres.

L’identité du modèle de base n’a pas été dévoilée au lancement, mais est devenue publique le 20 mars 2026 après qu’un utilisateur l’a repérée dans les en‑têtes d’appels API. Lee Robinson, VP Developer Education chez Cursor, a confirmé que Composer 2 s’appuie sur Kimi K2.5, un modèle open‑source de Moonshot AI. Il a précisé qu’environ trois quarts du calcul total provenaient de l’entraînement réalisé par Cursor (pré‑entraînement continu et RL), pas du modèle de base, ce qui explique selon lui pourquoi les évaluations diffèrent d’un run Kimi K2.5 brut.

Moonshot AI a ensuite confirmé un partenariat commercial autorisé via Fireworks AI, qui a assuré l’infrastructure RL et l’inférence. Le co‑fondateur Aman Sanger a indiqué que l’équipe avait évalué plusieurs bases avec des benchmarks de perplexité avant de retenir Kimi K2.5, et a décrit la phase post‑base comme un pré‑entraînement continu suivi d’un RL 4× plus intensif.

L’infrastructure d’entraînement repose sur PyTorch et Ray, avec des noyaux de quantification MXFP8 personnalisés optimisés pour les GPU NVIDIA Blackwell.

Auto‑résumé

L’auto‑résumé, que Cursor appelle « RL avec compaction en boucle », fonctionne ainsi : lorsque la fenêtre de contexte de 200 000 tokens approche de la saturation, le modèle fait une pause, compresse son propre contexte à environ 1 000 tokens, puis reprend. Comme ce comportement de compression fait partie de la fonction de récompense RL, le modèle apprend quelles variables, décisions d’architecture et logs d’erreurs conserver ou écarter.

Le blog recherche de Cursor rapporte que cette approche réduit de 50 % les erreurs de compaction par rapport aux résumés guidés par prompt, tout en utilisant environ un cinquième des tokens. En démonstration, Composer 2 a résolu le problème « make‑doom‑for‑mips » de Terminal‑Bench 2.0 en 170 itérations, en compressant plus de 100 000 tokens de contexte au passage.

Capacités clés

Pendant une session, Composer 2 a accès à :

• Recherche sémantique à l’échelle du codebase pour retrouver du code pertinent dans un projet
• Lecture, édition et création multi‑fichiers avec précision au niveau de la ligne
• Exécution de commandes terminal et interprétation des sorties
• MCP (Model Context Protocol) pour intégrer des services externes
• Un outil navigateur natif pour tester les changements d’UI directement dans l’éditeur

Ensemble, ces briques permettent à l’agent de travailler sur de nombreux fichiers et étapes au cours d’une seule session.

Variantes de Composer 2

Cursor propose Composer 2 en deux variantes, qui partagent la même intelligence sous‑jacente.

Composer 2 Fast

La variante Fast est sélectionnée par défaut quand vous choisissez Composer 2 dans la liste des modèles. Elle est optimisée pour des sessions interactives à faible latence, lorsque vous codez en temps réel et attendez des réponses quasi instantanées.

Composer 2 Standard

La variante Standard fonctionne à une vitesse inférieure mais coûte nettement moins cher par token, ce qui la rend plus adaptée aux tâches en arrière‑plan, aux refactorings en lot ou aux boucles agentiques longues où l’immédiateté n’est pas critique.

Voici la décomposition des tarifs :

Vous pouvez utiliser la variante Fast lorsque vous codez activement, puis basculer sur Standard la nuit ou pour les opérations massives afin de maîtriser la consommation de crédits. Nous reviendrons plus loin sur les différences de prix.

Benchmarks de Composer 2

Cursor évalue Composer 2 sur trois benchmarks, chacun couvrant un aspect différent de la performance en codage.

Comprendre les benchmarks

CursorBench est le benchmark interne propriétaire de Cursor, actuellement en version CursorBench‑3. Les tâches proviennent de vraies sessions Cursor et sont sourcées via un outil appelé Cursor Blame, qui relie le code committé à la requête agent qui l’a généré. Le benchmark mesure la justesse des solutions, la qualité du code, l’efficacité et le comportement d’interaction. L’ampleur des problèmes a à peu près doublé entre la version initiale et CursorBench‑3, tant en lignes de code qu’en nombre de fichiers. Cursor complète CursorBench par des expérimentations en trafic réel contrôlé pour détecter des régressions qu’une notation hors‑ligne pourrait manquer. Évidemment, CursorBench n’est pas publiquement reproductible : ces scores ne peuvent pas être vérifiés indépendamment.

Terminal‑Bench 2.0 est maintenu par le Laude Institute et teste la capacité d’un agent IA à accomplir des tâches réelles dans un terminal : navigation, exécution de scripts, interprétation d’erreurs, itération vers la solution. Cursor a utilisé le framework d’évaluation officiel Harbor avec les réglages par défaut et a exécuté cinq itérations par modèle, en reportant la moyenne.

SWE‑bench Multilingual est un sous‑ensemble de SWE‑bench avec 300 tâches couvrant 9 langages. Il évalue la capacité à résoudre de vrais tickets GitHub, ce qui en fait un test pertinent de programmation multi‑langages.

Résultats à travers les générations de Composer

Les scores se sont améliorés à chaque génération :

Scores sur trois générations de Composer. Image de l’auteur.

À propos des limites des benchmarks

• CursorBench est fermé et non reproductible indépendamment. Cursor ne publie pas de scores sur des benchmarks établis comme SWE‑bench Verified, ce que certains dans la communauté jugent incohérent.
• SWE‑bench Verified n’est plus reporté par OpenAI après avoir constaté que des modèles de pointe pouvaient reproduire des patchs de tests de mémoire et qu’environ 60 % des problèmes non résolus comportaient des tests défectueux.
• Terminal‑Bench inclut des tâches de type puzzle (comme trouver le meilleur coup d’échecs à partir d’une position) qui ne reflètent pas le travail réel d’un développeur. Cela reste néanmoins le plus transparent des trois, avec un cadre public et des méthodes d’évaluation documentées.

Dans quelle mesure Composer 2 est-il meilleur que Composer 1.5 ?

L’amélioration de Composer 1.5 à Composer 2 est la plus marquante à ce jour, tant sur la performance que sur le coût.

Comme montré dans le tableau ci‑dessus, Composer 2 obtient 61,3 sur CursorBench contre 44,2 pour Composer 1.5, soit environ +39 %. L’écart sur Terminal‑Bench 2.0 est d’environ +29 % (61,7 vs 47,9), et SWE‑bench Multilingual progresse d’environ +12 % (73,7 vs 65,9).

La baisse de coût dépasse encore les gains de benchmarks. Selon le billet de lancement de Cursor, Composer 2 Standard est environ 86 % moins cher que Composer 1.5 sur les tokens d’entrée et la variante Fast reste environ 57 % moins chère. Cursor n’a pas publié de page tarifaire dédiée à Composer 1.5 ; ces pourcentages proviennent de la comparaison faite au lancement.

Les différences techniques clés :

• Approche d’entraînement : Composer 1.5 a poussé le RL 20× plus loin sur la même base gelée, et le calcul RL post‑entraînement a dépassé celui du pré‑entraînement du modèle de base. Composer 2 a pris une autre voie : d’abord créer une nouvelle base plus solide via pré‑entraînement continu, puis appliquer un RL 4× plus intensif.
• Qualité de l’auto‑résumé : Composer 1.5 a introduit l’auto‑résumé mais via une compression guidée par prompt avec des milliers de tokens d’instructions, générant des résumés d’environ 5 000 tokens. La compaction entraînée au RL de Composer 2 produit environ 1 000 tokens avec 50 % d’erreurs en moins et réutilise aussi le cache KV des tokens précédents, réduisant davantage le coût d’inférence.
• Capacité long‑terme : Composer 2 gère des tâches nécessitant des centaines d’actions séquentielles. Comme mentionné plus haut, c’est un cran au‑dessus de ce que 1.5 traitait de manière fiable.

L’accueil de Composer 1.5 par la communauté a été mitigé. Certains développeurs l’ont jugé utile surtout pour de petites tâches (commits, éditions simples). Les chiffres de benchmark montrent des progrès sur les points les plus critiqués.

Composer 2 vs Claude Opus 4.6 vs GPT‑5.4

C’est la comparaison que beaucoup attendent. Composer 2 dépasse Claude Opus 4.6 sur certains benchmarks de code, est derrière GPT‑5.4 sur la plupart, et coûte beaucoup moins cher que les deux.

Comparaison des benchmarks

Les chiffres parlent d’eux‑mêmes :

Composer 2 vs Claude Opus 4.6 vs GPT‑5.4

Composer 2 devance légèrement Opus 4.6 sur CursorBench et Terminal‑Bench 2.0, mais GPT‑5.4 reste en tête avec une marge nette. L’écart sur Terminal‑Bench 2.0 entre Composer 2 (61,7) et GPT‑5.4 (75,1) est de 13 points.

À noter : les scores Terminal‑Bench 2.0 mesurent des paires agent+modèle, pas des modèles nus. Cursor a utilisé le framework Harbor pour son score, tandis que le 75,1 de GPT‑5.4 correspond au harness Simple Codex sur le leaderboard officiel. Des harness différents peuvent produire des résultats différents pour un même modèle.

Comparaison des tarifs

Voici comment les prix se comparent :

Comparaison des scores de benchmark et des tarifs par token. Image de l’auteur.

Composer 2 Standard est environ 90 % moins cher que Opus 4.6 et près de 80 % moins cher que GPT‑5.4 par token. Pour des équipes exécutant des milliers de requêtes agentiques par jour, l’écart compte vite.

Ce que chaque modèle fait de mieux

Composer 2 est un modèle dédié au code, verrouillé sur l’IDE Cursor. Il traite rapidement les tâches courantes à faible coût, mais ne fait rien en dehors du code.

Claude Opus 4.6 offre une fenêtre de contexte de 200 000 tokens (avec une bêta à 1 M de tokens, plus onéreuse), excelle en planification architecturale multi‑fichiers et prend en charge l’orchestration multi‑agents via Agent Teams. C’est un modèle généraliste particulièrement performant en code.

GPT‑5.4 mène sur les benchmarks de codage les plus difficiles, dispose d’une capacité native d’utilisation d’ordinateur et prend en charge une fenêtre de contexte expérimentale de 1,05 million de tokens. C’est le modèle le plus capable seul, mais aussi le plus coûteux à l’échelle.

Le positionnement de Cursor : la valeur par tâche dans l’IDE, pas la chasse au record de benchmark.

Composer 2 vs Claude Code vs GitHub Copilot

La section précédente compare Composer 2 en tant que modèle. Voici la comparaison au niveau produit.

Claude Code est l’agent de codage en terminal d’Anthropic. D’après une enquête développeurs 2026, il est désormais l’outil d’IA de programmation le plus utilisé chez les pros, 46 % le citant comme outil préféré contre 19 % pour Cursor. Beaucoup utilisent Cursor pour l’édition quotidienne dans l’IDE et basculent sur Claude Code pour des tâches autonomes complexes. Les deux outils se complètent plus qu’ils ne s’opposent.

GitHub Copilot reste l’outil le plus diffusé, avec plus de 20 millions d’utilisateurs au total et un ticket d’entrée à 10 $/mois. Il a récemment ajouté un mode Agent pour des actions multi‑étapes, mais beaucoup de développeurs estiment que l’édition multi‑fichiers de Cursor va plus loin.

Environ 70 % des développeurs utilisent désormais deux à quatre outils d’IA en parallèle. La question est moins « quel outil ? » que « quelle combinaison ? »

Comment utiliser Composer 2

Composer 2 vit entièrement dans l’IDE Cursor ; rien à installer séparément.

Configuration pas à pas

Pour démarrer, téléchargez ou mettez à jour Cursor depuis cursor.com. Composer 2 est disponible sur tous les forfaits payants (Pro, Pro+, Ultra, Teams, Enterprise). Ouvrez le panneau Agent avec Cmd+I sur Mac ou Ctrl+I sur Windows et Linux, puis sélectionnez « Composer 2 » ou « Composer 2 Fast » dans la liste des modèles. La variante Fast est activée par défaut.

Où trouver le menu de sélection des modèles Cursor. Image de l’auteur.

À partir de là, décrivez en langage naturel la tâche à réaliser. Composer 2 opère par défaut en mode Agent : il peut explorer votre codebase, apporter des modifications, exécuter des commandes terminal et utiliser tous les outils disponibles de manière autonome. Vous validez ou refusez les changements au fil de l’eau.

Raccourcis essentiels

Voici les raccourcis que vous utiliserez le plus souvent avec Composer 2 :

Gérer le contexte

Composer 2 propose plusieurs moyens de contrôler le contexte. Tapez @ suivi d’un nom de fichier, d’un dossier ou d’une URL pour injecter un contexte précis dans le prompt. Le symbole # cible un fichier particulier. Des « pills » de contexte en haut du chat affichent ce que l’agent référence actuellement.

Pour les grands projets, activer Autocontext dans Settings permet à Cursor de récupérer automatiquement le code pertinent via des embeddings. Vous pouvez aussi ajouter de la documentation personnalisée dans Settings pour un contexte spécifique à vos frameworks.

Auto‑résumé en pratique

Pour les tâches longues, l’auto‑résumé s’active automatiquement quand la fenêtre de contexte est pleine. Vous pouvez aussi lancer une compression manuelle avec la commande /compress . Si l’agent suggère de démarrer une nouvelle conversation, c’est généralement que le contexte devient trop volumineux pour un résumé efficace.

Tarification de Composer 2

Nous avons évoqué les coûts par token dans la section Variantes, inutile de les répéter. Voici plutôt comment la tarification s’applique concrètement.

Paliers d’abonnement Cursor

Cursor utilise un système d’abonnement à paliers avec des crédits qui déterminent l’usage des modèles tiers. Répartition actuelle :

Comment fonctionnent les crédits avec Composer 2

C’est souvent ce point qui prête à confusion. L’usage de Composer sur les plans individuels provient d’un pool dédié, distinct du pool de crédits utilisé pour les modèles tiers comme Claude ou GPT. Cursor décrit ce pool comme offrant « une utilisation généreuse incluse », sans publier de limites exactes.

Quand vous utilisez le mode « Auto », qui laisse Cursor choisir un modèle pour chaque requête, l’usage des modèles Composer est illimité sur les forfaits payants sans déduire de crédits. Le choix manuel de modèles tiers premium consomme votre pool mensuel. Une fois épuisé, vous pouvez activer le dépassement à l’usage.

Contexte tarifaire

La tarification de Cursor a évolué plusieurs fois l’an passé. En juin 2025, le système forfaitaire « 500 requêtes rapides/mois » a été remplacé par une facturation à crédits, ramenant de fait les requêtes d’environ 500 à près de 225 par mois sur l’offre Pro.

En mars 2026, les modèles de pointe comme GPT‑5.4 et Opus 4.6 débitent votre pool mensuel avec une tarification dynamique à la tokenisation. L’usage de Composer 2 reste sur son pool séparé. Pour budgéter une équipe, privilégiez Composer 2 pour le quotidien et réservez les crédits tiers aux tâches qui l’exigent.

Limites connues de Composer 2

Comme évoqué plus haut, Composer 2 est dédié au code. Le co‑fondateur Aman Sanger est clair : « Il ne vous aidera pas à faire vos impôts. Il ne saura pas écrire des poèmes. » Pour des tâches généralistes, vous aurez toujours besoin de Claude ou GPT dans Cursor.

Des utilisateurs rapportent que, sur des plans d’exécution rigides en plusieurs étapes, Composer 2 omet parfois des vérifications intermédiaires et se précipite vers l’implémentation. Probable artefact d’entraînement : le modèle est incité à « terminer » plutôt qu’à vérifier.

Certains signalent que sous macOS, le file watcher en arrière‑plan de Cursor ignore des directives .gitignore dans de très grands monorepos, amenant l’agent à indexer des dossiers de dépendances comme node_modules et à consommer des tokens de façon inattendue.

CursorBench reste fermé. Pour Terminal‑Bench 2.0, Cursor a retenu « le score maximum entre le leaderboard officiel et le score obtenu sur notre infrastructure » pour les modèles non‑Composer ; une méthodologie à garder à l’esprit.

Sur la transparence : Cursor n’a pas divulgué l’utilisation de Kimi K2.5 comme base dans le billet de lancement. L’information a émergé le 20 mars 2026 lorsqu’un utilisateur a trouvé l’ID du modèle dans des en‑têtes d’API, suscitant brièvement un débat public sur la conformité de licence. Lin Qiao, CEO de Fireworks AI, a clarifié que Cursor était conforme dès le premier jour via la plateforme de Fireworks. Moonshot AI a confirmé un partenariat commercial autorisé. Lee Robinson et le co‑fondateur Aman Sanger ont reconnu que l’absence de disclosure était « un raté » et se sont engagés à plus de transparence sur les modèles de base à l’avenir.

Conclusion

Cursor l’affirme clairement : Composer 2 ne cherche pas à être le modèle le plus capable tous usages confondus. La priorité est un coût plus bas pour le travail quotidien dans l’IDE.

Les benchmarks le confirment : Composer 2 dépasse Claude Opus 4.6 sur Terminal‑Bench 2.0 pour un coût par token inférieur d’environ 90 %, mais reste derrière GPT‑5.4 sur les benchmarks les plus exigeants.

Le marché se dirige vers des workflows multi‑modèles, et la tarification de Composer 2 laisse penser que Cursor construit en partant de cette hypothèse.

Pour en savoir plus sur les outils d’IA qui façonnent le développement logiciel, consultez notre comparaison GPT‑5.4 vs Claude Opus 4.6.