EN BREF
La nouvelle fonctionnalité d'utilisation de l'ordinateur par l'agent de Cursor permet aux agents cloud IA de contrôler leurs propres machines virtuelles, ce qui leur permet de construire, tester et vérifier le code de manière autonome. Les agents s'exécutent dans des VMs isolées avec des environnements de développement complets, peuvent ouvrir des navigateurs et naviguer sur localhost, et produire des pull requests prêtes à être fusionnées avec des vidéos et des journaux. Accès via Cursor Desktop, Web, Slack, GitHub ou API. Plus de 30 % des modifications de code internes de Cursor sont désormais créées par ces agents autonomes.
Introduction
La façon dont les développeurs écrivent du code évolue rapidement. Pendant des années, les assistants de codage IA comme Cursor ont fonctionné comme des outils de complétion intelligente — suggérant la ligne suivante, expliquant le code ou aidant à refactoriser le travail existant. Mais un changement majeur est en cours.
Cursor a annoncé ce qu'ils appellent "le plus grand changement dans la façon dont nous construisons des logiciels depuis le passage de la complétion par tabulation au travail synchrone avec des agents." Leurs agents cloud peuvent désormais contrôler leurs propres machines virtuelles pour construire, tester et démontrer du code fonctionnel.
Ce n'est pas seulement une amélioration progressive. Selon l'annonce de Cursor, 30 à 35 % de leurs pull requests fusionnées sont désormais créées par des agents cloud autonomes.
Dans ce guide, vous découvrirez ce que fait la fonction d'utilisation de l'ordinateur par l'agent de Cursor, comment elle fonctionne et comment la configurer exactement.
Qu'est-ce que l'utilisation de l'ordinateur par l'agent Cursor ?
L'utilisation de l'ordinateur par l'agent Cursor est une fonctionnalité qui permet aux agents IA d'opérer dans leurs propres machines virtuelles isolées plutôt que de simplement interagir avec votre environnement de développement local. Lorsque vous lancez un agent cloud, il déploie un environnement de développement complet dans le cloud — une VM isolée avec tout le nécessaire pour construire, tester et vérifier des logiciels.
Pourquoi c'est important
Les assistants de codage IA traditionnels fonctionnent en :
- Suggérant des complétions de code dans votre IDE
- Répondant à des questions sur votre base de code
- Aidant à refactoriser ou expliquer le code existant
Les agents cloud de Cursor vont plus loin en effectuant réellement le travail :
- Fonctionnant dans des environnements cloud isolés
- Installant les dépendances et construisant les projets
- Ouvrant des navigateurs et testant l'interface utilisateur
- Vérifiant que les changements fonctionnent avant de rendre compte
- Créant des pull requests prêtes à être fusionnées avec des preuves
La technologie derrière tout ça
Chaque agent cloud s'exécute dans sa propre machine virtuelle isolée. Cela procure plusieurs avantages importants :
- Isolation : Les agents ne se disputent pas les ressources locales
- Parallélisme : Plusieurs agents peuvent travailler simultanément
- Vérification : Les agents peuvent réellement tester leurs modifications
- Preuves : Chaque PR inclut des vidéos, des captures d'écran et des journaux
Agents Cloud vs. Assistance IA traditionnelle dans l'IDE
Comprendre la différence entre les agents cloud et l'IA traditionnelle basée sur l'IDE permet de définir des attentes réalistes :
Codage IA traditionnel (Mode Classique de Cursor) :
- Les suggestions apparaissent dans votre IDE au fur et à mesure que vous tapez
- Vous oblige à revoir et accepter chaque modification
- Limité aux ressources de votre machine locale
- Pas de capacité à exécuter des tests ou à vérifier les fonctionnalités
- Vous gardez le contrôle total et le contexte à tout moment
Agents Cloud (Autonomes) :
- Les agents travaillent indépendamment sans supervision constante
- Les modifications sont testées et vérifiées avant que vous ne les voyiez
- Ressources VM complètes disponibles pour les builds et les tests
- Produit des artefacts révisables montrant ce qui a été fait
- Vous n'intervenez qu'au stade de la révision de la PR
Le changement clé est de "l'IA m'assiste" à "l'IA le fait pour moi." Cela ne remplace pas les développeurs — cela déplace votre rôle de l'implémentation à la révision et à la direction.
Explication des exigences techniques
Comprendre ce qui se passe sous le capot aide au dépannage :
- Environnement VM : Chaque agent reçoit une VM fraîche basée sur Ubuntu avec les outils de développement courants préinstallés
- Clonage de dépôt : L'agent clone votre dépôt, y compris les sous-modules, pour travailler avec votre base de code réelle
- Gestion des dépendances : L'agent peut installer des paquets npm, des exigences pip ou d'autres dépendances selon les besoins
- Accès réseau : Les agents peuvent accéder à internet pour cloner des paquets, exécuter des commandes curl ou naviguer vers des serveurs localhost
- Stockage des artefacts : Les vidéos et captures d'écran sont stockées et liées dans la PR générée
Cette transparence signifie que vous savez toujours dans quel environnement votre code a été construit et testé.
Comment fonctionnent les agents cloud de Cursor
Aperçu de l'architecture
Lorsque vous lancez un agent cloud Cursor, voici ce qui se passe :
- Provisionnement de VM : Cursor déploie une machine virtuelle isolée avec un environnement de développement complet
- Accès au dépôt : L'agent clone votre dépôt et toutes les dépendances
- Exécution des tâches : L'agent lit vos exigences, effectue des modifications et exécute des tests
- Vérification : L'agent ouvre des navigateurs, navigue vers localhost, clique sur l'interface utilisateur pour vérifier que tout fonctionne
- Génération d'artefacts : L'agent enregistre des vidéos, des captures d'écran et des journaux montrant ce qui a été fait
- Création de PR : L'agent crée une pull request avec toutes les preuves
Où lancer les agents
Les agents cloud de Cursor sont accessibles depuis plusieurs plateformes :
| Plateforme | Comment lancer |
|---|---|
| Cursor Desktop | Sélectionnez "Cloud" dans le menu déroulant sous l'entrée de l'agent |
| Cursor Web | Visitez cursor.com/agents |
| Slack | Utilisez la commande @cursor |
| GitHub | Commentez @cursor sur une PR ou un problème |
| API | Utilisez l'API Cursor pour lancer un agent |
| Linear | Utilisez la commande @cursor |
Exigences
Avant d'utiliser les agents cloud, assurez-vous d'avoir :
- Des modèles compatibles avec le Mode Max activés (seuls ces modèles supportent les agents cloud)
- Des privilèges de lecture/écriture sur votre dépôt
- Tout dépôt dépendant ou sous-module accessible
Actuellement, les agents cloud prennent en charge les dépôts GitHub et GitLab.
Guide de configuration étape par étape
Étape 1 : Accéder à l'onboarding
Accédez à cursor.com/onboard pour commencer. Cette page vous guide à travers la configuration initiale de l'agent et vous permet de regarder l'agent s'installer lui-même.
Étape 2 : Choisissez votre plateforme de lancement
Vous avez plusieurs options :
Option A : Cursor Desktop
- Ouvrez l'IDE Cursor
- Trouvez l'entrée de l'agent en bas
- Cliquez sur le menu déroulant et sélectionnez "Cloud"
- Décrivez ce que vous voulez construire
Option B : Cursor Web
- Allez sur cursor.com/agents
- Connectez-vous avec votre compte
- Sélectionnez votre dépôt
- Décrivez votre tâche
Option C : Intégration GitHub
- Accédez à votre dépôt
- Ouvrez un problème ou une PR
- Commentez
@cursor construire une fonctionnalité qui... - L'agent prendra en charge la tâche
Étape 3 : Configurer les privilèges de l'agent
Lorsque vous utilisez un agent cloud pour la première fois, vous devrez accorder :
- L'accès en lecture/écriture au dépôt
- L'accès à tout dépôt dépendant
- L'accès aux sous-modules si applicable
Étape 4 : Définir votre tâche
Soyez précis sur ce que vous voulez que l'agent accomplisse. Par exemple :
- "Construire une page de connexion avec des champs d'e-mail et de mot de passe"
- "Ajouter un bouton de commutation de mode sombre à la page des paramètres"
- "Corriger le bug où l'API renvoie 500 pour une entrée invalide"
Plus vous fournissez de contexte, mieux l'agent peut livrer.
Étape 5 : Surveiller et réviser
Bien que les agents travaillent de manière autonome, vous pouvez :
- Observer le bureau à distance de l'agent en temps réel
- Examiner les artefacts générés (vidéos, captures d'écran)
- Prendre le contrôle de la session pour essayer les modifications vous-même
- Approuver ou demander des modifications à la PR
Fonctionnalités et capacités clés
Auto-test et itération
Peut-être la fonctionnalité la plus puissante : les agents peuvent réellement vérifier leur travail. Ils peuvent :
- Démarrer des serveurs de développement
- Ouvrir des navigateurs et naviguer vers localhost
- Cliquer sur les éléments de l'interface utilisateur
- Exécuter des tests automatisés
- Vérifier que la fonctionnalité fonctionne comme prévu
L'agent a passé 45 minutes à faire une démonstration complète du site de documentation de Cursor. Il a fourni un résumé de toutes les fonctionnalités testées, y compris la barre latérale, la navigation supérieure, la recherche, le bouton de copie de page, la boîte de dialogue de partage de commentaires, la table des matières et le changement de thème.
Enregistrement des artefacts
Chaque exécution d'agent produit des artefacts riches :
- Des vidéos montrant la fonctionnalité en action
- Des captures d'écran des moments clés
- Des journaux des processus de build et de test
- Un diff de toutes les modifications de code
Cela rend la révision rapide — vous pouvez voir exactement ce qui a été fait sans avoir à extraire la branche.
Contrôle du bureau à distance
Vous voulez essayer les modifications vous-même ? Vous pouvez prendre le contrôle direct du bureau à distance de l'agent. Cela vous permet de :
- Tester la fonctionnalité dans l'environnement de l'agent
- Vérifier que cela fonctionne avant de fusionner
- Apporter des modifications supplémentaires si nécessaire
- Éviter d'extraire la branche localement
Accès multiplateforme
Les agents cloud fonctionnent où que vous soyez :
- Desktop : Intégration complète de l'IDE
- Web : Gestion des agents basée sur le navigateur
- Mobile : Surveillance en déplacement
- Slack : Commandes d'agent rapides
- GitHub : Intégration des problèmes et des PR
Cas d'utilisation concrets
Création de nouvelles fonctionnalités
Décrivez une fonctionnalité dont vous avez besoin, et l'agent la construit de bout en bout : échafaudage, implémentation, tests et vérification.
Reproduction de bugs
Demandez à l'agent de reproduire un bug, et il peut :
- Mettre en place l'environnement
- Déclencher les conditions du bug
- Enquêter sur la cause première
- Proposer et tester un correctif
Correctifs rapides
Pour les petites modifications, vous pouvez déléguer entièrement à l'agent sans changer de contexte.
Tests d'interface utilisateur
Les agents peuvent cliquer sur les interfaces pour vérifier :
- Les parcours utilisateurs fonctionnent correctement
- Le design responsif s'affiche correctement
- Les éléments interactifs répondent comme prévu
Travaux d'intégration API
Lors de la construction d'intégrations API, les agents peuvent :
- Mettre en place des serveurs simulés
- Tester les points de terminaison API
- Vérifier la gestion des réponses
- Générer de la documentation
C'est là que des outils comme Apidog complètent parfaitement les agents de Cursor — utilisez Apidog pour concevoir et tester vos API, puis laissez les agents Cursor gérer l'implémentation et l'intégration frontend. Par exemple, vous pouvez tester les API localhost avec des services de webhook pour vérifier que vos intégrations API fonctionnent correctement avant le déploiement.
Limitations et considérations
Limitations actuelles
- Support de dépôt : Actuellement GitHub et GitLab uniquement
- Restriction de modèle : Seuls les modèles compatibles avec le Mode Max fonctionnent
- Exigence de privilèges : Nécessite un accès complet en lecture/écriture
- Nouvelle fonctionnalité : Encore en évolution, certains cas limites possibles
Quand utiliser et ne pas utiliser
Idéal pour :
- Demandes de fonctionnalités bien définies
- Reproduction et corrections de bugs
- Code passe-partout et échafaudage
- Tâches de test et de vérification
Peut ne pas être idéal pour :
- Code hautement sensible à la sécurité (réviser attentivement les privilèges)
- Décisions architecturales complexes (jugement humain nécessaire)
- Tâches nécessitant une configuration d'environnement local spécifique
Considérations de sécurité
Lorsque vous accordez aux agents l'accès au dépôt, gardez à l'esprit ces meilleures pratiques de sécurité :
- Utilisez des jetons à portée limitée : Au lieu d'accorder un accès complet au dépôt, utilisez des jetons avec les permissions minimales requises
- Examinez les actions de l'agent : Toujours examiner les PRs minutieusement avant de fusionner, surtout pour le code de production
- Environnements séparés : Envisagez d'utiliser les agents uniquement sur des branches non-production initialement
- Journaux d'audit : Profitez de l'enregistrement des artefacts de Cursor pour auditer ce que l'agent a fait
- Commencez petit : Commencez par des tâches à faible risque pour gagner en confiance avant d'aborder des fonctionnalités critiques
L'approche de VM isolée de Cursor est intrinsèquement plus sûre que de donner aux agents un accès local direct, mais une utilisation responsable nécessite toujours de la vigilance.
L'avenir des agents de codage autonomes
Bonnes pratiques pour tirer le meilleur parti des agents cloud
Pour maximiser la productivité avec les agents autonomes de Cursor, suivez ces pratiques éprouvées :
1. Rédigez des invites claires et spécifiques
La qualité de la sortie de l'agent est directement corrélée à la clarté de l'invite. Au lieu de requêtes vagues comme "corriger le bug de connexion", soyez précis : "Lorsqu'un utilisateur soumet le formulaire de connexion avec des identifiants valides, il devrait être redirigé vers /dashboard mais voit à la place une erreur 401. Le serveur renvoie le jeton correct dans la réponse."
2. Fournissez le contexte tôt
Fournissez le contexte pertinent aux agents dès le début : chemins de fichiers, extraits de code pertinents, messages d'erreur ou liens vers des problèmes connexes. Les agents ne peuvent travailler qu'avec ce qu'ils connaissent.
3. Utilisez un raffinement itératif
N'essayez pas de faire construire tout par les agents en une seule fois. Commencez par une version minimale viable, examinez les résultats, puis développez. Cela produit de meilleurs résultats que de décharger des exigences massives dans une seule invite.
4. Exploitez plusieurs agents en parallèle
Puisque les agents s'exécutent dans des VM isolées, vous pouvez lancer plusieurs agents pour différentes tâches simultanément — un pour une nouvelle fonctionnalité, un autre pour une correction de bug, un troisième pour des mises à jour de documentation.
5. Examinez minutieusement les artefacts
Les artefacts vidéo et capture d'écran ne sont pas seulement de jolis bonus — ils sont votre fenêtre sur ce que l'agent a réellement fait. Regardez-les pour détecter les problèmes que vous pourriez manquer lors de la révision de code.
Intégration à votre workflow existant
Les agents Cursor s'intègrent en douceur aux workflows de développement courants :
- CI/CD : Les agents peuvent créer des PRs qui déclenchent votre pipeline CI existant
- Révision de code : Le processus de révision de PR standard s'applique — aucun outil spécial n'est nécessaire
- Tests : Les agents peuvent exécuter votre suite de tests et inclure les résultats dans les PRs
- Documentation : Les agents peuvent mettre à jour les fichiers README, les docs API ou les commentaires en ligne
L'idée clé est que les agents augmentent votre workflow plutôt que de le remplacer. Vous continuez à réviser, tester et approuver — mais le travail de base se fait automatiquement.
L'annonce de Cursor représente une tendance plus large. Le domaine du codage IA s'intensifie :
- Anthropic a publié Claude Code avec des capacités d'agent
- OpenAI a introduit Codex pour le codage autonome
- Microsoft continue d'étendre les fonctionnalités de GitHub Copilot
- Google intègre des agents IA dans les workflows de développement
Le taux de PR autonomes de 30-35% de Cursor suggère que ce modèle fonctionne. Attendez-vous à ce que davantage d'outils adoptent des approches similaires à mesure que la technologie mûrit.
Pour le développement d'API spécifiquement, la combinaison d'agents autonomes avec des outils API dédiés crée un workflow puissant : les agents gèrent l'implémentation et les tests, tandis que des outils spécialisés comme Apidog gèrent la conception d'API, la documentation et les tests complets.
Conclusion
La fonctionnalité d'utilisation de l'ordinateur par l'agent de Cursor représente un changement fondamental dans la façon dont les logiciels sont construits. En permettant aux agents IA d'opérer dans leurs propres machines virtuelles, de tester leurs modifications et de produire des pull requests vérifiées et riches en artefacts, Cursor prouve que le codage autonome fonctionne à grande échelle.
La configuration est simple : choisissez votre plateforme, définissez votre tâche et laissez l'agent travailler. Avec plus de 30 % du propre code de Cursor désormais écrit par des agents, la technologie a fait ses preuves.
Prochaines étapes :
- Essayez l'onboarding sur cursor.com/onboard
- Commencez par une petite tâche bien définie
- Examinez les artefacts générés pour comprendre les capacités de l'agent
- Réfléchissez à la façon dont les agents autonomes pourraient améliorer votre workflow de développement
Démarrez avec Apidog : Essayez Apidog gratuitement pour concevoir, tester et documenter vos API tout en exploitant les assistants de codage basés sur l'IA comme Cursor pour l'implémentation.