Cursor Composer 2.5 : le modèle coding qui rivalise avec Opus 4.7 à un dixième du prix
🔎 0,50$ contre 5$ : la guerre des prix des modèles coding s'accélère
Le 18 mai 2026, Cursor sortait Composer 2.5, son troisième modèle proprietary. Le chiffre qui fait tilt : 0,50$ par million de tokens en input, soit exactement dix fois moins que Claude Opus 4.7 d'Anthropic (5$/M). Sauf que sur les benchmarks de coding agentique, les deux modèles affichent des scores quasi identiques.
C'est le signal fort d'un basculement de marché. Les éditeurs d'IDE IA ne se contentent plus d'emballer les modèles tiers : ils construisent leurs propres moteurs, optimisés pour une tâche précise, et cassent la structure de tarification dominante. Cursor n'est plus un simple wrapper autour d'Anthropic ou d'OpenAI. C'est devenu un acteur modèle.
L'essentiel
- Composer 2.5 égale Claude Opus 4.7 sur SWE-Bench Multilingual (79,8%) et CursorBench v3.1 (63,2%), d'après les données compilées par LushBinary.
- Prix de 0,50$/M input tokens contre 5$/M pour Opus 4.7, soit un rapport coût/performance 10:1 sur les tâches de coding agentique.
- Base technique : Kimi K2.5 de Moonshot AI, post-entraîné par Cursor avec 25× plus de tâches synthétiques et un optimiseur Sharded Muon, selon BuildFastWithAI.
- Disponibilité exclusive dans l'IDE Cursor. Pas d'API publique, pas de possibilité de l'utiliser hors écosystème.
- GPT-5.5 reste devant sur Terminal-Bench 2.0 (+13 points), ce qui signifie que Composer 2.5 n'est pas universellement supérieur.
Outils recommandés
| Outil | Usage principal | Prix (mai 2026, vérifiez sur cursor.com) | Idéal pour |
|---|---|---|---|
| Cursor (Composer 2.5) | IDE IA avec modèle proprietary intégré | Abonnement Pro (~20$/mois) | Développeurs qui codent en agentique au quotidien |
| Claude Opus 4.7 | LLM frontier généraliste | 5$/M input tokens (API) | Tâches complexes hors coding pur |
| GPT-5.5 | LLM frontier, leader Terminal-Bench | Tarification API OpenAI | Sessions terminal et bash intenses |
| Claude Code | Agent coding CLI d'Anthropic | Via API Anthropic | Développeurs CLI puristes |
Les benchmarks : où Composer 2.5 frappe vraiment
La performance frontier-level à une fraction du prix, c'est le claim central de la sortie. Mais les chiffres demandent un regard précis pour comprendre ce qui se passe réellement.
SWE-Bench Multilingual : le match nul
Sur SWE-Bench Multilingual, Composer 2.5, Claude Opus 4.7 et GPT-5.5 convergent tous les trois à 79,8%. C'est le benchmark qui mesure la capacité d'un modèle à résoudre des tickets GitHub réels dans plusieurs langages de programmation.
Un score identique entre trois modèles de génération différente est rare. Il suggère soit un plafond structurel du benchmark, soit une optimisation spécifique de chaque acteur sur cette métrique. Dans les deux cas, Composer 2.5 y arrive à un coût dérisoire.
CursorBench v3.1 : le terrain de jeu maison
Composer 2.5 atteint 63,2% sur CursorBench v3.1, là encore à égalité avec Opus 4.7 et GPT-5.5. C'est le benchmark interne de Cursor, conçu pour mesurer la performance en contexte d'agent multi-fichiers.
Le biais est évident : Cursor optimise ses modèles sur son propre benchmark. Mais tant que les résultats sont reproductibles et que le benchmark est public, c'est un signal de capacité réelle en environnement agentique.
Terminal-Bench 2.0 : la faille
C'est là que le récit se fissure. GPT-5.5 devance Composer 2.5 de 13 points sur Terminal-Bench 2.0. Ce benchmark mesure les compétences en ligne de commande, en bash et en opérations système.
Composer 2.5 est optimisé pour le coding en agent multi-fichiers, pas pour les sessions terminal pures. C'est un choix architectural, pas un défaut. Mais ça signifie que pour les workflows centrés sur le CLI, GPT-5.5 reste le choix évident.
| Benchmark | Composer 2.5 | Claude Opus 4.7 | GPT-5.5 |
|---|---|---|---|
| SWE-Bench Multilingual | 79,8% | 79,8% | 79,8% |
| CursorBench v3.1 | 63,2% | 63,2% | 63,2% |
| Terminal-Bench 2.0 | ← | ← | +13 pts |
| Prix input (par M tokens) | 0,50$ | 5$ | Variable |
Sources : LushBinary, TechTimes
L'architecture : Kimi K2.5 massivement post-entraîné
Composer 2.5 n'est pas un modèle construit de zéro. C'est un modèle de base open-source, Kimi K2.5 de Moonshot AI (Pékin), sur lequel Cursor a appliqué un post-entraînement massif.
Selon AlphaMatch, seulement ~25% du compute provient du modèle de base Kimi K2.5. Les 75% restants sont le travail d'entraînement de Cursor. Ce ratio est révélateur : la valeur ne réside plus dans le pré-entraînement, mais dans ce qu'on fait après.
Trois piliers du post-entraînement Cursor
1. 25× plus de tâches d'entraînement synthétique. Cursor a généré des millions de scénarios de coding agentique — résolution de bugs multi-fichiers, refactoring, ajout de features — pour créer un dataset d'alignement ultra-spécifique.
2. RL avec feedback textuel ciblé. Pas du RLHF générique. Un système de récompense qui évalue précisément la qualité du code généré en contexte agentique, avec des retours textuels granulaires plutôt que des simples upvote/downvote.
3. Optimiseur Sharded Muon. Une innovation d'optimisation qui permet de faire passer ce volume d'entraînement avec une efficacité de compute supérieure. C'est technique, mais c'est ce qui rend le modèle rentable à 0,50$/M tokens.
Cette stratégie — prendre un bon modèle open-source et le spécialiser à l'extrême — est exactement ce que d'autres acteurs font. La différence : Cursor contrôle l'IDE, le benchmark et le modèle. La boucle est fermée.
Le positionnement stratégique : pourquoi Cursor construit ses modèles
Cursor affiche un ARR en centaines de millions de dollars début 2026, selon Memeburn. Avec cette taille, dépendre d'Anthropic ou d'OpenAI pour le cœur de son produit devient un risque stratégique majeur.
Le piège de la dépendance aux modèles tiers
Un éditeur d'IDE IA qui utilise exclusivement des modèles tiers fait face à trois problèmes. Le premier est la marge : chaque token généré via Opus 4.7 coûte 5$, et Cursor doit soit l'absorber, soit le répercuter sur l'utilisateur. Le deuxième est la différenciation : si votre IDE utilise le même modèle que tous vos concurrents, votre avantage compétitif réside uniquement dans l'UX. Le troisième est la vulnérabilité : Anthropic ou OpenAI peuvent changer leurs prix, leurs conditions d'accès, ou sortir leur propre IDE.
En construisant Composer 2.5, Cursor élimine ces trois risques d'un coup. Le coût par session baisse drastiquement, le modèle est exclusif, et personne ne peut le retirer.
La concurrence monte : Claude Code et OpenAI Codex
Anthropic pousse Claude Code, son agent coding en CLI. OpenAI développe Codex. Les deux sont des menaces directes sur le terrain de l'agent coding. Composer 2.5 est la réponse de Cursor : un modèle que ni Anthropic ni OpenAI ne peuvent offrir, optimisé pour l'écosystème Cursor.
Le parallèle avec Gemini 3.5 Flash, qui bat Opus 4.7 et GPT-5.5 sur les benchmarks agents, est frappant. La tendance est claire : les modèles spécialisés et optimisés dépassent les modèles generalistes frontier sur leur terrain de prédilection.
Ce que ça change concrètement pour le développeur
L'analyse de Kingy AI met le doigt sur les changements pratiques. Au-delà des benchmarks, qu'est-ce que Composer 2.5 change dans le quotidien d'un développeur Cursor ?
Des sessions agentiques plus longues sans casser la tirelire
L'avantage prix n'est pas théorique. Une session agentique intensive avec Opus 4.7 peut facilement consommer 5 à 10 millions de tokens en input (contexte accumulé, relectures, itérations). À 5$/M, ça coûte 25 à 50$ par session complexe. À 0,50$/M avec Composer 2.5, c'est 2,50$ à 5$.
Ça change le comportement. Les développeurs n'hésitent plus à lancer des tâches agentiques lourdes — refactoring d'un module entier, migration de framework, debug跨-fichiers — parce que le coût n'est plus un frein psychologique.
Meilleure cohérence multi-fichiers
Composer 2.5 est entraîné spécifiquement pour maintenir la cohérence quand il modifie plusieurs fichiers en parallèle. C'est là que le post-entraînement sur des tâches synthétiques agentiques paie : le modèle "comprend" qu'un changement dans un fichier A implique des modifications coordonnées dans les fichiers B et C, sans perdre le fil.
Les limites réelles
Ce n'est pas un modèle miracle. Sur les tâches de pure logique algorithmique hors contexte agentique, Opus 4.7 reste probablement supérieur. Sur le terminal pur, GPT-5.5 l'écrase. Et surtout, Composer 2.5 est enfermé dans Cursor. Si vous changez d'IDE, il disparaît.
Pour choisir le bon modèle selon votre usage, le comparatif Claude, GPT, Gemini, Llama : quel modèle choisir en 2026 ? offre un cadre de décision par profil.
La course à la souveraineté des modèles : ce que Composer 2.5 signifie pour le marché
L'industrie du LLM traverse une phase de maturation. La première vague (2023-2024) était celle de l'accès : qui pouvait utiliser les meilleurs modèles. La deuxième vague (2025) était celle de l'agentique : qui pouvait faire exécuter des tâches complexes. La troisième vague, celle que Composer 2.5 illustre, est celle de la souveraineté modèle.
Le modèle comme moat, pas comme commodité
Quand Cursor, Google avec Gemini 3.5 Flash, et d'autres acteurs commencent à construire des modèles sur mesure, le LLM cesse d'être une commodité interchangeabilité. Il redevient un avantage compétitif propriétaire.
C'est un retour en arrière paradoxal. L'open-source (Kimi K2.5, Llama, etc.) a démocratisé l'accès aux modèles de base. Mais la valeur s'est déplacée vers le post-entraînement spécialisé, qui lui reste propriétaire. Le modèle ouvert est le socle. La spécialisation est le fossé.
Les gagnants et les perdants
Gagnants : Les éditeurs d'outils qui ont assez de données d'usage et de compute pour post-entraîner leurs propres modèles. Cursor, Google, probablement Microsoft/GitHub à terme.
Perdants : Les fournisseurs de modèles "purs" qui ne contrôlent pas la couche application. Si Cursor peut offrir 90% de la performance d'Opus 4.7 pour 10% du prix, la valeur perçue d'Anthropic sur le segment coding diminue mécaniquement.
Inconnue : Les développeurs. Plus de choix, mais aussi plus de lock-in. Chaque écosystème IDE aura son modèle exclusif, et migrer d'un outil à l'autre signifiera changer de "cerveau".
Le rapport qualité-prix en détail
Parler de "dix fois moins cher" est exact mais incomplet. Il faut regarder le coût total d'une session de coding agentique pour comprendre l'impact réel.
Scénario concret : refactoring d'un module backend
Prenons une tâche typique : refactorer un module de 15 fichiers, ajouter des tests, mettre à jour les types. Contexte initial : 200K tokens. À chaque itération, le contexte grossit de 50 à 100K tokens. Sur 10 itérations, on atteint facilement 1M tokens en input cumulés.
| Modèle | Coût input (1M tokens) | Coût pour cette tâche |
|---|---|---|
| Claude Opus 4.7 | 5$/M | ~5$ |
| GPT-5.5 | Tarif API OpenAI | Variable |
| Composer 2.5 | 0,50$/M | ~0,50$ |
Sur une seule tâche, la différence est modeste. Mais un développeur intensif peut lancer 20 à 50 sessions agentiques par semaine. À l'échelle d'une équipe de 10 développeurs sur un mois, l'économie se compte en milliers de dollars.
Pourquoi Cursor peut se permettre ce prix
Le coût de 0,50$/M tokens n'est pas de la magie. C'est la combinaison de trois facteurs : un modèle de base open-source (pas de coût de pré-entraînement à amortir), une optimisation d'infrastructure via Sharded Muon, et un modèle économique où l'abonnement Cursor Pro (~20$/mois) absorbe une partie de la marge.
Cursor ne vend pas des tokens. Il vend un abonnement IDE avec un modèle intégré. La tarification par token est un signal de comparaison, pas nécessairement la structure de revenus réelle.
❌ Erreurs courantes
Erreur 1 : Confondre "égaler sur un benchmark" avec "égaler en général"
Composer 2.5 égale Opus 4.7 sur SWE-Bench Multilingual et CursorBench. Ça ne veut pas dire qu'il égale Opus 4.7 sur tout. Sur le raisonnement général, la rédaction, l'analyse de documents longs, Opus reste largement supérieur. Composer 2.5 est un spécialiste, pas un polymathe.
Erreur 2 : Penser que Composer 2.5 remplacera tous les modèles dans Cursor
L'IDE Cursor propose toujours Claude Opus 4.7, GPT-5.5 et d'autres modèles. Composer 2.5 est une option supplémentaire, optimisée pour les tâches agentiques multi-fichiers. Pour une revue de code ponctuelle ou une question de conception, Opus ou GPT-5.5 peuvent rester de meilleurs choix.
Erreur 3 : Ignorer le lock-in
Composer 2.5 n'existe que dans Cursor. Si vous construisez des workflows qui dépendent de ses spécificités (cohérence multi-fichiers, coût bas pour sessions longues), migrer vers Claude Code ou un autre outil sera douloureux. C'est exactement ce que Cursor veut.
Erreur 4 : Comparer les prix tokens sans contexte
0,50$/M vs 5$/M, c'est un ratio 10:1. Mais si Composer 2.5 a besoin de 2× plus de tokens pour arriver au même résultat (contexte plus grand, plus d'itérations), le ratio réel devient 5:1. C'est toujours massif, mais il faut rester honnête sur les métriques.
❓ Questions fréquentes
Composer 2.5 est-il disponible via API ?
Non. Il est exclusivement intégré à l'IDE Cursor. Vous ne pouvez pas l'appeler depuis votre propre application ou via un client API externe.
Quel est le rapport exact avec Kimi K2.5 ?
Kimi K2.5 de Moonshot AI sert de modèle de base. Cursor applique ensuite un post-entraînement massif (75% du compute total) pour le spécialiser en coding agentique. Le modèle final est propriétaire.
Composer 2.5 bat-il GPT-5.5 ?
Non. Il égale GPT-5.5 sur SWE-Bench Multilingual et CursorBench, mais GPT-5.5 reste nettement supérieur sur Terminal-Bench 2.0 (+13 points). Le classement des meilleurs LLM agentic reflète cette hiérarchie.
Est-ce que ça vaut le coup de passer à Cursor juste pour Composer 2.5 ?
Si vous faites du coding agentique intensif (multi-fichiers, sessions longues), oui. Le rapport coût/performance est imbattable. Si vous utilisez l'IA ponctuellement pour des questions rapides, l'abonnement Cursor ne se justifie probablement pas.
Cursor va-t-il ouvrir Composer 2.5 un jour ?
Rien ne l'indique. La stratégie de Cursor est de créer un lock-in par le modèle. Ouvrir l'accès détruirait cet avantage. Les meilleurs outils IA pour le code montrent que chaque éditeur tend vers la même logique d'écosystème fermé.
✅ Conclusion
Cursor Composer 2.5 confirme un tournant : dans le coding agentique, le post-entraînement spécialisé bat le modèle generaliste frontier, à une fraction du coût. Les 79,8% sur SWE-Bench Multilingual à 0,50$/M tokens ne sont pas un trick de benchmark — c'est le résultat d'une stratégie d'entraînement cohérente basée sur Kimi K2.5. Le reste est du lock-in assumé, et pour l'instant, il fonctionne.