Combien coûte Cursor Composer ?

Cursor Composer est un nouveau modèle de codage de pointe, intégré à Cursor 2.0, qui offre une génération de code automatisée et beaucoup plus rapide pour les flux de travail complexes impliquant plusieurs fichiers. L'accès à Composer est régi par les abonnements à plusieurs niveaux existants de Cursor, auxquels s'ajoute une facturation par jetons lorsque vous atteignez votre quota ou utilisez le routage « Auto » de Cursor. Le coût se compose donc d'un abonnement fixe et de frais de jetons calculés à l'usage. Vous trouverez ci-dessous une description complète et pratique (fonctionnalités, avantages, tarification, exemples concrets et comparaisons avec la concurrence) pour vous permettre d'estimer les coûts réels et de déterminer si Composer est pertinent pour votre équipe.

Qu'est-ce que Cursor Composer ?

Composer est le nouveau modèle de pointe de Cursor, introduit dans Cursor 2.0. Il a été conçu et optimisé spécifiquement pour les flux de travail d'ingénierie logicielle et les tâches de codage multi-étapes. Selon l'annonce de Cursor, Composer offre des performances de codage de niveau supérieur tout en étant optimisé pour une faible latence et une itération rapide. Cursor affirme que la plupart des échanges conversationnels s'effectuent en moins de 30 secondes en pratique et revendique un débit de génération environ quatre fois supérieur à celui de modèles aux performances similaires lors de ses tests internes. Composer a été entraîné avec un accès à la recherche et aux outils à l'échelle du code source, ce qui lui permet de raisonner et d'effectuer des modifications sur des projets de grande envergure.

Où se situe Composer au sein du produit Cursor ?

Composer n'est pas une application distincte à acheter séparément ; il est proposé comme option de modèle au sein du produit Cursor (version bureau et web) et est géré par le routeur de modèles de Cursor (Auto). L'accès au niveau du modèle dépend de votre abonnement Cursor et de la facturation de l'utilisation au-delà de votre forfait. La documentation des modèles de Cursor mentionne Composer parmi les modèles disponibles, et l'entreprise propose différents niveaux d'abonnement ainsi qu'une facturation à l'usage par jetons.

Les modifications apportées par Cursor à mi-2025 aux pools d'utilisation et aux systèmes de crédit illustrent cette tendance : plutôt qu'une utilisation véritablement illimitée des modèles premium, Cursor fournit des quotas de forfait (et des choix automatiques), puis facture l'utilisation supplémentaire aux tarifs API/jetons.

Principales caractéristiques et avantages de Composer

Composer vise à améliorer la productivité des développeurs pour les tâches d'ingénierie complexes. Ses principaux atouts :

• Raisonnement en code agentique : Composer prend en charge les flux de travail en plusieurs étapes (par exemple, comprendre un bug, effectuer une recherche dans un dépôt, modifier plusieurs fichiers, exécuter des tests et itérer). Cela le rend plus adapté que les complétions ponctuelles pour les tâches d'ingénierie complexes.
• Vitesse / faible latence : Cursor rapporte que Composer est nettement plus rapide en termes de débit de génération que les modèles comparables et que les tours interactifs typiques se terminent rapidement, permettant des boucles d'itération plus rapides.
• Intégration étroite du code source : Composer a été entraîné avec l'accès à l'ensemble d'outils de récupération et d'édition de Cursor ainsi qu'à l'indexation de la base de code, ce qui améliore sa capacité à travailler avec de grands référentiels et à maintenir le contexte entre les fichiers.
• Modes et outils de l'agent : Composer est conçu pour fonctionner avec les modes d'agent de Cursor et le protocole MCP (Model Context Protocol), ce qui lui permet d'appeler des outils spécialisés, de lire le code indexé et d'éviter de devoir réexpliquer la structure du projet. Cela réduit l'utilisation répétitive de jetons dans de nombreux flux de travail.

Pourquoi c'est important : Pour les équipes effectuant des modifications de code approfondies et des refactorisations multi-fichiers, Composer peut réduire l'itération manuelle et le changement de contexte, mais comme il est actif et peut effectuer plus de travail de calcul par requête, l'utilisation des jetons par requête a tendance à être plus élevée que les modèles de complétion simples (ce qui alimente la discussion sur les coûts mesurés ci-dessous).

Comment Composer a-t-il été construit ?

Architecture et approche de formation

Composer est décrit comme un modèle MoE optimisé par apprentissage par renforcement et doté d'un pipeline d'entraînement personnalisé à grande échelle. Principaux éléments mis en avant par Cursor :

• Mélange d'experts (MoE) Conception permettant d'adapter efficacement la capacité aux tâches de code à contexte long.
• Apprentissage par renforcement (RL) avec des signaux de récompense adaptés aux comportements actifs utiles en génie logiciel : rédaction de plans, utilisation de la recherche, édition de code, rédaction de tests et optimisation de l’utilisation des outils parallèles.
• Formation à l'utilisation des outils: pendant l'entraînement, Composer avait accès à un ensemble d'outils (lecture/écriture de fichiers, recherche sémantique, terminal, grep) et a donc appris à appeler les outils au besoin et à intégrer les résultats.
• Infrastructure personnaliséeCursor utilise des pipelines PyTorch + Ray, des noyaux MXFP8 MoE et de vastes clusters de machines virtuelles pour permettre un apprentissage par renforcement asynchrone et à grande échelle. Les choix d'infrastructure (entraînement à faible précision, parallélisme d'experts) visent à réduire les coûts de communication et à minimiser la latence d'inférence.

Pourquoi moE + RL est important pour le code

L'édition de code exige un raisonnement précis et itératif sur de vastes dépôts. L'apprentissage multi-éléments (MoE) confère au modèle une capacité épisodique (de nombreux paramètres disponibles de manière sélective), tandis que l'apprentissage par renforcement (RL) optimise les comportements (éviter les hallucinations, exécuter des tests, proposer des différences minimales). L'entraînement avec l'ensemble d'outils de l'agent signifie que Composer n'est pas affiné uniquement sur la prédiction du jeton suivant ; il a appris à utiliser les outils disponibles dans l'environnement de développement de Cursor. C'est pourquoi Cursor positionne Composer comme un modèle « agentique » plutôt que comme un simple modèle de complétion.

Comment sont tarifés les abonnements Cursor pour Composer ?

La tarification de Cursor combine niveaux d'abonnement (forfaits mensuels) avec frais basés sur l'utilisation (Jetons, cache et certains frais d'agent/d'outil). Les différents niveaux d'abonnement incluent des fonctionnalités de base et une utilisation prioritaire ; l'utilisation intensive ou premium est facturée en supplément. Vous trouverez ci-dessous les tarifs publics et une description détaillée de chaque formule.

niveaux individuels (personnels)

• Loisir (gratuit) : Version d'entrée de gamme, requêtes d'agent/saisie semi-automatique limitées ; inclut une courte période d'essai Pro. Idéal pour des tests légers.
• Pro — 20 $/mois (individuel) : Tout ce qui est inclus dans Hobby, plus une utilisation étendue des agents, la complétion automatique illimitée des onglets, les agents en arrière-plan et un nombre maximal de fenêtres contextuelles. C'est le point de départ idéal pour les développeurs individuels qui souhaitent bénéficier des fonctionnalités de Composer.
• Pro+ — 60 $/mois (individuel, recommandé pour les utilisateurs avancés) : L'utilisation incluse est plus importante sur les modèles premium. Le déploiement des tarifs de Cursor en juin 2025 a précisé que les forfaits Pro incluent un ensemble de crédits de modèles (pour une utilisation des « modèles de pointe ») et que l'utilisation supplémentaire peut être achetée à un tarif majoré ou par facturation au jeton.
• Ultra — 200 $ / mois : pour les personnes corpulentes nécessitant une utilisation des modèles inclus nettement plus grands et un accès prioritaire.

Équipe / Entreprise

Équipes — 40 $ / utilisateur / mois : Cette version ajoute la facturation centralisée, l'analyse de l'utilisation, le contrôle d'accès basé sur les rôles et l'authentification unique (SSO). Les équipes plus importantes peuvent également opter pour la version Entreprise (tarification personnalisée) qui inclut la mutualisation des utilisateurs, la facturation par facture/bon de commande, SCIM, les journaux d'audit et l'assistance prioritaire.

Tarification par jetons pour Cursor Composer

Cursor combine des forfaits par utilisateur avec une facturation au jeton pour les requêtes premium ou effectuées par des agents. Il existe deux contextes de facturation liés mais distincts à comprendre :

1. taux de jetons en mode Auto / Max (Sélection dynamique « Auto » du curseur ou compartiments de facturation Max/Auto).
2. Liste des modèles / Prix direct des modèles (Si vous sélectionnez directement un modèle comme Composer, les API de liste de modèles ont des taux de jetons par modèle).

Ces différents modes modifient les taux effectifs de jetons d'entrée/sortie qui apparaîtront sur votre facture. Vous trouverez ci-dessous les valeurs de référence publiées par Cursor dans sa documentation et ses pages de modèles ; ce sont les valeurs les plus importantes pour le calcul des coûts.

Auto / Max

Lorsque vous dépassez les limites de votre forfait (ou si vous utilisez explicitement la fonction Auto pour accéder aux modèles premium), Cursor facture l'utilisation des modèles sur un par jeton base. Les taux les plus fréquemment cités pour Cursor Voiture Les routeurs (qui sélectionnent un modèle haut de gamme à la demande) sont :

• Écriture en entrée + cache : 1.25 $ par 1,000,000 XNUMX XNUMX de jetons
• Sortie (génération) : 6.00 $ par 1,000,000 XNUMX XNUMX de jetons
• Lecture du cache : 0.25 $ par 1,000,000 XNUMX XNUMX de jetons

Ces tarifs ont été documentés dans les documents de compte/tarification de Cursor décrivant la facturation automatique et constituent la base des coûts d'exploitation de Composer lorsque l'utilisation de Composer est facturée via Auto ou lorsque vous sélectionnez directement l'utilisation du modèle facturée aux tarifs de l'API.

Prix ​​catalogue des compositeurs et des modèles

La liste des modèles de Cursor affiche les prix par modèle. Pour certains modèles premium de Cursor et Composer, les prix indiqués dans la liste des modèles sont les suivants : Entrée : 1.25  / 1 M ; Sortie : 10.00  / 1 MEn pratique, cela signifie que si vous choisissez explicitement Composer comme modèle plutôt que d'exécuter Auto, le taux de jetons de sortie que vous encourez pourrait être supérieur au taux de sortie de 6 $ d'Auto.

Pourquoi les jetons d'entrée et de sortie diffèrent-ils ?

• Jetons d'entrée Il s'agit des jetons que vous envoyez (invites, instructions, extraits de code, contexte de fichier). Cursor facture leur écriture dans le système (et parfois leur mise en cache).
• Jetons de sortie Il s'agit des résultats générés par le modèle (modifications de code, suggestions, différences, etc.). La génération de ces résultats est plus coûteuse car elle consomme davantage de ressources de calcul. Les chiffres publiés par Cursor reflètent ces coûts relatifs.

Comparaison de Cursor Composer avec ses concurrents

Pour évaluer le rapport qualité-prix, il est utile de comparer le coût unitaire de Composer à celui d'autres services d'IA largement utilisés par les développeurs. Notez que les capacités du modèle, la latence, l'intégration et les fonctionnalités incluses dans l'abonnement sont également importantes ; le prix, à lui seul, ne suffit pas.

GitHub Copilot (niveaux individuels)

GitHub Copilot est principalement facturé par utilisateur avec différents niveaux (Gratuit, Pro à environ 10 $/mois, Pro+ et Business plus onéreux). Copilot inclut un certain nombre de requêtes « premium » par mois et facture les requêtes premium supplémentaires (options disponibles par requête). Copilot propose des modèles (dont Google, Anthropic et OpenAI dans certains abonnements) et est vendu comme un SaaS par développeur. Pour de nombreux développeurs indépendants, le tarif tout compris par utilisateur de Copilot peut s'avérer plus simple et plus économique pour les tâches courantes ; en revanche, pour les tâches complexes nécessitant plusieurs étapes, un modèle de facturation à l'utilisation peut être plus transparent.

OpenAI (API / modèles avancés)

Les modèles haut de gamme d'OpenAI (série GPT-5 et variantes premium) présentent des coûts par jeton différents, pouvant être supérieurs au tarif Composer de Cursor pour certains modèles professionnels. OpenAI propose également plusieurs niveaux de performance (ainsi que des remises pour le traitement par lots ou la mise en cache) qui influent sur le coût réel. Lors d'une comparaison, il convient de prendre en compte la latence, la précision des tâches de programmation et la valeur ajoutée de l'intégration de l'éditeur de Cursor (qui peut compenser un écart de coût par jeton).

Lequel est le moins cher en pratique ?

• Petites saisies fréquentes / saisies automatiques : Un logiciel SaaS par utilisateur (Copilot) est souvent la solution la moins chère et la plus simple.
• Tâches volumineuses multi-fichiers et multi-agents : Les modèles à jetons (Composer via Cursor Auto ou Anthropic/OpenAI directement) offrent flexibilité/qualité mais coûtent plus cher par requête importante ; une modélisation précise de l'utilisation des jetons est essentielle.

Conclusion — Composer est-il « cher » ?

Le compositeur est pas Présenté comme un élément unique et forfaitaire, il fait en réalité partie d'un système hybride. Pour une utilisation interactive légère à modérée, un 20 $/mois Pro L'utilisation du mode automatique avec l'abonnement peut limiter vos coûts (quelques dizaines de dollars par mois). Pour les charges de travail importantes et parallèles impliquant de nombreux fichiers volumineux, Composer peut générer des centaines, voire des milliers de requêtes par mois, car le coût des jetons de sortie et la concurrence augmentent considérablement. Comparé aux solutions par abonnement (comme GitHub Copilot), le Composer de Cursor privilégie des performances accrues, une gestion optimisée des agents et une meilleure prise en compte des dépôts, au détriment d'un coût d'inférence marginal plus élevé.

Si vos objectifs sont l'automatisation multi-agents, les refactorisations à l'échelle du dépôt ou des cycles d'itération plus courts permettant de gagner du temps d'ingénierie, la rapidité et les outils de Composer peuvent offrir un excellent retour sur investissement.

Comment utiliser CometAPI dans Cursor ? (étape par étape)

En résumé : CometAPI est une passerelle d'agrégation de modèles (un point d'accès unique pouvant servir de proxy pour de nombreux fournisseurs de modèles). Pour l'utiliser dans Cursor, vous devez vous inscrire auprès de CometAPI, obtenir une clé API et un identifiant de modèle, puis ajouter cette clé et ce point d'accès dans les paramètres des modèles de Cursor en tant que fournisseur personnalisé (en remplaçant l'URL de base) et sélectionner le modèle CometAPI en mode Composer/Agent.

CometAPI a également conçu un modèle de codage propriétaire basé sur Claude, spécifiquement pour le curseur : cometapi-sonnet-4-5-20250929-thinking et cometapi-opus-4-1-20250805-thinking et ainsi de suite

Étape A — Obtenez vos identifiants CometAPI

1. Inscrivez-vous sur CometAPI et créer une clé API depuis leur tableau de bord. Gardez la clé secrète (traitez-la comme n'importe quel jeton porteur).
2. Créez/copiez une clé API et notez le nom/l'identifiant du modèle que vous souhaitez utiliser (par exemple, claude-sonnet-4.5 ou un autre modèle de fournisseur disponible via CometAPI).Documentation/guides de CometAPI Décrire le processus et lister les noms des modèles pris en charge.

Étape B — Ajouter CometAPI comme modèle/fournisseur personnalisé dans Cursor

1. Ouvrir le curseur → Paramètres → Modèles (ou Paramètres → Clés API).
2. Si le curseur affiche un « Ajouter un modèle personnalisé » or « Remplacer l'URL de base OpenAI » option, utilisez-la :

• URL de base / Point de terminaison: collez l'URL de base compatible avec OpenAI de CometAPI (CometAPI indiquera si elle expose une openai/v1 point de terminaison de style ou point de terminaison spécifique au fournisseur). (Exemple : https://api.cometapi.com/v1 — utilisez l'URL réelle de la documentation CometAPI.)
• clé API: collez votre clé CometAPI dans le champ clé API.
• Nom du modèle: ajoutez l'identifiant du modèle exactement comme dans les documents CometAPI (par exemple, claude-sonnet-4.5 or composer-like-model).

3. Vérifier La connexion est établie si Cursor propose un bouton « Vérifier » / « Tester ». Le mécanisme de modèle personnalisé de Cursor exige généralement que le fournisseur soit compatible avec OpenAI (ou que Cursor accepte une URL de base et une clé). Les guides de la communauté présentent le même schéma (URL de base personnalisée → clé fournie → vérification).

Si vous souhaitez connaître plus de conseils, de guides et d'actualités sur l'IA, suivez-nous sur VK, X et Discord!

Voir aussi
Cursor 2.0 et Composer : comment une refonte multi-agents a bouleversé le codage de l’IA.