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

Cursor, la plateforme d'éditeur de code et d'agent basée sur l'IA, a été lancée Curseur 2.0 le 29 octobre 2025 — une mise à jour majeure qui associe un modèle de codage spécialement conçu (nommé CompositeurCette nouvelle version propose une interface repensée et centrée sur l'agent, ainsi qu'une série d'améliorations de la plateforme visant à rendre le développement agentiel plus rapide, plus sûr et plus collaboratif. L'entreprise présente cette mise à jour comme un tournant stratégique : elle abandonne l'utilisation de modèles tiers au profit de son propre modèle pré-entraîné et d'outils optimisés de bout en bout pour le développement de logiciels « agentiels ».

Ci-dessous : un aperçu détaillé des nouveautés de Cursor 2.0, de la conception de Composer, des modifications concrètes apportées au journal des modifications et, surtout, — Ce qui a véritablement surpris le monde de l'IA pour les développeurs à propos de cette version.

Qu'est-ce qu'un curseur (et pourquoi les développeurs devraient-ils y prêter attention) ?

Cursor est un éditeur et une plateforme conçus dès le départ pour permettre aux développeurs d'utiliser l'IA à nos agents Cursor est conçu comme un outil de collaboration à part entière au sein du flux de travail de développement. Il combine un éditeur local/distant, l'orchestration d'agents, l'intégration d'outils (terminaux, navigateur, recherche sémantique) et un flux de travail centré sur les modèles, permettant ainsi aux agents de lire, planifier, modifier, tester et itérer sur des bases de code réelles. L'entreprise présente Cursor comme « la meilleure façon de coder avec l'IA », en mettant l'accent sur la capacité des agents à réaliser des tâches d'ingénierie utiles plutôt que de se contenter de compléter automatiquement des lignes de code.

Pourquoi Cursor 2.0 est important maintenant

Les assistants IA pour le code ne se contentent plus de tâches simples, mais gèrent désormais des flux de travail plus longs et complexes (planification → édition → test → itération). Cela engendre de nouveaux goulots d'étranglement : latence, fidélité du contexte dans les grands dépôts, exécution sécurisée des commandes shell/CI et travail humain de validation des modifications apportées par l'agent. Curseur 2.0 Il cible directement ces goulots d'étranglement en proposant un modèle optimisé pour les flux de travail multi-agents. et Primitives d'interface utilisateur et d'architecture permettant d'exécuter simultanément et en toute sécurité de nombreux agents. En bref : Cursor ambitionne de devenir une solution complète pour le développement logiciel centré sur les agents.

Fonctionnalités de la mise à jour Cursor 2.0 :

• 4 fois plus rapide — un tour de dialogue moyen est effectué en moins de 30 secondes ;
• Capacités améliorées pour les tâches multi-étapes — capables de gérer indépendamment des chaînes de code complexes ;
• Recherche sémantique améliorée — capable de comprendre et de trouver des relations dans l'ensemble du code source ;
• Optimisation de l'interaction à faible latence — adaptée au développement en temps réel et au prototypage rapide ;
• Formation par apprentissage par renforcement (RL) — optimisée pour le codage basé sur les agents.

Quel est le concept de base de Cursor 2.0 ?

Au cœur de Cursor 2.0 se trouvent trois idées interdépendantes :

1. Conception de l'éditeur axée sur l'agent

Plutôt que d'ajouter des agents à un EDI traditionnel, Cursor 2.0 les présente comme des objets dans l'éditeur : visibles dans une barre latérale, gérables comme des processus et capables d'exécuter des « plans » (stratégies en plusieurs étapes) sur le dépôt. Cela transforme les actions d'IA en tâches orchestrées, chacune avec ses entrées, ses journaux et ses sorties que les ingénieurs peuvent analyser.

2. Modèle de codage rapide et dédié (Composer)

Le nouveau modèle de Cursor, Composer, est un modèle de codage de pointe, entraîné et optimisé spécifiquement pour les interactions entre agents au sein de l'environnement Cursor. Il privilégie le débit et la réactivité – des propriétés essentielles pour des cycles de codage courts et itératifs dans un éditeur – aux performances brutes et coûteuses des benchmarks de perplexité des jetons. L'entreprise indique que Composer atteint environ Vitesse de génération multipliée par 4 Comparé à des modèles aux performances similaires, il effectue la plupart des interactions en moins de 30 secondes lors de ses tests internes. Cette rapidité n'est pas qu'un simple gain de temps ; elle transforme radicalement l'expérience utilisateur (passant de l'attente à l'itération).

3. Exécution parallèle et isolée des agents

Cursor 2.0 permet aux équipes d'exécuter plusieurs agents en parallèle sur un même projet tout en évitant les conflits de fichiers grâce à l'isolation de l'espace de travail de chaque agent (via des techniques telles que les répertoires de travail Git ou les environnements de travail distants isolés). Ceci permet d'explorer différentes hypothèses à grande échelle : exécuter simultanément plusieurs stratégies de réparation, variantes de refactorisation ou pipelines de test, et comparer les résultats sans interférence.

---

Journal des modifications de Cursor 2.0 : quelles sont les nouveautés ?

Cursor a publié un journal des modifications détaillé en même temps que l'annonce de la version 2.0. Les points saillants ci-dessous résument les changements les plus importants apportés au produit et à la recherche.

Compositeur — Premier modèle de codage agentiel de Cursor

• Modèle de frontière conçu à cet effet : Composer est décrit comme un modèle « de pointe » optimisé pour les tâches d'ingénierie logicielle et la rapidité d'exécution. Il a été entraîné avec un accès aux outils du code source, ce qui lui permet d'apprendre les schémas de recherche, d'édition et de résolution de problèmes complexes au sein d'un dépôt réel.
• Avantage de vitesse : Cursor indique que Composer est à peu près 4 fois plus rapide en termes de débit de génération que les modèles d'intelligence comparable dans leurs benchmarks et le fait que la plupart des échanges conversationnels se terminent en moins de 30 secondes en pratique — une amélioration clé pour les sessions interactives.
• Optimisation des agents : Composer a été entraîné dans un environnement multi-agents (accès à des outils comme la recherche sémantique, l'édition et l'exécution de tests) et optimisé par apprentissage par renforcement afin de favoriser des modifications de code rapides et fiables. Certaines études indépendantes suggèrent l'utilisation d'architectures de type MoE (mélange d'experts) et un ajustement fin par apprentissage par renforcement dans la stratégie d'entraînement du modèle.

Impact sur les développeurs : une latence réduite et une meilleure prise en compte du contexte pour les grands référentiels rendent les flux de travail itératifs des agents plus rapides et plus fiables pour les modifications en plusieurs étapes.

Multi-agents : orchestration parallèle des agents

Gestion des barres latérales et des plans : Une nouvelle interface utilisateur d'éditeur permet aux développeurs de créer, nommer et gérer plusieurs agents et « plans » (stratégies d'agents en plusieurs étapes) avec une barre latérale persistante afin que les agents et leurs journaux soient faciles à inspecter.

Exécutions parallèles (jusqu'à huit agents) : Cursor 2.0 prend en charge l'exécution jusqu'à huit agents en parallèle Chaque processus s'exécute sur une seule invite, dans une copie isolée du code source afin d'éviter les conflits. Ceci est rendu possible grâce à des répertoires de travail Git locaux ou à des machines distantes. Le parallélisme transforme l'expérimentation automatisée, auparavant linéaire et bloquante, en un processus rapide et comparatif.

Navigateur (GA) : permettre aux agents de tester et d’inspecter de véritables interfaces utilisateur Web

*Le navigateur est passé à GA :*Le navigateur intégré de Cursor, initialement en version bêta, est désormais disponible pour tous et mieux intégré à l'éditeur. Les agents peuvent interagir avec les pages web, extraire des éléments DOM et renvoyer des informations structurées à l'environnement d'exécution. Ils peuvent ainsi consulter la documentation, interroger des API distantes et effectuer un débogage web sans quitter l'éditeur.

Impact sur les développeurs : Les agents peuvent désormais valider les modifications de l'interface utilisateur, reproduire les bogues du client et itérer avec des preuves concrètes du DOM/visuelles plutôt qu'avec des descriptions textuelles aveugles.

Amélioration de la revue de code et des différences

Examen simplifié des modifications d'agents dans plusieurs fichiers. Cursor 2.0 simplifie l'examen des modifications apportées par un agent dans un dépôt sans avoir à naviguer entre les fichiers ; les différences sont présentées de manière à réduire la charge cognitive.

Impact sur les développeurs : À mesure que les agents effectuent des modifications plus importantes ou inter-fichiers, le temps que les humains consacrent à déterminer la fiabilité diminue — une étape essentielle pour l'adoption.

Terminaux isolés (GA) et contrôles de sécurité

Les terminaux sandboxés sont GA (macOS) et exécutent par défaut les commandes shell de l'agent dans un environnement sécurisé. Les commandes shell sont exécutées dans un environnement isolé (sandbox) avec accès en lecture/écriture à l'espace de travail, sans accès réseau par défaut et avec une liste blanche pour les commandes sensibles. Des contrôles d'administration sont disponibles pour les entreprises.
Impact sur les développeurs : Une exécution plus sûre des agents est cruciale ; le sandboxing réduit les risques lorsqu’un agent doit exécuter des tests, des linters ou des commandes éphémères.

Mode vocal, mode plan et agents en arrière-plan

• Le contrôle vocal pour les agents (reconnaissance vocale + mots-clés de soumission personnalisés).
• Mode Plan: créer un plan avec un modèle et l'exécuter avec un autre ; les plans peuvent être exécutés au premier plan ou en arrière-plan.
• Agents de fond et de cloud: démarrage plus rapide, fiabilité de 99.9 % pour les agents cloud, meilleure visibilité des opérations en arrière-plan.

Que révèle Cursor 2.0 sur le paysage plus large du codage IA ?

Le déplacement du curseur est remarquable pour deux raisons :

1. La spécialisation plutôt que la généralité. Composer illustre une tendance à concevoir des modèles adaptés à des domaines et environnements d'exécution spécifiques (ici : le développement agentiel au sein d'un EDI). Au lieu d'un modèle généraliste unique couvrant tous les cas d'utilisation, les équipes privilégient désormais des modèles co-conçus avec l'expérience utilisateur et la chaîne d'outils qu'ils utilisent.
2. L'orchestration des agents en tant que primitive de produit. L'interface utilisateur de Cursor considère les agents comme des ressources gérées que vous pouvez orchestrer, auditer et versionner. Ce modèle de produit – des agents en tant que processus gérés avec des arborescences de travail isolées et des plans partagés – devrait se généraliser dans d'autres outils de développement, à mesure que les équipes chercheront à déployer une assistance autonome à grande échelle en toute sécurité.

Cette combinaison — des modèles spécialisés et plus rapides associés à une expérience utilisateur d'orchestration délibérée — fait évoluer le secteur des « modèles comme outils de saisie automatique » vers les « modèles comme collaborateurs actifs », mais elle soulève également des questions de gouvernance auxquelles chaque équipe devra répondre.

Comment puis-je accéder à Cursor 2.0 ?

1. Téléchargez ou mettez à jour l'application Cursor depuis le site officiel (Cursor distribue ses mises à jour sur son site). Cursor 2.0 a été publié en tant que version 2 (Composer + interface utilisateur multi-agents) ; la première étape consiste donc à effectuer la mise à jour vers la dernière version de Cursor.

2. Assurez-vous que Cursor 2.0 / Composer est activé

• La tarification de Cursor repose sur des abonnements, chacun offrant différents niveaux d'accès à Composer et à d'autres modèles. L'entreprise propose une formule gratuite « Ami », mais les utilisateurs professionnels optent généralement pour un abonnement payant afin de débloquer toutes les fonctionnalités.
• La version 2.0 de Cursor (Composer, interface utilisateur multi-agents, navigateur intégré, etc.) est mise en avant dans le journal des modifications ; si l’application s’est mise à jour automatiquement, vous devriez déjà utiliser la version 2.0. Sinon, mettez à jour l’application depuis la page de téléchargement ou depuis la boîte de dialogue de mise à jour de l’application.
• Les fonctionnalités de compositeur ou de gestion de plusieurs fichiers/agents peuvent être désactivées (option bêta) dans les paramètres (versions antérieures). Si vous ne voyez pas le compositeur, vérifiez Paramètres → Fonctionnalités/Bêta et activez-le ; le compositeur s’ouvre généralement via le raccourci compositeur/agent (par exemple, Ctrl/Cmd + I) ou depuis le panneau latéral. Le compositeur peut être activé/désactivé et apparaît dans l'interface utilisateur Agent/Composer.

3. Configurer les clés API / les modèles: Le curseur utilise des clés API configurées pour appeler les fournisseurs LLM (OpenAI, Anthropic, Google ou des fournisseurs personnalisés tels que API CometOuvrez Cursor → Paramètres → Modèles (ou Paramètres → Clés API) pour ajouter des clés de fournisseur et des URL de base personnalisées. Cursor vous permettra ensuite de sélectionner le modèle activé dans Chat / Agent / Composer.

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.

É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).

Étape C — Sélectionnez le modèle CometAPI dans Composer / Agent

1. Ouvrir Composer ou Agent (raccourci) Ctrl/Cmd + I ou le panneau latéral).
2. Modifiez la sélection du modèle de « Auto » (ou votre modèle actuel) à celle du fournisseur/modèle personnalisé que vous venez d'ajouter.
3. Démarrez une session Composer ou lancez un agent et vérifiez qu'il répond en utilisant le modèle CometAPI choisi. Testez avec une invite courte (par exemple : « Rechercher dans le dépôt et ajouter des tests unitaires pour les fonctions défaillantes »). tests/”) pour valider le comportement.

Conclusion : s’agit-il d’une mise à jour majeure ?

Cursor 2.0 n'est pas qu'une simple mise à jour fonctionnelle ; c'est une véritable approche produit qui combine un modèle de codage dédié avec des primitives d'orchestration rendant les flux de travail multi-agents concrets. Ses éléments surprenants — un modèle multi-agents interne (Composer) optimisé pour la vitesse, un environnement d'exécution multi-agents avec des mécanismes d'isolation précis et une intégration plus poussée d'outils comme un navigateur GA — témoignent d'une évolution majeure dans l'intégration de l'IA au génie logiciel. Pour les équipes rigoureuses en matière de revues, de tests et de bonnes pratiques de développement, Cursor 2.0 offre une voie crédible vers une itération nettement plus rapide et une automatisation accrue des tâches d'ingénierie courantes. Pour l'écosystème plus large des développeurs d'IA, l'accent mis par Cursor sur l'orchestration des agents et les outils associés incitera probablement les autres fournisseurs à dépasser les interactions avec un seul assistant et à s'orienter vers des équipes d'agents, des garde-fous opérationnels et des modèles prenant en compte la latence.