Cursor Composer 2.5 : Qu'est-ce que c'est, comment l'utiliser et comment y accéder

Cursor a lancé Composer 2.5 le 18 mai 2026. Le point important pour les développeurs : un modèle de codage qui se rapproche d’Opus 4.7 et GPT-5.5 sur de vrais benchmarks logiciels, avec un coût inférieur à un dollar par tâche.

Essayez Apidog aujourd’hui

Ce guide explique comment utiliser Composer 2.5 dans Cursor : ce que c’est, comment l’activer, quand choisir la variante standard ou rapide, et comment l’intégrer à un workflow API avec Apidog pour éviter de générer du code basé sur des suppositions.

Qu’est-ce que Cursor Composer 2.5 ?

Composer 2.5 est le modèle de codage agentique de Cursor. Il peut planifier une tâche, modifier des fichiers, exécuter des commandes de terminal et vérifier son travail directement dans l’éditeur Cursor.

Il succède à Composer 2. La différence pratique : Composer 2 était surtout un partenaire rapide pour l’autocomplétion et les petites tâches, tandis que Composer 2.5 vise les tâches longues multi-fichiers.

Points clés :

• Il est construit sur le checkpoint open-source Moonshot Kimi K2.5, une base d’environ un billion de paramètres.
• Cursor indique avoir consacré environ 85 % du budget de calcul d’entraînement à la post-formation et à l’apprentissage par renforcement.
• Le modèle a été entraîné sur 25 fois plus de tâches synthétiques que Composer 2, notamment des exercices où une fonctionnalité est supprimée puis reconstruite jusqu’à ce que les tests passent.

En pratique, Composer 2.5 maintient mieux le contexte sur les longues sessions. Il suit plus correctement les instructions complexes et évalue mieux la quantité de travail nécessaire, sans s’arrêter trop tôt ni sur-implémenter.

Pour le contexte sur la génération précédente, consultez le guide Composer 2.

Ce qui a changé sous le capot

Trois changements expliquent l’amélioration :

1. RL ciblée avec feedback textuel
   
   Cursor ne se limite pas à une récompense finale. Il ajoute un court indice textuel décrivant la correction attendue, l’insère dans le contexte local, puis distille ce comportement dans le modèle. Cela aide notamment le modèle à éviter d’appeler des outils indisponibles.

2. Données synthétiques à grande échelle
   
   L’augmentation de 25x des tâches synthétiques donne au modèle plus d’exemples réalistes de travail sur dépôt, validés par des tests.

3. Optimiseur Muon sharded avec HSDP dual-mesh
   
   C’est une partie infrastructure, pas une fonctionnalité utilisateur. Elle a permis à Cursor d’entraîner un modèle de 1T de paramètres avec une étape d’optimisation de 0,2 seconde, donc d’itérer plus vite sur la qualité.

Vous n’avez pas besoin de mémoriser ces détails pour l’utiliser, mais ils expliquent pourquoi Composer 2.5 est plus stable sur les tâches longues que les agents précédents.

Benchmarks de Composer 2.5

Cursor compare Composer 2.5 à Opus 4.7 et GPT-5.5 sur trois suites :

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

Sur SWE-bench Multilingual, Composer 2.5 atteint 79,8 %, à moins d’un point d’Opus 4.7 et devant GPT-5.5. C’est aussi une progression nette par rapport aux 73,7 % de Composer 2.

Sur CursorBench, la suite de tâches interne de Cursor, Composer 2.5 dépasse les paramètres par défaut d’Opus 4.7.

Le point faible reste Terminal-Bench 2.0, où GPT-5.5 mène avec 82,7 %. Si votre workflow dépend surtout de longues séquences terminal, ce benchmark mérite d’être pris en compte.

Le facteur décisif est le coût par tâche. Cursor indique environ 63 % sur CursorBench pour un coût moyen inférieur à un dollar par tâche, alors qu’Opus 4.7 et GPT-5.5 coûtent plusieurs dollars par tâche pour des résultats similaires ou inférieurs. Une analyse de The Decoder arrive à la même conclusion : une qualité proche des meilleurs modèles à une fraction du prix.

Conclusion : Composer 2.5 n’est pas premier sur tous les benchmarks, mais il offre un compromis qualité/prix très intéressant pour les tâches de développement quotidiennes.

Combien coûte Composer 2.5 ?

Cursor propose deux variantes :

Variante	Entrée	Sortie	Quand l’utiliser
Standard	0,50 $ / M de jetons	2,50 $ / M de jetons	Tâches agentiques courantes, meilleure efficacité coût
Rapide	3,00 $ / M de jetons	15,00 $ / M de jetons	Itération en direct, latence plus faible

La variante rapide fournit la même qualité de modèle avec une latence réduite. Elle est généralement sélectionnée par défaut.

Côté facturation :

• Les abonnements individuels comme Pro incluent un pool d’utilisation Composer.
• Les abonnements Équipe et Entreprise sont facturés au tarif API.
• Pendant la semaine de lancement, Cursor a doublé l’utilisation de Composer 2.5 pour faciliter les premiers tests.

Pour plus de détails sur la tarification, consultez le guide de tarification Cursor Composer. Pour tester sans payer immédiatement, le guide Composer gratuit couvre l’utilisation incluse.

Comment accéder à Cursor Composer 2.5

Voici le chemin le plus direct :

1. Mettez Cursor à jour
   
   Ouvrez Cursor, vérifiez les mises à jour, puis redémarrez l’application si nécessaire.

2. Connectez-vous avec un abonnement compatible
   
   Les abonnements Pro et Business incluent l’utilisation de Composer. Un compte gratuit peut tester le modèle via les allocations incluses, mais un usage intensif nécessite un abonnement payant.

3. Ouvrez le sélecteur de modèle
   
   Lancez une conversation ou une session agent, puis ouvrez le menu de sélection du modèle.

4. Choisissez composer-2.5
   
   La variante rapide est souvent sélectionnée par défaut.

5. Utilisez le mode Agent
   
   Composer 2.5 est conçu pour modifier des fichiers, lancer des commandes et utiliser des outils. Utilisez donc le mode Agent plutôt qu’une simple discussion.

Le modèle peut lire et modifier des fichiers, exécuter des commandes terminal et appeler les outils exposés par Cursor. Les documents officiels de Composer 2.5 listent les paramètres actuels.

Si vous débutez avec l’agent Cursor, la vue d’ensemble de Cursor 2.0 explique le fonctionnement de l’interface.

Comment utiliser Composer 2.5 efficacement

L’accès est simple. La qualité du résultat dépend surtout de la façon dont vous formulez la tâche.

Donnez-lui une vraie tâche de bout en bout

Composer 2.5 est plus utile sur des tâches multi-étapes que sur des micro-demandes ligne par ligne.

Exemple :

Ajoute la pagination au endpoint GET /orders.

Contraintes :
- paramètres query : page et pageSize
- page commence à 1
- pageSize max = 100
- retourne 422 si page ou pageSize est invalide
- mets à jour les tests existants
- ajoute des tests pour les cas invalides
- tous les tests doivent passer

Ce type d’invite donne au modèle un objectif clair, des contraintes et une condition de validation.

Définissez la condition de succès

Composer 2.5 a été entraîné à travailler contre des vérifications. Indiquez donc comment vous validerez la tâche.

Exemple :

La tâche est terminée uniquement si :
1. tous les tests existants passent ;
2. les nouveaux tests couvrent les cas valides et invalides ;
3. le endpoint retourne 422 pour une entrée invalide ;
4. aucun changement non lié à la pagination n’est introduit.

Cela réduit les implémentations trop larges et aide le modèle à s’auto-corriger.

Choisissez la bonne variante

Utilisez :

• Standard pour les tâches longues, batch ou sensibles au coût.
• Rapide quand vous itérez en direct et attendez chaque réponse.

L’intelligence est la même. Vous échangez surtout latence contre coût.

Gardez le contexte fiable

Les agents savent modifier beaucoup de code, mais ils peuvent toujours deviner lorsqu’ils ne connaissent pas la forme exacte d’une API, d’un schéma ou d’un contrat métier.

C’est particulièrement important pour le code API.

Composer 2.5 et votre workflow API

Beaucoup de tâches réelles touchent une API : clients HTTP, SDK internes, tests d’intégration, mocks, validation de payloads, gestion d’erreurs.

Si vous demandez simplement :

Écris un client TypeScript pour notre service de paiement.

Composer 2.5 peut générer un code propre, mais il risque d’inventer :

• des endpoints ;
• des champs ;
• des codes d’erreur ;
• des headers d’authentification ;
• des formats de réponse.

Le bon workflow consiste à connecter le modèle à votre spécification réelle, puis à tester les appels générés.

Étape 1 : fournir la vraie spécification API

Le serveur MCP Apidog permet de connecter votre spécification API Apidog à Cursor.

Objectif : faire générer à Composer 2.5 du code de requête, des types et des tests contre votre vrai schéma, pas contre une estimation.

Si vous utilisez plusieurs agents, le guide des meilleurs serveurs MCP pour Cursor présente aussi des options complémentaires.

Étape 2 : vérifier les appels générés

Une fois le code généré, validez-le dans Apidog :

1. copiez ou importez les endpoints concernés ;
2. envoyez de vraies requêtes ;
3. vérifiez les codes de statut ;
4. confirmez la forme des réponses ;
5. transformez les appels corrects en tests automatisés ou en serveurs simulés.

Le modèle produit le premier brouillon. Apidog vérifie que ce brouillon correspond au comportement réel de l’API.

Cette boucle est la plus importante :

spécification réelle → génération par Composer 2.5 → test dans Apidog → automatisation

Elle évite de convertir la vitesse de génération en dette de débogage.

Composer 2.5 vs la concurrence

Résumé pratique :

• vs Opus 4.7
  
  Composer 2.5 est proche sur SWE-bench Multilingual et CursorBench, avec un coût par tâche beaucoup plus bas. Opus reste devant sur le score maximal de CursorBench.

• vs GPT-5.5
  
  Composer 2.5 gagne sur SWE-bench Multilingual et CursorBench. GPT-5.5 mène nettement sur Terminal-Bench 2.0.

• vs Claude Code
  
  Ce ne sont pas les mêmes workflows. Composer 2.5 vit dans l’éditeur Cursor ; Claude Code est un agent de terminal. La comparaison Claude Code vs Cursor détaille les cas d’usage.

• vs GitHub Copilot
  
  Copilot est surtout puissant pour l’autocomplétion inline. Composer 2.5 est pensé pour les tâches agentiques multi-fichiers. Le guide Cursor vs GitHub Copilot approfondit la comparaison.

Cursor a aussi indiqué entraîner un modèle beaucoup plus grand avec xAI, avec environ dix fois plus de puissance de calcul. Composer 2.5 semble donc être une étape intermédiaire, pas un plafond.

Questions fréquentes

Composer 2.5 est-il gratuit ?

Il n’existe pas de niveau entièrement gratuit dédié à Composer 2.5. Les abonnements individuels incluent toutefois un pool d’utilisation Composer, et Cursor a doublé l’utilisation pendant la semaine de lancement.

Le guide Composer gratuit explique l’allocation incluse.

Composer 2.5 est-il meilleur que Composer 2 ?

Oui. SWE-bench Multilingual passe de 73,7 % à 79,8 %, et Composer 2.5 maintient mieux le contexte sur les tâches longues.

Le guide Composer 2 donne le point de comparaison.

Sur quel modèle Composer 2.5 est-il basé ?

Composer 2.5 est construit sur le checkpoint open-source Kimi K2.5 de Moonshot, puis fortement post-entraîné par Cursor avec apprentissage par renforcement et tâches synthétiques.

Quelle variante choisir : standard ou rapide ?

Même intelligence, latence différente.

• Choisissez standard pour réduire les coûts.
• Choisissez rapide quand vous travaillez en interaction directe avec l’agent.

Composer 2.5 fonctionne-t-il avec MCP ?

Oui. Il prend en charge les outils agentiques de Cursor, dont MCP. Vous pouvez connecter votre spécification API via le serveur MCP Apidog pour générer du code aligné sur votre schéma réel.

En résumé

Composer 2.5 rend le codage agentique plus intéressant économiquement : des performances proches d’Opus 4.7 sur de vraies tâches logicielles, avec un coût par tâche beaucoup plus bas.

Pour l’utiliser :

1. mettez Cursor à jour ;
2. sélectionnez composer-2.5 dans le menu des modèles ;
3. utilisez le mode Agent ;
4. donnez-lui des tâches complètes avec critères de succès ;
5. vérifiez systématiquement le code généré.

Pour les APIs, ne laissez pas le modèle deviner. Générez le code contre votre spécification réelle, puis téléchargez Apidog pour envoyer des requêtes, confirmer les réponses et convertir les appels valides en tests ou en mocks.