Passer au contenu principal

Un article étiquetés avec "assistants de programmation"

Voir toutes les étiquettes

Architectures des systèmes d'agents de GitHub Copilot, Cursor et Windsurf

· 18 minutes de lecture
Lark Birdy
Chief Bird Officer

Architectures des systèmes d'agents de GitHub Copilot, Cursor et Windsurf

Ces dernières années, plusieurs produits d'assistance à la programmation basés sur l'IA ont vu le jour, tels que GitHub Copilot, Cursor et Windsurf. Leurs implémentations introduisent toutes le concept d'« Agent » (agent intelligent), permettant à l'IA d'assister le travail de codage de manière plus proactive. Cet article propose une étude approfondie de la construction du système d'agents de ces produits du point de vue de l'architecture d'ingénierie, y compris la philosophie de conception architecturale, la décomposition et la planification des tâches, les stratégies d'invocation de modèles, la gestion de l'état du contexte, les mécanismes d'extension de plugins, ainsi que les compromis et innovations clés dans leurs conceptions respectives. Le contenu suivant est principalement basé sur les blogs d'ingénierie officiels, les articles des développeurs de projets et les documents techniques pertinents.

Architecture de l'Agent GitHub Copilot

Philosophie de Conception Architecturale : GitHub Copilot s'est initialement positionné comme un "programmeur pair IA" pour les développeurs, et a maintenant étendu cette approche avec un mode "Agent". Son système d'Agent n'est pas une collection d'agents indépendants, mais plutôt un agent intelligent intégré capable d'engager des conversations multi-tours et d'exécuter des tâches en plusieurs étapes, supportant des entrées multimodales (par exemple, en utilisant des modèles de vision pour interpréter des captures d'écran). Copilot met l'accent sur l'assistance de l'IA plutôt que sur le remplacement des développeurs. En mode Agent, il agit davantage comme un ingénieur automatisé au sein d'une équipe, acceptant les tâches assignées, écrivant du code de manière autonome, déboguant et soumettant les résultats via des Pull Requests. Cet agent peut être déclenché via l'interface de chat ou en assignant une GitHub Issue à Copilot.

Décomposition et Planification des Tâches : L'Agent de Copilot excelle à décomposer les tâches logicielles complexes en sous-tâches et à les accomplir une par une, en employant un processus de raisonnement interne similaire à la "Chaîne de Pensée" (Chain-of-Thought). Il parcourt de manière répétée le cycle "analyser le problème → exécuter les modifications de code ou les commandes → vérifier les résultats" jusqu'à ce que les exigences de l'utilisateur soient satisfaites. Par exemple, en mode Agent, Copilot n'exécute pas seulement les étapes spécifiées par l'utilisateur, mais infère aussi implicitement et exécute automatiquement les étapes supplémentaires nécessaires pour atteindre l'objectif principal. Si des erreurs de compilation ou des échecs de test surviennent pendant le processus, l'Agent identifie et corrige les erreurs lui-même, et réessaie, afin que les développeurs n'aient pas à copier-coller à plusieurs reprises les messages d'erreur comme des invites. Un blog de VS Code résume son cycle de travail : l'Agent Copilot détermine de manière autonome le contexte pertinent et les fichiers à modifier, propose des modifications de code et des commandes à exécuter, surveille l'exactitude des modifications ou de la sortie du terminal, et itère continuellement jusqu'à ce que la tâche soit terminée. Cette exécution automatisée en plusieurs tours permet à Copilot de gérer une variété de tâches, de

Architecture de l'Agent de Cursor

Philosophie de Conception Architecturale : Cursor est un outil de codage alimenté par l'IA, développé par la startup Anysphere. Il s'agit essentiellement d'un éditeur de code (modifié à partir de VS Code) profondément intégré à un assistant IA. Cursor offre deux modes d'interaction principaux : l'assistant de chat et l'Agent autonome. En mode conversationnel normal, il agit comme un assistant de code traditionnel, répondant aux questions ou générant du code basé sur des instructions ; lorsqu'il est basculé en mode Agent (également appelé "Composer"), Cursor peut exécuter de manière proactive une série d'opérations au nom du développeur. Cette architecture donne aux utilisateurs la liberté de choisir selon leurs besoins : les tâches simples peuvent être gérées en demandant ligne par ligne en mode assistant, tandis que les tâches complexes ou répétitives peuvent être traitées par lots en invoquant l'Agent. Cursor se concentre actuellement principalement sur l'assistance dans le domaine du texte (code), sans mettre l'accent sur l'entrée/sortie multimodale (bien qu'il offre une fonctionnalité de saisie vocale, convertissant la parole en texte pour les invites). Similaire à Copilot, le système d'Agent de Cursor fonctionne également comme un agent intelligent unique en série, et non comme plusieurs agents travaillant en parallèle. Cependant, sa caractéristique distinctive est son accent sur la collaboration humain-IA : en mode Agent, l'IA entreprend autant d'actions que possible, mais permet globalement aux développeurs d'intervenir et de prendre le contrôle à tout moment, plutôt que de fonctionner de manière totalement non supervisée pendant de longues périodes.

Décomposition des Tâches et Planification : En mode Agent de Cursor, l'IA peut gérer des tâches complexes impliquant plusieurs fichiers, mais la conception privilégie un style de requête étape par étape. Après avoir reçu une instruction de haut niveau de l'utilisateur, l'Agent recherche de manière autonome des extraits de code pertinents, ouvre les fichiers nécessitant des modifications, génère des plans de modification et exécute même des tests/commandes de compilation pour vérifier l'effet. Cependant, contrairement aux Agents de Copilot ou de Windsurf, l'Agent de Cursor fait généralement une pause après avoir terminé une proposition initiale, attendant la révision de l'utilisateur et des instructions supplémentaires. Cela signifie que l'Agent de Cursor ne s'améliore généralement pas de manière continue et répétée, à moins qu'il ne reçoive une nouvelle invite de l'utilisateur. Par exemple, si vous demandez à Cursor d'effectuer un refactoring inter-projets, il collectera tous les emplacements nécessitant une modification et générera un diff pour chaque fichier afin que l'utilisateur puisse le réviser ; à ce stade, l'utilisateur décide quelles modifications accepter et appliquer. Si ces changements introduisent de nouveaux problèmes, Cursor ne continuera pas arbitrairement à modifier, à moins que l'utilisateur ne fasse d'autres demandes telles que "corriger les problèmes apparus". Ce mécanisme assure une supervision humaine aux points de décision critiques, empêchant l'IA de s'emballer. Cependant, cela signifie également que l'Agent de Cursor manque d'autonomie pour la planification à long terme, nécessitant une guidance humaine étape par étape pour compléter des boucles fermées complexes. Pour améliorer partiellement l'autonomie continue, l'équipe de Cursor a également ajouté certaines fonctionnalités itératives au système d'Agent. Par exemple, il essaiera de compiler et d'exécuter du code et de détecter les erreurs, corrigera automatiquement certains problèmes simples tels que les erreurs de syntaxe ou de lint, mais s'arrêtera généralement après quelques tentatives, rendant le contrôle à l'utilisateur. Les développeurs ont observé que l'Agent de Cursor est très efficace pour le refactoring local ou les changements de portée limitée, mais pour les changements généralisés, il nécessite souvent que l'utilisateur le sollicite par segments, complétant la tâche étape par étape. Globalement, Cursor positionne l'Agent comme un "assistant d'exécution intelligent" plutôt qu'un robot de programmation automatisé tout-puissant ; sa planification des tâches tend vers l'exécution à court terme, le rapport en temps opportun et la décision humaine de l'étape suivante.

Stratégie d'Invocation de Modèle : Cursor ne forme pas ses propres grands modèles linguistiques ; il adopte une stratégie d'intégration d'API tierces. Les utilisateurs peuvent configurer des clés API de fournisseurs comme OpenAI ou Anthropic au sein de Cursor, et le backend de Cursor appellera alors le grand modèle correspondant au nom de l'utilisateur. Quel que soit le fournisseur de modèle choisi par l'utilisateur, toutes les requêtes IA passeront par le propre serveur de Cursor : l'application locale regroupe le contexte de l'éditeur et les questions de l'utilisateur et les envoie au cloud, le serveur de Cursor assemble l'invite complète et appelle le modèle, puis renvoie les résultats à l'éditeur. Cette architecture facilite l'optimisation des invites de Cursor et la gestion unifiée des états de session, mais cela signifie également qu'il doit être utilisé en ligne, et les fonctions IA principales sont indisponibles en mode hors ligne. Pour des considérations de coût pour les développeurs, Cursor prend en charge les utilisateurs utilisant leurs propres quotas d'API (ainsi la facturation de l'invocation du modèle revient à l'utilisateur), mais même ainsi, les requêtes passent toujours par le serveur officiel pour des opérations telles que la récupération d'embeddings de code et le formatage des réponses. En termes de sélection de modèles, Cursor propose généralement quelques modèles grand public au choix (par exemple, GPT-4, GPT-3.5, Claude 2, etc.) ; les utilisateurs peuvent en préférer un, mais ne peuvent pas accéder aux modèles non pris en charge par Cursor. En revanche, des systèmes comme Windsurf permettent de remplacer le moteur sous-jacent, tandis que Cursor est plus fermé, les mises à jour et ajustements de modèles étant principalement contrôlés par l'équipe officielle. De plus, Cursor n'a pas de solutions de déploiement local comme Copilot Enterprise, ni n'intègre de modèles open-source — il est entièrement orienté services cloud, il peut donc rapidement suivre les

Architecture de l'Agent Windsurf (Codeium)

Philosophie de Conception Architecturale : Windsurf est un produit de programmation basé sur l'IA, lancé par l'équipe Codeium, et positionné comme le premier "IDE Agentique" (Environnement de Développement Intégré à Agent Intelligent) de l'industrie. Contrairement à Copilot, qui nécessite de basculer entre les modes Chat/Agent, l'assistant IA de Windsurf (nommé Cascade) possède des capacités d'agent en permanence, passant sans effort de la réponse aux questions à l'exécution autonome de tâches multi-étapes selon les besoins. Codeium résume officiellement sa philosophie par "Flows = Agents + Copilots". Un Flow désigne un état de collaboration synchrone entre les développeurs et l'IA : l'IA fournit des suggestions comme un assistant à tout moment et peut également prendre le relais de manière proactive pour exécuter une

Résumé comparatif des systèmes

Vous trouverez ci-dessous un tableau présentant un aperçu des similitudes et des différences dans les architectures d'Agent de GitHub Copilot, Cursor et Windsurf :

Dimension de la fonctionnalitéGitHub CopilotCursorWindsurf (Codeium)
Positionnement architecturalA commencé comme un chatbot d'aide à la programmation, s'est étendu au "mode Agent" (nom de code Project Padawan) ; l'Agent peut être intégré à la plateforme GitHub, avec les workflows d'Issues/PR. Conversation multi-tours avec un seul Agent, pas d'architecture multi-Agent explicite. Prend en charge l'entrée multimodale (images).Éditeur local priorisant l'IA (dérivé de VS Code), inclut des interactions en mode Chat et en mode Agent. Le mode assistant par défaut se concentre sur les Q&R et la complétion, le mode Agent nécessite une activation explicite pour que l'IA exécute des tâches de manière autonome. Architecture à Agent unique, pas de traitement multimodal.Conçu dès le départ comme un "IDE Agentique" : l'assistant IA Cascade est toujours en ligne, capable à la fois de converser et d'effectuer des opérations autonomes en plusieurs étapes, sans nécessiter de changement de mode. Exécution par un seul Agent, réalise une collaboration synchrone entre l'humain et l'IA via les Flux (Flows), actuellement axé sur le texte de code.
Planification et exécution des tâchesPrend en charge la décomposition automatique des tâches et l'exécution itérative. L'Agent décompose les requêtes utilisateur en sous-tâches et les complète itérativement jusqu'à ce que l'objectif soit atteint ou explicitement arrêté. Possède des capacités d'auto-réparation (peut identifier et corriger les erreurs de compilation/test). Fournit les résultats sous forme de PR après chaque achèvement de tâche et attend la révision humaine ; le feedback de la révision déclenche l'itération suivante.Peut gérer les modifications inter-fichiers mais privilégie l'exécution en un seul tour : l'Agent reçoit les instructions et fournit toutes les suggestions de modification en une seule fois, listant les diffs pour approbation par l'utilisateur. N'itère généralement pas de manière autonome en plusieurs tours (sauf si l'utilisateur le relance), et les erreurs sont souvent laissées à l'utilisateur pour décider si l'IA doit les corriger. Effectue par défaut un nombre limité de cycles de correction automatique, évitant les blocages indéfinis.Autonomie profonde : Cascade peut décomposer des exigences de haut niveau en une série d'actions et les exécuter en continu jusqu'à ce que la tâche soit terminée. Excelle dans les refactorings importants et les tâches inter-modules, enchaîne automatiquement les appels à l'édition, la création de fichiers, l'exécution de commandes, la vérification de tests, etc., jusqu'à ce que le code passe les auto-vérifications. Si de nouveaux problèmes sont détectés pendant le processus, il continue d'itérer et de les corriger, ne nécessitant presque aucune intervention humaine, à l'exception du résultat final (mais les changements critiques nécessiteront une confirmation humaine finale).
Stratégie de modèleFusion multi-modèle cloud : Prend en charge OpenAI GPT-4, la série GPT-3.5 (noms de code internes o1, o3-mini, etc.), Anthropic Claude 3.5, Google Gemini 2.0, etc., et les utilisateurs peuvent changer de modèles préférés dans l'interface. Améliore l'efficacité grâce à une architecture à double modèle (grand modèle génère des solutions, petit modèle applique rapidement les changements). Les modèles sont uniformément hébergés et invoqués par GitHub ; les requêtes des utilisateurs de Copilot Enterprise passent par des instances dédiées. Ne prend pas en charge le déploiement privé.Repose entièrement sur les API de grands modèles tiers : toutes les requêtes sont relayées via le cloud de Cursor et invoquent les modèles OpenAI/Anthropic. Les utilisateurs peuvent utiliser leurs propres clés API (facturation autogérée) mais l'invocation se produit toujours sur les serveurs officiels. Pas d'options de modèles hors ligne ou locaux. Les types de modèles dépendent de la gamme prise en charge par Cursor ; les utilisateurs ne peuvent pas intégrer librement de nouveaux modèles. Cursor ne forme pas directement de modèles mais adapte les modèles externes en optimisant les prompts.Modèles principalement auto-développés, backend flexible : utilise par défaut les modèles de code propriétaires de Codeium, et permet aux utilisateurs d'entreprise de choisir un déploiement auto-hébergé. L'architecture prend en charge le changement de différents moteurs de modèles (modèle Codeium "Sonnet" ou open source, etc.), et peut étendre les interfaces tierces à l'avenir. Certaines fonctions légères utilisent de petits modèles pour le calcul local/edge afin de réduire la latence. Met l'accent sur le contrôle de l'utilisateur sur l'environnement IA (rythme de mise à jour des modèles, stabilité des versions contrôlée par l'utilisateur).
Contexte et mémoireUtilise une stratégie RAG pour obtenir le contexte de code : récupère des extraits de code pertinents via GitHub Code Search et les injecte dans les prompts. Les prompts incluent un résumé de la structure du projet plutôt que le texte complet pour économiser des tokens. Prend en charge l'intégration des descriptions d'Issues et des discussions de PR associées dans le contexte pour comprendre l'intention de la tâche et les standards du projet. L'historique des conversations est conservé au sein d'une seule session ; pas de mémoire automatique inter-sessions (nécessite de s'appuyer sur les Issues/PRs ou les READMEs pour transporter les informations inter-sessions).Construit un index vectoriel pour le projet au démarrage afin de prendre en charge la recherche sémantique. Les prompts du modèle se concentrent sur le contexte de code actuellement fourni par l'utilisateur (fichiers ou extraits ouverts) ; lorsque d'autres parties sont nécessaires, elles sont récupérées via la pertinence sémantique et insérées. Fournit un mécanisme de fichier .cursor/rules, permettant aux développeurs de définir des connaissances et des standards permanents pour le projet ; l'Agent lit ces règles dans chaque conversation, équivalent à une mémoire à long terme fournie par l'humain. Pas de mémoire automatique inter-sessions par défaut (nécessite que l'utilisateur enregistre manuellement dans les fichiers de règles).Indexation sémantique complète du projet : pré-scanne localement l'ensemble de la base de code pour construire un index ; Cascade peut récupérer n'importe quel contenu de fichier comme contexte à tout moment. Comprend un système de Mémoires qui enregistre automatiquement et de manière persistante le contenu important des conversations et les notes/règles spécifiées par l'utilisateur, réalisant ainsi une mémoire inter-sessions. Ainsi, Cascade "se souvient" des conventions du projet et des discussions précédentes même après un redémarrage. Intègre également l'état de l'environnement IDE comme source de contexte : perception en temps réel des fichiers ouverts par l'utilisateur, position du curseur, sortie du terminal, etc., utilisant cette information implicite pour comprendre l'intention de l'utilisateur. Globalement, Cascade a une vue de contexte plus large et plus dynamique.
Outils et extensionsIntégration profonde avec le workflow GitHub : L'Agent obtient un environnement de développement isolé dans le cloud via GitHub Actions, capable d'exécuter des tests unitaires, de lancer des projets, etc. Les outils intégrés incluent la lecture de fichiers, la recherche de dépôts, l'application de changements de code, les commandes de terminal, etc., que le LLM peut appeler au besoin. Introduit la norme MCP (Model Context Protocol), prenant en charge la connexion à des sources de données et services externes ; les plugins MCP officiels peuvent accéder aux données GitHub, et une interface ouverte globale pour les extensions tierces. Possède des capacités de vision par ordinateur, peut analyser les captures d'écran jointes aux Issues comme base de problème.Fournit des outils riches de manipulation d'IDE, guidés précisément par des prompts système sur leur utilisation (par exemple, exigeant de l'IA de lire le contenu du fichier avant de le modifier, évitant l'écriture aveugle non basée sur le contexte). Atteint la capacité de plugin via l'interface MCP, permettant la connexion à des outils/sources de données personnalisés pour étendre les capacités de l'Agent. Par exemple, les développeurs peuvent ajouter un plugin de requête de base de données pour permettre à l'Agent Cursor d'utiliser les dernières informations de schéma de base de données dans le code. L'Agent Cursor suit strictement les règles prédéfinies pour l'utilisation des outils (par exemple, expliquer les actions avant d'appeler), améliorant la prévisibilité de l'interaction.Intégration d'outils la plus complète : Cascade a un contrôle opérationnel étendu sur l'éditeur et le système, du système de fichiers au terminal. Prend en charge l'exécution automatique de commandes (par exemple, build, test) et l'utilisation des résultats pour les actions ultérieures. À partir de Wave 3, prend en charge les plugins MCP, permettant aux services externes de devenir des outils de Cascade via la configuration JSON, tels que les API de cartes, les interfaces de base de données, etc. Cascade surveille également l'état de l'IDE (contenu du presse-papiers, sélection actuelle, etc.) pour des réponses plus intelligentes. Pour la sécurité, Windsurf exige la confirmation de l'utilisateur pour les changements critiques et une pré-configuration pour les appels de services externes afin de prévenir les abus. Globalement, Cascade est presque équivalent à un partenaire de développement IA avec des capacités de plugin IDE et de script Shell.
Compromis d'ingénierie et innovationIntégration de la plateforme : tire pleinement parti de l'infrastructure GitHub existante (Actions, mécanismes de PR, etc.) pour héberger l'Agent. Sécurité avant tout : politiques intégrées pour empêcher le code non révisé d'affecter directement la branche principale et l'environnement de production. Proposition de la norme ouverte MCP, pionnière dans l'exploration industrielle d'une solution universelle pour que les LLM appellent des outils externes. Transparence : permet aux utilisateurs de consulter les journaux d'exécution de l'Agent pour comprendre son processus de prise de décision, augmentant la confiance. L'innovation réside dans l'intégration profonde de l'IA à diverses étapes du workflow de développement pour réaliser un développement collaboratif humain-IA en boucle fermée.Service cloud : l'architecture cloud choisie assure la performance des grands modèles et une gestion unifiée, mais sacrifie la capacité hors ligne. Prompts affinés : transformer les LLM en assistants de code professionnels repose sur une vaste collection de prompts système et d'instructions d'outils ; l'investissement de Cursor dans ce domaine a rendu sa qualité de génération très appréciée. Supervision humaine : préfère une étape supplémentaire de confirmation humaine plutôt que de donner à l'IA une liberté totale de modifier le code — cette stratégie conservatrice réduit les risques d'erreur et renforce la confiance de l'utilisateur. Personnalisation : grâce aux fichiers de règles et aux plugins, Cursor offre aux utilisateurs avancés des moyens de personnaliser le comportement de l'IA et d'étendre ses capacités, un avantage majeur en termes de flexibilité d'ingénierie.Centré sur l'humain : a introduit le mode Flux (Flows) pour lutter contre la faible efficacité de l'exécution asynchrone des premiers Agents, permettant une interaction en temps réel entre les actions de l'IA et les humains. Intégration de contexte extrême : indexation de code locale + mémoire inter-sessions + surveillance du comportement de l'IDE, créant l'Agent d'acquisition d'informations le plus complet actuellement dans l'industrie. Adapté aux entreprises : a investi dans des modèles auto-développés et le déploiement privé pour répondre aux exigences de sécurité et de conformité. Assurance qualité : Cascade assure la fiabilité des changements automatisés à grande échelle en exécutant automatiquement des tests et en exigeant une révision humaine. L'innovation de Windsurf réside dans la recherche d'un équilibre entre l'automatisation et le contrôle humain : permettre à l'IA d'améliorer significativement l'efficacité du développement tout en évitant l'emballement de l'IA ou des résultats de faible qualité grâce à une conception architecturale intelligente.

Enfin, cette recherche est basée sur les blogs officiels, les partages de développeurs et les matériaux techniques connexes de