Le 19 mars 2026, Anysphere a publié un article de blog en apparence discret : trois benchmarks, un tableau de prix, et une annonce qui repositionne l’ensemble du marché du coding IA.
Cursor, l’IDE basé sur VS Code qui compte plus d’un million d’utilisateurs quotidiens, ne se contente plus de revendre les modèles d’Anthropic et d’OpenAI.
Avec Composer 2, la startup valorisée à 29,3 milliards de dollars a lancé son propre modèle IA, entraîné entièrement en interne sur des données exclusivement liées au code.
Le signal est stratégique : Cursor passe de revendeur à fabricant, et les chiffres méritent une analyse sérieuse avant de crier victoire ou défaite.
Ce qu’il faut retenir :
- Composer 2 bat Claude Opus 4.6 sur 2 benchmarks sur 3, mais GPT-5.4 reste devant sur Terminal-Bench 2.0 (75.1 vs 61.7)
- Le prix change tout : $0.50/M tokens en entrée contre $5.00 pour Opus 4.6, soit 10x moins cher
- La self-summarization compresse 5 000 tokens en 1 000 avec 50% moins d’erreurs, directement intégrée dans la boucle RL
- Claude Code reste 5,5x plus économe en tokens que Cursor pour des tâches identiques : l’avantage prix de Composer 2 se réduit à l’usage
- Trois générations en 5 mois (oct. 2025, fév. 2026, mars 2026) : la vélocité d’Anysphere est un signal industriel autant que technique
Cursor Composer 2 : genèse et architecture
Pour comprendre ce que représente Composer 2, il faut retracer une chronologie rapide.
En octobre 2025, Cursor lance Composer 1 avec la sortie de Cursor 2.0 : premier modèle propriétaire de la startup, architecturé en Mixture-of-Experts (MoE) avec apprentissage par renforcement, 4x plus rapide que les modèles comparables, mais moins précis que les modèles frontier.
En février 2026, Composer 1.5 améliore les benchmarks (44.2 sur CursorBench, 47.9 sur Terminal-Bench 2.0), mais reste encore derrière Opus 4.6 de 10 points sur Terminal-Bench selon The New Stack.
Le 19 mars 2026, Composer 2 inaugure deux phases d’entraînement inédites pour Anysphere.
Phase 1 : le continued pretraining.
Cursor a pris un modèle de base (dont il ne divulgue pas le nom) et l’a ré-entraîné intensivement sur un corpus massif de code, avant toute phase de fine-tuning.
C’est le même playbook que DeepSeek Coder ou CodeLlama : saturer un bon modèle général de données de code pour créer une base spécialisée, plus réceptive au signal de renforcement.
Phase 2 : le RL sur tâches long-horizon.
Cursor a ensuite appliqué du reinforcement learning spécifiquement sur des tâches de coding à séquences longues, exigeant des centaines d’actions consécutives.
Le résultat est un modèle avec une fenêtre de contexte de 200 000 tokens, une vitesse de génération annoncée à 200+ tokens par seconde, et une spécialisation revendiquée : Composer 2 ne fait pas de poèmes et ne remplit pas vos déclarations fiscales.
Co-fondateur Aman Sanger, à Bloomberg : « Il ne vous aidera pas à faire vos impôts. »
« La concentration sur le code est l’avantage compétitif, pas une limitation. »
Pour explorer les fonctionnalités de Cursor avant de plonger dans les benchmarks, notre guide complet de Cursor pour développeurs couvre l’ensemble des fonctionnalités de l’IDE.
Les benchmarks décryptés
Cursor publie trois benchmarks pour Composer 2.
Avant de lire les chiffres, une note méthodologique s’impose.
Les harnesses d’évaluation diffèrent selon les modèles : les modèles Anthropic sont évalués avec le harness Claude Code, les modèles OpenAI avec le Simple Codex harness, et Cursor utilise le framework Harbor (le harness officiel désigné pour Terminal-Bench 2.0).
Ces différences ne sont pas anodines : Anthropic rapporte que Claude Opus 4.6 atteint 65.4% sur Terminal-Bench 2.0 dans sa propre configuration optimisée, contre 58.0% dans les mesures de Cursor.
Pour aller plus loin sur la lecture critique des benchmarks IA, notre article comment lire les benchmarks IA sans se faire manipuler donne les clés d’analyse.
Terminal-Bench 2.0
Terminal-Bench 2.0 est maintenu par le Laude Institute : il teste la capacité d’un agent à accomplir des tâches en ligne de commande de façon autonome, sans assistance humaine step-by-step.
Cursor a effectué 5 itérations par paire modèle/agent et reporté la moyenne.
| Modèle | Terminal-Bench 2.0 |
|---|---|
| GPT-5.4 Thinking | 75.1 |
| Composer 2 | 61.7 |
| Claude Opus 4.6 | 58.0 |
| Composer 1.5 | 47.9 |
Composer 2 bat Claude Opus 4.6 de 3,7 points sur ce benchmark externe, mais GPT-5.4 reste devant avec une avance significative de 13 points.
CursorBench interne
CursorBench est le benchmark propriétaire de Cursor : les tâches sont basées sur les requêtes réelles des ingénieurs d’Anysphere, avec une moyenne de 352 lignes de code réparties sur 8 fichiers par exercice.
| Modèle | CursorBench |
|---|---|
| GPT-5.4 Thinking (High) | 63.9 |
| Composer 2 | 61.3 |
| Claude Opus 4.6 | 58.2 |
| Composer 1.5 | 44.2 |
Composer 2 dépasse Claude Opus 4.6 (61.3 vs 58.2) pour la première fois sur ce test interne, tout en restant légèrement derrière GPT-5.4.
Gardez la relativité : c’est Cursor qui a conçu ce benchmark, sur des tâches correspondant à son propre éditeur.
SWE-bench Multilingual
SWE-bench Multilingual est le plus neutre des trois : il teste la résolution de vrais tickets GitHub dans plusieurs langages de programmation.
| Modèle | SWE-bench Multilingual |
|---|---|
| Claude Opus 4.6 | 77.8 |
| Composer 2 | 73.7 |
| Composer 1.5 | 65.9 |
| Composer 1 | 56.9 |
C’est le seul benchmark des trois où Claude Opus 4.6 conserve l’avantage : 77.8% contre 73.7% pour Composer 2.
L’amélioration par rapport à Composer 1.5 reste remarquable (+7.8 points), mais le résumé honnête est celui-ci : Composer 2 est devant sur 2 benchmarks sur 3, et derrière sur le plus neutre.
Le vrai avantage : le prix
Les benchmarks font les titres, mais c’est le tableau de prix qui devrait retenir l’attention des équipes de développement.
Composer 2 vise l’optimum prix/performance, et à ce niveau de prix, la comparaison change radicalement.
| Modèle | Input (par 1M tokens) | Output (par 1M tokens) |
|---|---|---|
| Composer 2 Standard | $0.50 | $2.50 |
| Composer 2 Fast (défaut) | $1.50 | $7.50 |
| Claude Opus 4.6 | $5.00 | $25.00 |
| GPT-5.4 (court contexte) | $2.50 | $15.00 |
| GPT-5.4 (long contexte) | $5.00 | $22.50 |
Le tier Standard est 10x moins cher qu’Opus 4.6 en entrée et en sortie.
Même la variante Fast (qui devient le mode par défaut dans Cursor et offre la même intelligence à plus haute vitesse) reste 3x moins chère qu’Anthropic et 2x moins chère qu’OpenAI en contexte court.
Le calcul économique devient frappant à l’échelle : une équipe consommant 10 millions de tokens par jour paie environ $5 avec Composer 2 Standard, contre $50 avec Claude Opus 4.6.
C’est l’analogie Apple puces M vs Intel appliquée au monde des modèles : en contrôlant l’ensemble de la chaîne, du training à l’inférence, Cursor peut offrir des performances comparables à un coût structurellement inférieur.
La self-summarization : l’innovation technique
La vraie innovation de Composer 2, moins visible que les benchmarks, est ce que Cursor appelle le compaction-in-the-loop RL.
Le problème à résoudre est classique : les tâches de coding complexes génèrent des centaines d’actions et des dizaines de milliers de tokens de contexte, et quand la fenêtre se remplit, les modèles « oublient » et commettent des erreurs qui invalident tout le travail précédent.
Les solutions habituelles (glisser la fenêtre, compresser via prompts séparés) perdent invariablement des informations cruciales.
La solution de Cursor : intégrer la compression dans la boucle d’apprentissage par renforcement elle-même.
Composer 2 apprend, pendant l’entraînement lui-même, quelles informations valent la peine d’être gardées.
La compression est intégrée au cycle d’apprentissage par renforcement, pas ajoutée après coup.
Concrètement, quand Composer 2 atteint un seuil de tokens, il insère une synthèse de son contexte actuel : il compresse 5 000+ tokens en environ 1 000 tokens, avec une sélection apprise par renforcement.
Les résultats mesurés par Cursor sur des tâches de haute difficulté :
- Les résumés traditionnels par prompt nécessitent 5 000+ tokens de sortie en moyenne
- La self-summarization de Composer 2 produit des résumés de 1 000 tokens en moyenne (5x plus token-efficient)
- Les erreurs de compression sont réduites de 50%
Un exemple documenté dans les notes de recherche de Cursor : une tâche de 170 tours d’interaction avec compression de 100 000+ tokens vers 1 000 tokens au fil de la session, avec un résultat final correct.
Composer 2 vs Claude Code : deux philosophies
La comparaison la plus pertinente pour un développeur : Cursor avec Composer 2 vs Claude Code, bien plus que Composer 2 vs Opus 4.6 en isolation.
Ces deux outils ont convergé en 2026 sur beaucoup de fonctionnalités (agents en arrière-plan, CLI, workflows agentiques), mais leur philosophie reste structurellement différente.
| Critère | Cursor + Composer 2 | Claude Code |
|---|---|---|
| Interface principale | IDE complet (fork VS Code) | CLI + extensions VS Code |
| Accès aux modèles | Multi-modèles (Claude, GPT, Gemini, Composer) | Modèles Anthropic uniquement |
| Contexte effectif | 200K annoncé, 70-120K en pratique | 200K fiable (1M en bêta) |
| Tab completions | Oui, modèle dédié | Non |
| Efficience tokens | Standard marché | 5,5x moins de tokens pour tâches identiques |
Le chiffre 5,5x est documenté : Claude Code complète une tâche de référence avec 33 000 tokens sans erreur, là où Cursor (avec GPT-5) en consomme 188 000 avec des erreurs (The New Stack, builder.io).
L’avantage prix brut de Composer 2 ($0.50 vs $5.00) doit être pondéré par cette consommation de tokens supérieure à l’usage.
Sur la fenêtre de contexte, plusieurs threads sur le forum Cursor reportent une limite effective de 70 000 à 120 000 tokens, malgré l’annonce de 200K, due à des truncations internes de performance.
Pour les développeurs qui débutent avec Claude Code, notre guide des commandes Claude Code pour débutants reste le meilleur point d’entrée.
La philosophie de chaque outil traduit deux visions du coding IA :
- Cursor : l’IDE enrichi par l’IA, avec feedback visuel, tab completions, multi-modèles, et maintenant son propre modèle spécialisé
- Claude Code : l’agent autonome qui délègue les tâches complexes, avec contexte fiable et efficience maximale
Le pattern qui émerge chez les développeurs les plus productifs : Claude Code pour les gros refactors et l’architecture, Cursor pour l’édition rapide et le UI/frontend.
Impact sur le marché du coding IA
Composer 2 est autant un signal industriel qu’un produit.
Depuis deux ans, Cursor, GitHub Copilot et Windsurf étaient tous des « revendeurs avec une belle interface » : les vrais modèles venaient d’Anthropic, OpenAI ou Google.
Avec Composer 2, Cursor devient la première plateforme de coding IA à produire son propre modèle frontier-class tout en continuant à proposer les modèles tiers en parallèle.
La logique économique est directe : les souscriptions Cursor opèrent à marges négatives, subventionnées par les contrats enterprise.
Si Cursor sert la majorité de ses requêtes sur son propre modèle, son coût de revient s’effondre et sa dépendance aux fournisseurs concurrents disparaît.
Car Anthropic a Claude Code, OpenAI a Codex standalone, Google a Gemini CLI : chaque grand lab construit son propre outil de coding.
Cursor ne pouvait pas rester indéfiniment dépendant de modèles fournis par ses propres compétiteurs.
Composer 2 est une réponse de survie autant qu’une ambition technique.
La valorisation actuelle de 29,3 milliards de dollars (novembre 2025), plus de 2 milliards de dollars ARR et 50 000 clients business (Stripe, Figma) donnent à Anysphere les ressources pour accélérer cette stratégie.
Trois générations de Composer en cinq mois montre une vélocité de R&D que peu de labs pourraient soutenir.
Des chercheurs d’Anysphere ont déjà commencé à évoquer publiquement Composer 3.
Notre verdict sur Composer 2
La réponse dépend de votre profil d’utilisation.
Composer 2 sur Cursor vaut clairement le test si :
- Vous êtes déjà abonné Cursor Pro et cherchez à étirer votre budget de requêtes
- Vos tâches quotidiennes sont bien définies : refactors clairs, features avec spécifications précises, modifications multi-fichiers sur une base de code maîtrisée
- La vitesse de génération compte dans votre workflow : 200+ tokens/s change l’expérience d’itération répétée
- Vous travaillez sur un grand monorepo où la self-summarization donne à Composer 2 un avantage structurel sur les tâches longues
Claude Opus 4.6 (ou Claude Code) reste supérieur si :
- Vos tâches exigent une profondeur de raisonnement sur des architectures complexes ou des exigences ambiguës
- Vous avez besoin du contexte fiable à 200K tokens sur une large base de code
- L’efficience tokens à l’usage vous importe (5,5x d’économies mesurées sur des tâches complexes)
- Vous résolvez des tickets GitHub réels : Opus 4.6 reste devant sur SWE-bench Multilingual (77.8% vs 73.7%)
Testez Composer 2 sur un projet existant : prenez une tâche de refactoring que vous connaissez bien, mesurez le résultat et le coût réel en tokens.
Et pour découvrir le coding IA depuis le début, notre guide Claude Code pour débutants reste le meilleur point d’entrée dans l’univers des agents de coding.
La vraie leçon de Composer 2 : le marché du coding IA entre dans une phase de spécialisation verticale où les plateformes les plus solides construisent leurs propres fondations.
FAQ
Composer 2 bat-il réellement Claude Opus 4.6 ?
Sur 2 benchmarks sur 3 publiés par Cursor, oui.
Composer 2 dépasse Opus 4.6 sur CursorBench (61.3 vs 58.2) et Terminal-Bench 2.0 (61.7 vs 58.0).
Sur SWE-bench Multilingual (le plus neutre), Opus 4.6 conserve l’avantage (77.8 vs 73.7).
Les différences de harness d’évaluation rendent les comparaisons partiellement indirectes.
Quel est le prix de Composer 2 ?
Le tier Standard est à $0.50/M tokens en entrée et $2.50/M en sortie.
Le tier Fast (défaut dans Cursor) est à $1.50/$7.50.
Claude Opus 4.6 est à $5.00/$25.00, soit 10x plus cher que le Standard.
Composer 2 est-il utilisable hors de l’IDE Cursor ?
Oui, via l’API Cursor avec les identifiants composer-2 (Standard) et composer-2-fast.
Pour les abonnés Cursor Pro, l’usage de Composer 2 est pris sur un quota dédié, séparé des crédits pour les modèles tiers.
Sur quel modèle de base Composer 2 est-il entraîné ?
Cursor ne divulgue pas le modèle de base utilisé pour le continued pretraining.
La startup confirme uniquement : une première phase de pretraining sur du code, suivie d’une phase de RL sur des tâches long-horizon.
Qu’est-ce que la self-summarization de Cursor ?
Cursor l’appelle compaction-in-the-loop RL : quand Composer 2 approche la limite de sa fenêtre de contexte, il compresse automatiquement son historique (5 000+ tokens vers ~1 000).
Cette capacité est apprise pendant l’entraînement par renforcement, pas appliquée en post-traitement.
Résultat : 5x plus token-efficient que les méthodes traditionnelles et 50% moins d’erreurs de compression.
Quelle est la vitesse de génération de Composer 2 ?
Cursor rapporte plus de 200 tokens par seconde (mesure prise sur le trafic réel du 18 mars 2026, normalisée pour les différences de taille de tokens entre fournisseurs).
La variante Fast est le mode par défaut dans l’IDE.
Faut-il choisir Cursor ou Claude Code en 2026 ?
Cursor excelle pour l’édition rapide, les tab completions, la flexibilité multi-modèles et les workflows visuels.
Claude Code est supérieur pour les gros refactors autonomes, le contexte fiable à 200K tokens et l’efficience tokens (5,5x moins de tokens pour des tâches identiques).
Plusieurs développeurs utilisent les deux en parallèle selon la nature des tâches.
GPT-5.4 est-il meilleur que Composer 2 ?
Sur Terminal-Bench 2.0, GPT-5.4 Thinking arrive en tête avec 75.1% contre 61.7% pour Composer 2.
Sur CursorBench, GPT-5.4 High est légèrement devant (63.9 vs 61.3).
GPT-5.4 est facturé à $2.50-$5.00/M tokens en entrée, contre $0.50 pour Composer 2 Standard.
Composer 2 peut-il gérer les grands projets enterprise ?
Pour les tâches de coding bien définies sur de grandes bases de code, la self-summarization donne à Composer 2 un avantage spécifique sur les sessions longues.
Pour les architectures complexes avec des exigences ambiguës, Opus 4.6 maintient une profondeur de raisonnement supérieure selon le consensus des développeurs ayant testé les deux.
Cursor est-il toujours fiable avec Composer 2 ?
La communauté Cursor a signalé des problèmes de fiabilité en mars 2026, dont un bug confirmé de réversion de code.
Des développeurs reportent des coûts mensuels de $40-50 avec usage intensif et une limite de contexte effective à 70-120K tokens malgré l’annonce de 200K.
Articles Similaires
Reddit bloque le scraping IA : ce qui change pour les LLM et l’open source
Le 25 mars 2026, Reddit a déclenché une onde de choc dans la communauté IA : la plateforme ferme ses portes aux scrapers automatisés, impose la vérification biométrique pour les…
Jensen Huang déclare l’AGI atteinte : analyse d’une annonce qui divise
Le 22 mars 2026, à 1h55 dans l’épisode 494 du podcast Lex Fridman, Jensen Huang a prononcé cinq mots qui ont secoué la planète tech. Jensen Huang, PDG de Nvidia,…