Cursor a lancé Composer 2.5 le 18 mai 2026, et le titre est difficile à ignorer : un modèle de codage qui égale Opus 4.7 et GPT-5.5 sur de véritables benchmarks logiciels tout en coûtant moins d'un dollar par tâche. Si vous gagnez votre vie en écrivant du code, ce rapport qualité-prix change la façon dont vous planifiez votre journée.
Ce guide couvre trois choses que les développeurs continuent de chercher : ce qu'est réellement Composer 2.5, comment y accéder dans Cursor, et comment bien l'utiliser pour le travail de production. Vous obtiendrez les chiffres des benchmarks, le calcul des prix et un flux de travail pratique qui associe le modèle à Apidog afin que le code API qu'il écrit soit correct dès la première exécution.
Qu'est-ce que Cursor Composer 2.5 ?
Composer 2.5 est le propre modèle de codage agentique de Cursor, conçu pour planifier, modifier des fichiers, exécuter des commandes de terminal et vérifier son propre travail au sein de l'éditeur Cursor. C'est le successeur de Composer 2, et il fait passer le modèle de "partenaire d'autocomplétion rapide" à "agent qui termine de longues tâches sans perdre le fil".
Quelques faits le définissent :
- Il est construit sur le point de contrôle open-source Moonshot Kimi K2.5, une base d'environ un billion de paramètres.
- Cursor a consacré environ 85 % du budget de calcul d'entraînement à la post-formation et à l'apprentissage par renforcement, et pas seulement au modèle de base.
- Il a été entraîné sur 25 fois plus de tâches synthétiques que Composer 2, y compris des exercices où Cursor supprime une fonctionnalité et le modèle doit la reconstruire jusqu'à ce que les tests passent.
Le résultat pratique est un modèle qui maintient le contexte sur de longues sessions. Composer 2 était rapide mais parfois imprécis sur les tâches en plusieurs étapes. Composer 2.5 soutient l'effort sur une longue tâche, suit des instructions complexes de manière plus fiable et calibre la quantité de travail réellement nécessaire à une requête au lieu d'en faire trop ou pas assez.
Si vous souhaitez en savoir plus sur la famille de modèles, le guide Composer 2 explique l'architecture sur laquelle la version 2.5 s'appuie.
Ce qui a changé sous le capot
Trois idées d'entraînement sont à l'origine du bond en avant :
- RL ciblée avec feedback textuel. Au lieu d'une seule récompense à la fin d'une tâche, Cursor écrit un court indice décrivant la correction qu'il souhaite, insère cet indice dans le contexte local et distille le comportement dans le modèle. C'est ainsi qu'il a appris à cesser d'appeler des outils qui ne sont pas disponibles.
- Données synthétiques à grande échelle. L'augmentation de 25x des tâches synthétiques donne au modèle beaucoup plus de pratique sur le travail réaliste de dépôt, vérifié par des tests plutôt que par des intuitions.
- Un optimiseur Muon sharded avec HSDP dual-mesh. Il s'agit d'une infrastructure d'entraînement, et non d'une fonctionnalité que vous utilisez directement, mais c'est la raison pour laquelle Cursor a pu entraîner un modèle de 1T de paramètres avec une étape d'optimisation de 0,2 seconde. Des boucles d'entraînement plus rapides signifient plus d'itérations sur la qualité.
Vous n'avez pas besoin de mémoriser tout cela pour utiliser le modèle. C'est important car cela explique pourquoi Composer 2.5 semble plus stable sur les types de tâches longues et complexes qui bloquaient les agents précédents.
Benchmarks de Composer 2.5 : est-il vraiment si bon ?
Cursor rapporte les scores sur trois suites et les compare à Opus 4.7 et GPT-5.5. Voici le tableau :
| Benchmark | Composer 2.5 | Opus 4.7 | GPT-5.5 |
|---|---|---|---|
| SWE-bench Multilingual | 79.8% | 80.5% | 77.8% |
| Terminal-Bench 2.0 | 69.3% | 69.4% | 82.7% |
| CursorBench v3.1 | 63.2% | 64.8% (max) / 61.6% (default) | 59.2% (default) |
Lisez attentivement et l'histoire est cohérente. Sur SWE-bench Multilingual, un test standard de correction de vrais problèmes GitHub dans plusieurs langues, Composer 2.5 atteint 79,8 %, à un point d'Opus 4.7 et devant GPT-5.5. C'est une grande avancée par rapport aux 73,7 % de Composer 2. Sur CursorBench, la suite de tâches propre à Cursor, il dépasse les paramètres par défaut d'Opus 4.7.
Le seul domaine où il est à la traîne est Terminal-Bench 2.0, où GPT-5.5 mène avec 82,7 %. Si votre travail implique de longues séquences de terminal, gardez cela à l'esprit.
Le chiffre qui recontextualise tout est le coût par tâche. Cursor rapporte environ 63 % sur CursorBench pour un coût moyen de moins d'un dollar par tâche, tandis qu'Opus 4.7 et GPT-5.5 coûtent plusieurs dollars par tâche pour des résultats similaires ou inférieurs ; certaines comparaisons estiment les coûts des concurrents jusqu'à onze dollars. Une couverture indépendante de The Decoder est arrivée à la même conclusion : une qualité proche de la pointe de l'innovation à une fraction du prix.
Ainsi, Composer 2.5 n'est pas le meilleur modèle absolu sur tous les tableaux. C'est le modèle qui vous offre 95 % de la qualité de pointe pour environ un dixième du coût, ce qui est le compromis que la plupart des équipes souhaitent.
Combien coûte Composer 2.5 ?
Cursor propose deux variantes à deux niveaux de prix :
| Variante | Entrée | Sortie | Quand l'utiliser |
|---|---|---|---|
| Standard | 0,50 $ / M de jetons | 2,50 $ / M de jetons | Par défaut pour la plupart des travaux d'agent ; meilleure efficacité des coûts |
| Rapide | 3,00 $ / M de jetons | 15,00 $ / M de jetons | Travaux sensibles à la latence ; même intelligence, temps d'attente réduit |
La variante rapide vous offre la même qualité de modèle avec une latence plus faible, et c'est le défaut du produit. Son prix reste inférieur aux niveaux rapides des autres modèles de pointe.
La facturation dépend de votre abonnement :
- Les abonnements individuels (Pro et similaires) incluent un pool d'utilisation Composer autonome avec une utilisation généreuse, de sorte que la plupart des développeurs solos ne toucheront pas au tarif par jeton au quotidien.
- Les abonnements Équipe et Entreprise sont facturés directement au tarif de l'API.
- Promo de lancement : Cursor a doublé l'utilisation de Composer 2.5 pendant la première semaine après le lancement, de sorte que les premiers utilisateurs bénéficient d'un temps supplémentaire pour le tester.
Pour une ventilation plus complète de la façon dont Cursor mesure les modèles, consultez le guide de tarification de Cursor Composer. Si vous essayez de l'exécuter sans dépenser, le guide Composer gratuit couvre la voie de l'utilisation incluse.
Comment accéder à Cursor Composer 2.5
Accéder au modèle prend environ une minute.
- Mettez à jour Cursor. Composer 2.5 nécessite une version récente. Ouvrez Cursor, vérifiez les mises à jour (menu Cursor sur macOS, menu Aide ailleurs), et redémarrez si une mise à jour s'installe.
- Connectez-vous à un abonnement qui l'inclut. Les abonnements Pro et Business incluent l'utilisation de Composer. Un compte gratuit peut toujours l'essayer via les allocations incluses, mais une utilisation intensive nécessite un abonnement payant.
- Ouvrez le sélecteur de modèle. Démarrez une conversation ou une session d'agent, puis ouvrez le menu déroulant du modèle. Choisissez
composer-2.5. Vous verrez généralement la variante rapide sélectionnée par défaut. - Confirmez le mode agent. Composer est conçu pour le travail d'agent, utilisez donc le mode Agent plutôt que la simple conversation pour obtenir des modifications de fichiers, un accès au terminal et l'utilisation d'outils.
C'est toute la configuration. Le modèle a accès à tous les outils d'agent exposés par Cursor : lecture et modification de fichiers, exécution de commandes de terminal et appel d'outils. Les documents officiels du modèle Composer 2.5 listent les défauts actuels si Cursor les modifie.
Si vous avez déjà utilisé Cursor mais pas son agent, la vue d'ensemble de Cursor 2.0 est une bonne introduction au fonctionnement de l'interface de l'agent.
Comment utiliser Composer 2.5 efficacement
L'accès est facile. Obtenir un bon résultat demande un peu de technique.
Laissez-le exécuter des tâches longues. La principale amélioration de Composer 2.5 est la performance soutenue. Donnez-lui une tâche réelle avec un état final clair ("ajouter la pagination au point de terminaison des commandes et mettre à jour les tests") au lieu de micro-gérer une ligne à la fois. Il est entraîné à continuer jusqu'à ce que les tests passent.
Écrivez la condition de succès dans l'invite. Le modèle a été entraîné contre la vérification des tests. Si vous lui dites comment vous jugerez qu'il est terminé ("tous les tests existants restent verts et le nouveau point de terminaison renvoie 422 pour une entrée non valide"), il s'auto-corrige vers cet objectif.
Choisissez la bonne variante. Utilisez la variante standard pour les tâches par lots sensibles aux coûts et la variante rapide lorsque vous itérez en direct et attendez chaque réponse. La qualité est la même ; vous échangez seulement la latence contre le coût.
Gardez son contexte honnête. Les modèles agentiques sont puissants, mais ils devinent toujours quand ils ne connaissent pas la vraie forme d'une API. C'est le mode d'échec qu'il faut contourner, et c'est là que vos outils API sont importants.
Composer 2.5 et votre flux de travail API
La plupart des tâches de codage réelles touchent une API. Demandez à Composer 2.5 de "écrire un client pour notre service de paiement" et il produira un code d'apparence propre ; le risque est que les points de terminaison, les champs et l'authentification correspondent à ce que le modèle suppose plutôt qu'à ce que votre service expose réellement. Un code faux mais confiant est plus lent qu'aucun code.
Deux pratiques y remédient :
Premièrement, fournissez au modèle votre vraie spécification API au lieu de le laisser deviner. Le serveur MCP Apidog connecte votre spécification API Apidog directement à Cursor, de sorte que Composer 2.5 génère du code de requête, des types et des tests par rapport à votre schéma réel. Si vous exécutez également d'autres agents, le tour d'horizon des meilleurs serveurs MCP pour Cursor couvre les options complémentaires.
Deuxièmement, vérifiez les appels générés avant qu'ils n'atteignent la branche d'un coéquipier. Insérez les points de terminaison écrits par Composer 2.5 dans Apidog, envoyez de vraies requêtes, vérifiez les codes de statut et les formes de réponse, et transformez les appels fonctionnels en tests automatisés et en serveurs simulés. Le modèle écrit le premier brouillon ; Apidog confirme qu'il se comporte correctement. Cette boucle, générer par rapport à une spécification réelle, puis tester par rapport à un serveur réel, est ce qui empêche la vitesse de l'agent de se transformer en dette de débogage.
Composer 2.5 vs la concurrence
Petite orientation si vous choisissez un outil principal au quotidien :
- vs Opus 4.7 : Quasi-identique sur SWE-bench Multilingual et CursorBench, beaucoup moins cher par tâche. Opus est toujours en tête au sommet absolu du réglage max de CursorBench.
- vs GPT-5.5 : Composer 2.5 gagne sur SWE-bench Multilingual et CursorBench ; GPT-5.5 mène clairement sur Terminal-Bench 2.0.
- vs Claude Code : Forme d'outil différente. Composer 2.5 vit dans l'éditeur Cursor ; Claude Code est un agent de terminal. La comparaison Claude Code vs Cursor explique lequel convient à quel flux de travail.
- vs GitHub Copilot : Copilot est le plus puissant en tant qu'autocomplétion en ligne ; Composer 2.5 est conçu pour les tâches d'agent multi-fichiers. Le guide Cursor vs GitHub Copilot approfondit le sujet.
Cursor a également déclaré qu'il entraînait un modèle beaucoup plus grand avec xAI en utilisant environ dix fois plus de puissance de calcul, donc 2.5 est un point de contrôle sur une courbe plus raide, pas le plafond.
Questions fréquemment posées
Composer 2.5 est-il gratuit ? Il n'y a pas de niveau entièrement gratuit, mais les abonnements individuels incluent un pool d'utilisation Composer qui couvre le travail quotidien normal, et Cursor a doublé l'utilisation pendant la semaine de lancement. Le guide Composer gratuit explique jusqu'où va l'allocation incluse.
Composer 2.5 est-il meilleur que Composer 2 ? Oui, de manière mesurable. SWE-bench Multilingual est passé de 73,7 % à 79,8 %, et le modèle maintient le contexte beaucoup mieux sur les tâches longues. Le guide Composer 2 est la base sur laquelle il s'est amélioré.
Sur quel modèle Composer 2.5 est-il basé ? Il est construit sur le point de contrôle open-source Kimi K2.5 de Moonshot, puis fortement post-entraîné par Cursor avec l'apprentissage par renforcement et des tâches synthétiques.
Quelle variante dois-je choisir, standard ou rapide ? Même intelligence, latence et prix différents. Utilisez la variante standard pour le travail par lots rentable, rapide lorsque vous itérez en direct.
Composer 2.5 fonctionne-t-il avec les spécifications API et MCP ? Oui. Il prend en charge l'ensemble complet des outils d'agent de Cursor, y compris MCP. Connectez votre spécification API via le serveur MCP Apidog afin qu'il code par rapport à votre schéma réel.
En résumé
Composer 2.5 est le signe le plus clair à ce jour que "le codage de qualité de pointe" et "cher" se dissocient. Vous obtenez des résultats de niveau Opus 4.7 sur de vraies tâches logicielles pour bien moins d'un dollar par tâche, au sein d'un éditeur conçu pour le travail d'agent. Mettez à jour Cursor, choisissez composer-2.5 dans le menu déroulant du modèle, et donnez-lui de vraies tâches en plusieurs étapes au lieu de simples lignes.
Associez-le à une boucle de vérification rigoureuse et la vitesse se démultiplie réellement. Générez du code API par rapport à votre spécification réelle, puis Téléchargez Apidog pour envoyer des requêtes en direct, confirmer les réponses et verrouiller les appels fonctionnels dans des tests automatisés et des maquettes. Le code rapide que vous avez vérifié est meilleur que le code rapide que vous devez déboguer.