Carte d’application : agents GitHub Copilot

Découvrez comment utiliser GitHub Copilot fonctionnalités agentiques de manière responsable en comprenant leurs objectifs, fonctionnalités et limitations.

Dans cet article

Qu’est-ce qu’une carte de demande ?

GitHub’s application and platform cards are intended to help you understand how our AI technology works, the choices application owners can make that influence application performance and behavior, and the importance of considering the whole application, including the technology, the people, and the environment. Application cards are created for AI applications and platform cards are created for AI platform services. These resources can support the development or deployment of your own applications and can be shared with users or stakeholders impacted by them.

As part of its commitment to responsible AI, GitHub adheres to Microsoft's six core principles: fairness, reliability and safety, privacy and security, inclusiveness, transparency, and accountability. These principles are embedded in the Responsible AI Standard, which guides teams in designing, building, and testing AI applications. Application and Platform Cards play a key role in operationalizing these principles by offering transparency around capabilities, intended uses, and limitations. For further insight, readers are encouraged to explore Microsoft’s Responsible AI Transparency Report and Termes GitHub.

1. Vue d’ensemble

GitHub Copilot inclut plusieurs fonctionnalités agentiques qui vont au-delà de la suggestion et de la conversation, elles peuvent passer en revue le code, prendre des mesures en votre nom et créer des applications. Cette carte couvre les expériences suivantes :

  • Vérification du code par Copilot : examine les modifications et les métadonnées des pull requests sur GitHub.com, et génère des commentaires de retour ainsi que des modifications suggérées.

  • agent cloud Copilot: Un agent asynchrone sur GitHub.com qui peut créer des branches, écrire du code et ouvrir des pull requests en réponse aux tickets qui lui sont attribués. L’agent cloud s’exécute dans un environnement éphémère et pare-feu avec analyse automatisée de la sécurité.

  • Copilot CLI : outil en ligne de commande qui peut créer et modifier des fichiers, exécuter des commandes et effectuer des tâches à plusieurs étapes. Toutes les actions nécessitent des invites d’autorisation explicites et sont limitées au répertoire actif.

  • Copilot SDK : bibliothèque programmatique qui permet aux développeurs de créer des applications basées sur l’IA personnalisées à l’aide de Copilot. Le SDK communique avec Copilot CLI sur JSON-RPC et prend en charge les agents personnalisés, les intégrations de serveur MCP, les hooks de cycle de vie et la gestion de session.

  • GitHub Spark (préversion) : expérience de création d’applications managée où un agent écrit du code et exécute des commandes dans un environnement de développement. Spark fournit un runtime managé et peut ajouter des fonctionnalités d’inférence via le SDK GitHub Models.

Ces fonctionnalités partagent des principes communs : surveillance humaine, examen des sorties et utilisation responsable, mais diffèrent dans leurs environnements d’exécution, autorisations et flux de données. Les sections ci-dessous décrivent chaque expérience dans le contexte.

2. Termes clés

La liste suivante fournit un glossaire des termes clés liés à GitHub Copilot Agents :

  • Suggestion de code : modification de code spécifique proposée par la revue de code Copilot dans le cadre de son retour sur une demande de fusion. Les suggestions de code sont présentées sous forme de modifications suggérées qui peuvent être appliquées en quelques clics.

  • Filtrage du contenu : système de sécurité qui analyse les invites et les réponses pour détecter et bloquer le contenu dangereux, offensant ou non sécurisé avant de l’afficher à l’utilisateur.

  • Custom instructions : descriptions en langage naturel du style de codage et meilleures pratiques qu'un responsable de référentiel peut configurer pour guider les commentaires de Copilot révision de code. Les instructions personnalisées aident Copilot comprendre les conventions et normes d’une base de code spécifique.

  • Hallucination : phénomène où un modèle de langage génère une sortie qui sonne plausible, mais qui est factuelment incorrect, non pris en charge par le contexte fourni, ou entièrement fabriqué. Dans la révision du code, l’hallucination peut se manifester en tant que commentaires qui mettent en évidence les problèmes qui n’existent pas ou sont basés sur des malentendus du code.

  • Modèle de langage volumineux (LLM) : type de réseau neuronal formé sur un grand corps de données de texte pouvant générer, analyser et transformer le langage naturel et le code. Copilot Agents utilisent une ou plusieurs machines virtuelles LL pour traiter le contexte et produire des réponses.

  • Environnement de développement éphémère : environnement de calcul temporaire isolé créé pour chaque session d’agent cloud. L’environnement est détruit une fois la session terminée, ce qui garantit qu’aucun état n’est conservé entre les exécutions.

  • Pare-feu : contrôle au niveau du réseau activé par défaut pour l’agent cloud qui empêche les connexions sortantes à des hôtes non autorisés, protégeant contre l’exfiltration accidentelle ou malveillante du code ou des données.

  • crédit IA : Une unité de consommation pour les fonctionnalités Copilot. Chaque utilisation de la révision de code Copilot consomme des crédits d’IA.

  • Demande d’autorisation : étape de confirmation interactive dans Copilot CLI qui demande à l’utilisateur d’approuver une action, consistant par exemple à modifier un fichier, exécuter une commande ou accéder à des fichiers en dehors du répertoire courant, avant que l’agent ne poursuive. Les invites d’autorisation sont un mécanisme de sécurité clé pour l’exécution agentique locale.

  • Copilot SDK : bibliothèque programmatique (@github/copilot-sdk) qui permet aux développeurs de créer des applications personnalisées basées sur l’IA en créant des sessions, en envoyant des invites et en recevant des réponses de streaming à partir de Copilot. Le Kit de développement logiciel (SDK) communique avec Copilot CLI via JSON-RPC.

  • JSON-RPC : protocole de communication utilisé entre le SDK Copilot et l’interface CLI Copilot. Le Kit de développement logiciel (SDK) envoie des requêtes structurées au processus CLI, qui gère l’interaction du modèle et l’exécution des outils.

  • Agent personnalisé (SDK) : une configuration d’agent nommée au sein du SDK, qui possède son propre prompt système, des outils définis dans son périmètre et des serveurs MCP facultatifs. Le runtime du SDK peut déléguer automatiquement aux sous-agents en fonction de l’intention de l’utilisateur.

  • Hooks (SDK) : rappels de cycle de vie dans le SDK Copilot qui permettent aux développeurs d’injecter une logique personnalisée à des points spécifiques pendant une session, comme avant ou après l’utilisation de l’outil, au démarrage ou à la fin de la session, et en cas d’erreur.

  • ** Runtime managé** : environnement d'hébergement entièrement managé fourni par GitHub Spark qui s'adapte aux besoins de votre application et élimine la nécessité de gérer manuellement l'infrastructure.

  • Spark : application créée à l’aide de GitHub Spark. Les Sparks peuvent aller de simples utilitaires à des applications web full-stack et être déployés sur l’Internet public avec une visibilité configurable.

  • ** Modifier** : fonctionnalité de GitHub Spark qui vous permet de sélectionner un élément spécifique au sein de votre application et de fournir une invite ciblée pour affiner son style, sa substance ou son comportement, au lieu d’appliquer un changement global.

3. Fonctionnalités clés

Les principales fonctionnalités et capacités présentées ici décrivent ce pour quoi les agents GitHub Copilot sont conçus et comment ils exécutent les tâches prises en charge.

  • Commentaires automatisés sur la révision du code : lorsqu’un utilisateur demande une révision à Copilot, il analyse les modifications apportées au code ainsi que tout contexte supplémentaire pertinent et fournit des commentaires sur le code. Les commentaires peuvent inclure des commentaires en langage naturel et des suggestions de code spécifiques liées à des lignes et fichiers particuliers.

  • Conseils de révision personnalisables : la révision de code avec Copilot peut être personnalisée grâce à des instructions personnalisées — des descriptions en langage naturel du style de codage et des bonnes pratiques — afin que les retours reflètent les conventions et les normes d'un référentiel.

  • ** Création d’une demande de tirage automatique** : l’agent cloud Copilot peut récupérer une tâche à partir d’un problème, un commentaire de demande de tirage ou Copilot Chat, créer une branche, générer des modifications de code personnalisées et ouvrir une demande de tirage. Une fois la pull request initiale créée, l’agent peut itérer à partir de vos commentaires et retours.

  • Exécution éphémère et pare-feu : tout en travaillant sur une tâche, l’agent cloud a accès à son propre environnement de développement éphémère où il peut apporter des modifications au code, exécuter des tests automatisés et exécuter des linters. Un pare-feu est activé par défaut pour empêcher l’exfiltration des données.

  • Analyse automatisée de la sécurité : pendant la génération du code, l’agent cloud analyse automatiquement le code nouvellement généré pour détecter les vulnérabilités de sécurité à l’aide de CodeQL, de l’analyse des secrets et de l’analyse des dépendances, et tente de résoudre les problèmes avant leur introduction.

  • intégrations externales : l’agent cloud peut recevoir des informations et du contexte de MCP, tels que workIQ et Microsoft 365, et des applications externes telles que Microsoft Teams, Linear, Slack et Jira, ce qui permet aux équipes d’attribuer des tâches et de suivre la progression directement dans leurs flux de travail existants.

  • Exécution agentique locale (Copilot CLI) : Copilot CLI fournit une interface de type conversation dans le terminal qui peut créer et modifier de manière autonome des fichiers, exécuter des commandes et effectuer des tâches à plusieurs étapes. Toutes les actions sont limitées au répertoire actif et nécessitent des invites d’autorisation explicites avant que l’agent modifie les fichiers ou exécute des commandes.

  • Natural Language App Building (Spark) : GitHub Spark offre un environnement de développement centré sur le langage naturel pour la création et le déploiement d’applications web complètes sans que les utilisateurs n’écrivent ou déploient du code manuellement. Spark fournit un environnement d’exécution entièrement managé qui s’adapte aux besoins de votre application.

  • ** Fonctionnalités d'inférence (Spark)** : le Kit de développement logiciel (SDK) spark s'intègre en mode natif à GitHub Models, ce qui vous permet d'incorporer l'inférence de modèle dans votre application. Si Spark détermine que votre application nécessite des fonctionnalités d’inférence, elle les ajoute à l’aide du Kit de développement logiciel (SDK) Spark.

4. Utilisations prévues

GitHub Copilot Agents peuvent être utilisés dans plusieurs scénarios dans divers secteurs d’activité. Voici quelques exemples de cas d’usage :

  • Compléter la revue de code humaine : Copilot code review vise à fournir rapidement des retours sur le code d’un développeur, ce qui permet aux développeurs de finaliser le code en vue de sa fusion plus rapidement et ainsi d’améliorer la qualité globale du code.

  • Maintenance de Codebase : l’agent cloud peut s’attaquer aux correctifs liés à la sécurité, aux mises à niveau des dépendances et à la refactorisation ciblée.

  • Développement de fonctionnalités : l’agent cloud peut implémenter des demandes de fonctionnalités incrémentielles, développer des suites de test supplémentaires et créer ou mettre à jour la documentation.

  • Prototypage de nouveaux projets : l’agent cloud et l’interface CLI Copilot peuvent mettre en place de nouveaux concepts, ce qui permet aux développeurs d’explorer rapidement des idées.

  • Setting up your environment (CLI)  : Copilot CLI peut exécuter des commandes dans votre terminal pour configurer votre environnement local pour travailler sur des projets existants.

  • Finding the right command (CLI)  : Copilot CLI peut suggérer des commandes pour effectuer des tâches que vous essayez de terminer et expliquer des commandes inconnues dans le langage naturel.

  • Building custom AI applications (SDK) : le sdk Copilot permet aux développeurs de créer des applications qui tirent parti de Copilot pour la génération de code, l’interaction en langage naturel et l’automatisation des tâches dans leurs propres produits et flux de travail.

  • Orchestration multi-agent (SDK) : à l’aide d’agents personnalisés et de sous-agents, les développeurs peuvent créer des workflows sophistiqués où plusieurs agents spécialisés collaborent sur des tâches complexes, avec délégation automatique basée sur l’intention de l’utilisateur.

  • Extension d’applications avec des outils externes (SDK) : la prise en charge du serveur MCP du SDK permet aux développeurs de connecter leurs applications à des sources et services de données externes, en développant la gamme de tâches que leurs agents peuvent effectuer.

  • Création et déploiement d’applications web (Spark) : vous pouvez utiliser GitHub Spark pour créer des applications web full-stack à l’aide du langage naturel. L'environnement d'exécution intégré de Spark vous permet de déployer ces applications sur l'Internet public avec une visibilité configurable en fonction des autorisations de compte GitHub.

  • Prototypage rapide (Spark) : Spark aide les développeurs, les concepteurs, les responsables de produits et d’autres constructeurs à prototyper rapidement des idées sans avoir à créer d’applications à partir de zéro ou à construire des maquettes complexes. Les prototypes peuvent être déployés pour faciliter le partage ou rester non publiés.

5. Modèles et données d’entraînement

GitHub Copilot Agents tirent parti d’un large éventail de modèles IA pour alimenter l’expérience que les utilisateurs voient. Pour obtenir une comparaison des modèles disponibles pour Copilot, consultez Comparaison des modèles IA. Pour obtenir la liste complète des modèles pris en charge, consultez Modèles IA pris en charge dans GitHub Copilot. Pour plus d’informations sur l’emplacement d’hébergement des modèles, consultez Hébergement de modèles pour GitHub Copilot. Pour en savoir plus sur les données utilisées pour entraîner les modèles de base derrière GitHub Copilot Agents, reportez-vous à la comparaison des modèles IA liés ci-dessus et Quelles données ont GitHub Copilot été formées sur ? dans la FAQ GitHub Copilot.

Copilot Code Review est un produit spécialement conçu qui utilise un mélange soigneusement ajusté de modèles, d’instructions et de comportements du système pour fournir des retours cohérents et de haute qualité dans un large éventail de bases de code. Le changement de modèle n’est pas pris en charge, car cela risquerait de compromettre la fiabilité, l’expérience utilisateur et la qualité des commentaires de révision. La révision de code par Copilot peut utiliser des modèles qui ne sont pas activés sur la page des paramètres « Modèles » de votre organisation.

L’agent cloud Copilot utilise un modèle de langage volumineux pour raisonner sur les tâches, générer du code et tirer parti d’outils dans son environnement de développement éphémère. L’agent a été évalué dans divers langages de programmation. L’anglais est la principale langue prise en charge pour les requêtes et les réponses.

Copilot CLI utilise un modèle de langage volumineux pour raisonner les tâches, générer du code, modifier des fichiers et exécuter des commandes dans votre environnement de terminal local. L’agent a été évalué dans divers langages de programmation. L’anglais est la principale langue prise en charge pour les prompts et les réponses.

Le sdk Copilot communique avec Copilot CLI via JSON-RPC, à l’aide des mêmes modèles et fonctionnalités sous-jacents. Les applications créées avec le Kit de développement logiciel (SDK) utilisent les mêmes modèles que ceux disponibles pour l’utilisateur ou l’organisation authentifiés Copilot. Les développeurs peuvent également apporter leurs propres clés API (BYOK) pour utiliser des fournisseurs de modèles personnalisés.

GitHub Spark utilise un modèle de langage volumineux pour alimenter son agent dans l’environnement de développement. L’agent écrit du code et exécute des commandes pour générer votre application. Le Kit de développement logiciel (SDK) de Spark s'intègre en mode natif à GitHub Models, ce qui permet à votre application d'incorporer des fonctionnalités d'inférence de modèle. Pour plus d’informations sur les modèles utilisés par GitHub Models, consultez Utilisation responsable des modèles GitHub. Spark ne teste pas les prompts que vous créez dans votre application et qui sont utilisés pour l’inférence — vous devez vous assurer que les capacités intégrées fonctionnent comme prévu.

6. Performances

Différences par expérience

agent Copilot de cloud

L’agent cloud Copilot fonctionne à l’aide d’une combinaison de traitement du langage naturel et de Machine Learning pour comprendre votre tâche et apporter des modifications dans une base de code. Ce processus peut être divisé en plusieurs étapes :

  1. Traitement du prompt : la tâche fournie via un ticket, un commentaire sur une pull request ou un message dans Copilot Chat est combinée à d’autres informations contextuelles pertinentes pour former un prompt. Cette invite est envoyée à un modèle de langage étendu pour le traitement. Les entrées peuvent prendre la forme d’un langage naturel brut, d’extraits de code ou d’images.
  2. Analyse du modèle de langage : l’invite est transmise via un modèle de langage volumineux, qui est un réseau neuronal formé sur un grand corps de données. Le modèle de langage analyse l’invite d’entrée pour aider l’agent à raisonner sur la tâche et tirer parti des outils nécessaires.
  3. Génération de réponse : le modèle de langage génère une réponse en fonction de son analyse de l’invite. Cette réponse peut prendre la forme de suggestions en langage naturel et de suggestions de code.
  4. Formatage de la sortie : une fois que l’agent a terminé sa première exécution, il met à jour la description de la pull request avec les modifications qu’il a apportées. L’agent peut inclure des informations supplémentaires sur les ressources auxquelles il n’a pas pu accéder et fournir des suggestions sur les étapes à résoudre. Vous pouvez donner votre avis en laissant un commentaire dans la pull request ou en mentionnant explicitement l’agent (@copilot). L’agent soumette ensuite à nouveau ces commentaires pour une analyse plus approfondie et répond avec les modifications mises à jour.

Copilot’agent cloud est destiné à fournir la solution la plus pertinente pour la résolution des tâches. Cependant, il peut ne pas toujours fournir la réponse que vous recherchez. Vous êtes responsable de l’examen et de la validation des réponses générées par Copilot agent cloud pour vous assurer qu’elles sont précises et appropriées.

révision du code Copilot

La révision de code Copilot analyse votre code et fournit des commentaires à l’aide d’une combinaison de traitement du langage naturel et d’apprentissage automatique. Ce processus peut être divisé en plusieurs étapes :

  1. Traitement des entrées : les modifications de code sont combinées avec d’autres informations contextuelles pertinentes (par exemple, le titre et la description de la pull request), ainsi qu’avec les éventuelles instructions personnalisées définies, afin de former une requête. Ce prompt est envoyé à un grand modèle de langage.
  2. Language model analysis : l’invite est transmise via le modèle de langage Copilot, qui est un réseau neuronal formé sur un grand corps de données de texte. Le modèle de langage analyse l'invite de saisie.
  3. Génération de réponse : le modèle de langage génère une réponse en fonction de son analyse de l’invite d’entrée. Cette réponse peut prendre la forme de suggestions en langage naturel et de suggestions de code.
  4. Mise en forme de la sortie : la réponse est présentée à l’utilisateur, soit directement dans un éditeur pris en charge, soit sous la forme d’une revue de demande de tirage sur GitHub.com, avec des commentaires sur le code associés à des lignes précises dans des fichiers précis. Lorsque Copilot a fourni une suggestion de code, la suggestion est présentée sous la forme d’une modification suggérée, qui peut être appliquée en quelques clics.

Copilot CLI

Copilot CLI fonctionne à l’aide d’une combinaison de traitement du langage naturel et de Machine Learning pour comprendre votre tâche et apporter des modifications dans une base de code. Ce processus peut être divisé en plusieurs étapes :

  1. Traitement des entrées : votre saisie est combinée à des informations contextuelles pertinentes pour former un prompt. Cette invite est envoyée à un modèle de langage étendu pour le traitement. Les entrées peuvent prendre la forme d’un langage naturel brut, d’extraits de code ou de références à des fichiers dans votre terminal.
  2. Analyse du modèle de langage : l’invite est transmise via un modèle de langage volumineux, qui est un réseau neuronal formé sur un grand corps de données. Le modèle de langage analyse l’invite d’entrée pour aider l’agent à raisonner sur la tâche et à utiliser les outils nécessaires.
  3. Génération de réponse : le modèle de langage génère une réponse en fonction de son analyse de l’invite. Cette réponse peut prendre la forme de suggestions de langage naturel, de suggestions de code, de modifications de fichier et d’exécutions de commandes.
  4. Mise en forme de sortie : la réponse est mise en forme et présentée à l’aide de la mise en surbrillance de la syntaxe, de la mise en retrait et d’autres fonctionnalités de mise en forme. L’agent peut également exécuter des commandes dans votre environnement local et créer, modifier ou supprimer des fichiers dans votre système de fichiers afin d’effectuer la tâche. Toutes ces actions nécessitent des invites d’autorisation explicites.

Vous pouvez fournir des commentaires à l’agent une fois qu’il a retourné une réponse dans la fenêtre de conversation interactive. L’agent soumette à nouveau ces commentaires au modèle de langue pour une analyse plus approfondie et retourne une réponse supplémentaire.

Kit de développement logiciel (SDK) Copilot

Le SDK Copilot fournit une interface programmatique pour les fonctionnalités agentiques de Copilot. Les applications créées avec le Kit de développement logiciel (SDK) suivent ce processus :

  1. Création de session : l’application crée une session avec le Kit de développement logiciel (SDK), en spécifiant le modèle, l’invite système, les outils disponibles, les agents personnalisés, les serveurs MCP et les hooks. Le Kit de développement logiciel (SDK) établit une connexion JSON-RPC à Copilot CLI.
  2. Soumission du prompt : la saisie de l’utilisateur est transmise à la session. Le Kit de développement logiciel (SDK) achemine l’invite (ainsi que le contexte de session) vers l’interface CLI, qui la transfère au modèle de langage.
  3. Exécution de l’agent : les raisons du modèle de langage concernant la tâche et peuvent appeler des outils, déléguer à des sous-agents ou se connecter à des serveurs MCP. Les hooks de cycle de vie sont exécutés à chaque étape, permettant à l’application d’injecter une logique personnalisée.
  4. Diffusion en continu de la réponse : les réponses sont renvoyées à l’application, ce qui peut les présenter dans n’importe quel format approprié pour son interface. Le Kit de développement logiciel (SDK) fournit des événements structurés pour le texte, les appels d’outils, les erreurs et les signaux d’achèvement.

GitHub Spark

GitHub Spark utilise une approche basée sur un agent pour générer et modifier des applications. Ce processus peut être divisé en plusieurs étapes :

  1. Input processing : Les invites d’entrée sont prétraitées par Copilot, augmentées avec des informations contextuelles de vos entrées Spark actuelles, y compris le code de votre application actuelle, les invites précédentes et les journaux d’erreurs de votre environnement de développement, et envoyées à un agent basé sur un modèle de langage volumineux au sein de votre environnement de développement. Le système est conçu pour générer du code basé sur des invites envoyées et n’est pas capable d’interactions conversationnelles. L’anglais est la langue privilégiée pour les prompts.
  2. Analyse du modèle de langage : l’invite est transmise via un modèle de langage volumineux, qui est un réseau neuronal formé sur un grand corps de données de texte. Le modèle de langage analyse l’invite d’entrée pour aider l’agent à raisonner sur la tâche et tirer parti des outils nécessaires.
  3. Exécution de l’agent : l’agent s’exécute dans votre environnement de développement, acceptant l’invite et le contexte supplémentaire, et décide comment mettre à jour votre application. L’agent peut écrire du code, exécuter des commandes et lire des sorties d’exécution. Toutes les actions sont effectuées pour garantir le code fonctionnel et précis. La seule sortie de l'agent est le code de votre application.

Spark utilise des frameworks et des kits sdk qui garantissent une conception moderne et des déploiements sécurisés intégrés en toute transparence au composant runtime de Spark. L’infrastructure de conception est flexible et modulaire, ce qui vous permet de modifier le thème pour qu’il corresponde à votre apparence souhaitée. L’intégration au runtime de Spark utilise les meilleures pratiques pour les déploiements web afin de garantir des déploiements sécurisés et évolutifs.

7. Limitations

Comprendre les limites des fonctionnalités agentiques de GitHub Copilot est essentiel pour garantir qu’elles sont utilisées dans un cadre sûr et efficace. Même si nous encourageons les clients à tirer parti de ces fonctionnalités dans leurs solutions ou applications innovantes, il est important de noter qu’ils n’ont pas été conçus pour chaque scénario possible. Nous encourageons les utilisateurs à faire référence à Termes GitHub ainsi que les considérations suivantes lors du choix d’un cas d’usage :

  • Problèmes de qualité du code non détectés : Copilot peut ne pas identifier tous les problèmes présents dans le code, en particulier lorsque les modifications sont volumineuses ou complexes. Pour garantir que tous les problèmes pertinents sont identifiés et corrigés, la revue de code de Copilot doit être complétée par une revue de code humaine minutieuse.

  • Faux positifs : la revue de code de Copilot comporte un risque d’hallucination : elle peut signaler des problèmes dans le code examiné qui n’existent pas ou qui reposent sur une mauvaise interprétation du code. Les commentaires générés par Copilot révision du code doivent être soigneusement examinés et pris en compte avant de prendre des mesures et d’apporter des modifications.

  • Suggestions de code inexactes ou non sécurisées : dans ses commentaires, la révision de code de Copilot peut fournir des suggestions de code spécifiques. Le code généré peut sembler valide, mais peut ne pas réellement être sémantiquement ou syntactiquement correct, ou ne pas résoudre correctement le problème identifié dans le commentaire. De plus, le code généré par Copilot peut contenir des vulnérabilités de sécurité ou d’autres problèmes. Vous devez toujours examiner et tester attentivement le code généré par Copilot.

  • Biais potentiels : les données d'entraînement de Copilot sont tirées de dépôts de code existants, qui peuvent contenir des biais et des erreurs que l'outil peut perpétuer. En outre, la révision de code par Copilot peut favoriser certains langages de programmation ou certains styles de codage, ce qui peut entraîner des retours sous-optimaux ou incomplets.

  • Étendue limitée (agent cloud) : le modèle de langage utilisé par l’agent cloud a été formé sur un grand corps de code, mais a toujours une étendue limitée et peut ne pas être en mesure de gérer certaines structures de code ou langages de programmation obscurs. Pour chaque langue, la qualité des suggestions dépend du volume et de la diversité des données d’apprentissage pour cette langue.

  • Code incorrect (agent cloud) : l’agent cloud peut générer du code qui semble être valide, mais peut ne pas réellement être sémantiquement ou correctement correct, ou peut ne pas refléter avec précision l’intention du développeur. Vous devez examiner et tester soigneusement le code généré, en particulier quand vous traitez des applications critiques ou sensibles.

  • Risques de sécurité (agent cloud) : l’agent cloud génère du code et du langage naturel en fonction du contexte d’un problème ou d’un commentaire au sein d’un référentiel, ce qui peut exposer des informations sensibles ou des vulnérabilités si elles ne sont pas utilisées avec soin. Vous devez passer en revue toutes les sorties générées par l’agent soigneusement avant la fusion.

  • Correspondances de code public (agent cloud) : l’agent cloud peut générer du code qui est une correspondance ou une correspondance proche du code disponible publiquement, même si la stratégie « Suggestions correspondant au code public » est définie sur « Bloquer ». Si cela se produit, Copilot affichera les correspondances dans les journaux de session de l’agent, avec un lien permettant d’afficher les détails du code correspondant.

  • Limited scope (CLI) : le modèle de langage utilisé par Copilot CLI a été formé sur un grand corps de code, mais a toujours une étendue limitée et peut ne pas être en mesure de gérer certaines structures de code ou langages de programmation obscurs. Pour chaque langue, la qualité des suggestions dépend du volume et de la diversité des données d’apprentissage pour cette langue.

  • Inaccurate code (CLI) : Copilot CLI peut générer du code qui semble être valide, mais peut ne pas réellement être sémantiquement ou syntactiquement correct, ou peut ne pas refléter avec précision l’intention du développeur. Vous devez examiner et tester soigneusement le code généré, en particulier quand vous traitez des applications critiques ou sensibles.

  • ** Risques de sécurité (CLI)** : Copilot CLI génère du code et du langage naturel en fonction du contexte de votre environnement local, ce qui peut exposer des informations sensibles ou des vulnérabilités si elles ne sont pas utilisées avec soin. Vous devez examiner attentivement tous les résultats générés par l’agent.

  • Correspondances avec du code public (CLI) : Copilot CLI peut générer du code identique ou quasi identique à du code accessible publiquement, même si la stratégie « Suggestions correspondant au code public » est définie sur « Bloquer ».

  • Command execution risks (CLI)  : Une attention supplémentaire est requise lorsque vous demandez ou autorisez Copilot CLI à exécuter une commande, en particulier en ce qui concerne la destruction potentielle de certaines commandes suggérées. Vous pouvez rencontrer des commandes pour la suppression de fichiers ou le formatage du disque dur, ce qui peut entraîner des problèmes si elles ne sont pas utilisées correctement. Vous êtes finalement responsable des commandes exécutées par Copilot CLI.

  • ** Limitations (SDK)** : étant donné que le KIT de développement logiciel (SDK) Copilot communique avec Copilot CLI, les applications créées avec le SDK héritent des mêmes limitations de modèle, y compris l’étendue limitée de certains langages de programmation et le potentiel de génération de code inexacte ou non sécurisée.

  • Complexité de l’agent personnalisé (SDK) : les agents, outils ou hooks personnalisés configurés de manière incorrecte peuvent produire un comportement inattendu. Les développeurs sont chargés de tester et de valider le comportement de leurs configurations d’agent personnalisées.

  • Confiance accordée au serveur MCP (SDK) : les serveurs MCP connectés via le SDK peuvent exposer des outils et des données provenant de sources externes. Les développeurs doivent s’assurer que les serveurs MCP connectés sont fiables, car les serveurs malveillants ou mal configurés peuvent introduire un comportement dangereux ou exposer des données sensibles.

  • BYOK model variance (SDK) : lorsque vous utilisez des configurations bring-your-own-key avec des fournisseurs de modèles tiers, le comportement peut différer des modèles hébergés par GitHub. Les développeurs sont responsables de l’évaluation de la sécurité et de la qualité des réponses de leur fournisseur choisi.

  • Interprétation de l’intention utilisateur (Spark) : Spark n’est pas toujours correct dans son interprétation de votre intention. Vous devez toujours utiliser la préversion fournie par Spark pour confirmer le comportement précis au sein de votre application.

  • Étendue limitée (Spark) : Spark a été formé sur un grand corps de code et d’applications pertinentes, mais peut lutter avec des applications complexes ou vraiment nouvelles. Spark fonctionne le mieux sur les scénarios d’application courants et personnels (par exemple, les outils de productivité, les aides à l’apprentissage, les utilitaires de gestion de la vie) et lorsque l’instruction en langue naturelle est fournie en anglais.

  • Correspondances de code public (Spark) : Spark peut générer du code qui est une correspondance ou une correspondance proche du code disponible publiquement, même si la stratégie « Suggestions correspondant au code public » est définie sur « Bloquer ». Dans ce cas, Copilot ne fournira pas de références de code pointant vers la source d’origine du code.

  • Limitations de sécurité (Spark) : alors que le runtime de Spark suit les meilleures pratiques pour le déploiement d’applications, il génère du code de manière probabiliste, ce qui peut potentiellement introduire des vulnérabilités, en particulier si ces vulnérabilités sont courantes dans le jeu d’entraînement. Vous devez faire preuve de prudence lorsque vous créez des applications qui gèrent des données personnelles ou sensibles et toujours examiner et tester soigneusement l'application générée.

8. Évaluations

Les évaluations des performances et de la sécurité évaluent si les applications IA fonctionnent de manière fiable et sécurisée en examinant des facteurs tels que la base, la pertinence et la cohérence, tout en identifiant les risques liés à la génération de contenu nuisible. Les évaluations suivantes ont été effectuées avec des composants de sécurité déjà en place, qui sont également décrits dans 9. Composants de sécurité et atténuations.

Évaluations des performances et de la qualité

GitHub Copilot Agents sont évalués sur ses surfaces prises en charge à l’aide d’une combinaison de benchmarks standard (par exemple, SWE-Bench) et de suites d’évaluation développées en interne. Les tâches de benchmark sont sources à partir de référentiels open source publics et de scénarios synthétiques ; Aucune requête utilisateur réelle ni code client n’est utilisée. Chaque évaluation inclut plusieurs exécutions indépendantes pour prendre en compte le nondéterminisme dans les sorties du modèle. Les métriques clés incluent le taux de résolution (pourcentage de tâches correctement terminées), l’efficacité des jetons, la latence et la fiabilité des appels d’outil. Les modèles sont réévalués lorsque des mises à jour sont effectuées et surveillées en continu en production via des taux d’erreur, une latence de réponse et des modèles d’utilisation agrégés.

Méthodes d’évaluation des performances et de la qualité

De nouveaux modèles pour les agents GitHub Copilot subissent un processus d’évaluation intermédiaire avant le déploiement. Les équipes d’intégrateur exécutent des suites de benchmark spécifiques à leur surface, testant le modèle sur des tâches de codage représentatives telles que les correctifs de bogues, la génération de code et la refactorisation multi-fichiers. Les résultats sont examinés par rapport aux bases de référence établies et aux modèles de production existants. Les modèles doivent respecter ou dépasser les performances de référence sur les métriques clés, telles que le taux de résolution, l’efficacité des jetons et la latence, avant de passer à l’étape suivante. Un comité d’examen interfonctionnel prend une décision formelle de lancement ou de non-lancement avant qu’un modèle ne soit approuvé pour un déploiement destiné aux utilisateurs.

Évaluations des risques et de la sécurité

L’évaluation des risques potentiels associés au contenu généré par l’IA est essentielle pour la protection contre les risques de contenu avec différents degrés de gravité. Cela inclut l’évaluation de la prédisposition d’une application IA à générer du contenu dangereux ou le test des vulnérabilités pour les attaques jailbreak. Pour GitHub, nous effectuons des évaluations de performances, y compris celles qui sont adaptées à des fins de codage provenant de Microsoft Foundry :

  • Haine et iniquité
  • Sexuelle
  • Violence
  • Auto-préjudice
  • Matériel protégé
  • Déverrouillage
  • Vulnérabilité du code

Données d’évaluation pour la qualité et la sécurité

Nos données d’évaluation sont personnalisées pour évaluer les performances des applications IA dans des domaines clés de sécurité et de qualité, en simulant des scénarios et des risques réels. Nous commençons par identifier les aspects pertinents de l’évaluation des préoccupations en fonction de la recherche multidisciplinaire et des commentaires d’experts. Ces préoccupations sont traduites en objectifs d’évaluation ciblés et guident la formulation des mesures d’évaluation. Pour safety, nous créons des prompts antagonistes pour susciter des réponses indésirables ou des réponses dans des cas limites, qui sont ensuite évalués par des annotateurs assistés par l’IA, entraînés à évaluer la conformité aux normes de GitHub. Pour la qualité, nous élaborons des prompts fondés sur des grilles d’évaluation, adaptés à des scénarios tels que l’évaluation d’applications et d’agents de génération augmentée par récupération (RAG). Les jeux de données sont organisés à partir de diverses sources, notamment des jeux de données synthétiques et publics pour simuler des scénarios utilisateur réels. À l’aide des jeux de données organisés, les deux évaluations subissent un affinement itératif et l’alignement humain pour améliorer l’efficacité et la fiabilité des métriques. Cette méthodologie constitue la base d’évaluations reproductibles et rigoureuses qui reflètent la façon dont les clients utilisent des évaluations pour améliorer l’IA.

Évaluations personnalisées

Les fonctionnalités agentiques de Copilot ont fait l’objet d’exercices de red teaming en matière d’IA responsable (RAI) afin d’identifier et de traiter les risques potentiels. Nous continuons à surveiller l’efficacité et l’innocuité de ces caractéristiques au fil du temps. Pour plus d’informations, consultez Microsoft AI Red Team construit l’avenir d’une IA plus sûre sur le blog Sécurité Microsoft.

9. Composants de sécurité et atténuations

agent Copilot de cloud

  • Contrôles d’escalade de privilèges : l’agent cloud répond uniquement aux interactions des utilisateurs disposant d’un accès en écriture au référentiel. Les workflows GitHub Actions déclenchés par des pull requests créées par l’agent nécessitent l’approbation d’un utilisateur disposant d’un accès en écriture avant de pouvoir s’exécuter. L’agent filtre les caractères invisibles qui pourraient permettre aux utilisateurs de dissimuler des instructions malveillantes dans les commentaires ou le contenu des tickets.
  • Autorisations contraintes : l’agent cloud a uniquement accès au référentiel où il crée une demande de tirage (pull request) et ne peut pas accéder à d’autres référentiels. Il ne peut pousser que vers une seule branche : soit la branche de la pull request existante lorsqu’il est déclenché via @copilot, soit vers une nouvelle branche copilot/. Cela signifie que Copilot ne peut pas push directement vers votre branche par défaut (par exemple main). L’agent n’a pas accès aux secrets de l’organisation Ou du référentiel Actions. Seuls les secrets et les variables spécifiquement ajoutés à l’environnement copilot sont transmis à l’agent.
  • Assurer la traçabilité : Les commits de l’agent cloud ont Copilot comme auteur, et la personne qui a démarré la tâche est indiquée comme coauteur. Cela facilite l’identification du code généré par l’agent et celui qui a lancé la tâche. Les validations de l'agent cloud sont signées, de sorte qu'elles apparaissent comme « Vérifiées » sur GitHub. Cela garantit que les validations ont été effectuées par GitHub Copilot agent cloud et n’ont pas été modifiées. Chaque message de validation inclut un lien vers les journaux de session de l’agent. Cela vous donne un lien permanent à partir de n’importe quelle validation créée par un agent vers les journaux de session complets. Vous pouvez donc comprendre pourquoi Copilot apporté une modification lors de la révision du code ou tracez-la ultérieurement à des fins d’audit.
  • Pare-feu pour la prévention de l’exfiltration des données : par défaut, l’agent cloud dispose d’un pare-feu activé pour empêcher l’exfiltration du code ou d’autres données sensibles, accidentellement ou en raison d’une entrée utilisateur malveillante.
  • Détection automatisée des vulnérabilités de sécurité : pendant la génération du code, l’agent cloud analyse automatiquement le code nouvellement généré pour détecter les vulnérabilités de sécurité et tente de les résoudre. L’analyse est effectuée à l’aide de CodeQL (pour identifier les vulnérabilités et erreurs potentielles), l’analyse des secrets (pour vous assurer que les secrets ne sont pas introduits) et l’analyse des dépendances (pour vérifier les vulnérabilités connues dans les dépendances référencées).

Copilot CLI

  • Accès limité au répertoire : par défaut, Copilot CLI a uniquement accès aux fichiers et dossiers situés dans le répertoire à partir duquel il a été invoqué, ainsi que dans ses sous-répertoires. Si l’agent souhaite accéder aux fichiers en dehors du répertoire actif, il demande l’autorisation.
  • Demandes d’autorisation pour la modification de fichiers : Copilot CLI demande l’autorisation avant toute modification de fichiers. Vous devez vous assurer qu’il modifie les fichiers appropriés avant d’accorder l’autorisation.
  • Permission invite à exécuter des commandes : Copilot CLI demande l’autorisation avant d’exécuter des commandes susceptibles d’être dangereuses. Vous devez examiner attentivement ces commandes avant de donner l’autorisation d’exécuter.
  • Autorisations configurables : vous pouvez accorder à Copilot CLI des autorisations spécifiques, ou toutes les autorisations, à l’aide des différentes options de ligne de commande : par exemple, --allow-tool=[TOOLS...], --allow-all-tools, --allow-all (ou sa commande slash équivalente /allow-all dans une session interactive). Pour plus d’informations, consultez « Référence de commande CLI pour GitHub Copilot ». En règle générale, lorsque vous utilisez Copilot CLI en mode Autopilot, vous lui accorderez des autorisations complètes pour lui permettre d’effectuer une tâche de manière autonome, sans avoir à approuver l’activité au fur et à mesure de son fonctionnement sur la tâche. Pour plus d’informations, consultez « Autoriser GitHub Copilot CLI à fonctionner de manière autonome ».
  • ** Considérations relatives à la sécurité** : Pour plus d’informations sur les pratiques de sécurité lors de l’utilisation de l’interface CLI Copilot, consultez À propos de GitHub Copilot CLI.

Kit de développement logiciel (SDK) Copilot

  • Contrôles de sécurité CLI hérités : le SDK Copilot communique avec Copilot CLI et hérite de son modèle d’autorisations et de ses contrôles de sécurité. Les exécutions d’outils et les modifications de fichier nécessitent toujours des autorisations appropriées.
  • Supervision basée sur les hooks : les hooks du cycle de vie du SDK (tels que onPreToolUse et onPostToolUse) permettent aux développeurs de mettre en place des contrôles de sécurité personnalisés, des journaux d’audit et des processus d’approbation avant et après l’exécution de l’outil.
  • Isolation du serveur MCP : les serveurs MCP s’exécutent en tant que processus distincts. Les développeurs peuvent contrôler les serveurs disponibles par session, ce qui limite l’étendue de l’accès aux outils externes.
  • Étendue de session : chaque session du SDK est isolée avec son propre contexte, ses outils et ses autorisations. Les développeurs peuvent contrôler les données et fonctionnalités disponibles dans chaque session.
  • Responsabilité BYOK : lors de l’utilisation de configurations bring-your-own-key, les invites et les réponses sont envoyées directement au fournisseur configuré. Les développeurs sont responsables de l’examen des stratégies de gestion des données de leur fournisseur choisi.

Gestion des données lors de l’utilisation de votre propre fournisseur de modèles (CLI)

Lorsque vous configurez Copilot CLI pour utiliser votre propre fournisseur de modèles, vos invites, contexte de code et réponses générées sont envoyées directement au fournisseur que vous configurez. Ils ne sont pas acheminés par GitHub. Vous êtes responsable de l’examen et de la conformité aux conditions d’utilisation et aux stratégies de gestion des données de votre fournisseur choisi.

Telemetry

Lorsque vous utilisez votre propre fournisseur de modèles sans mode hors connexion, Copilot CLI continue d’envoyer des données de télémétrie à GitHub comme d’habitude. Cette télémétrie n’inclut pas vos invites ou votre code, mais elle inclut des métadonnées d’utilisation.

Si vous activez le mode hors connexion en définissant la variable d’environnement COPILOT_OFFLINE sur true, la télémétrie est entièrement désactivée. En mode hors connexion, Copilot CLI effectue uniquement des requêtes réseau à votre fournisseur de modèles configuré.

Disponibilité des fonctionnalités et de l’authentification

L’authentification GitHub n’est pas requise lors de l’utilisation de votre propre fournisseur de modèles (BYOK). Sans authentification GitHub, les fonctionnalités suivantes ne sont pas disponibles :

  • /delegate, qui remet la session à l'Copilot côté serveur de GitHub
  • Le serveur GitHub MCP
  • Recherche de code GitHub

En mode hors connexion, les outils web tels que web_fetch et GitHub Recherche de code sont également désactivés.

Pas de secours aux modèles hébergés par GitHub

Si la configuration de votre fournisseur de modèles n’est pas valide, Copilot CLI se termine par une erreur. Il ne revient pas aux modèles hébergés par GitHub. Les échecs courants, tels qu’un refus de connexion, des erreurs d’authentification, un modèle introuvable et des dépassements de délai, génèrent des messages clairs accompagnés d’instructions utiles.

GitHub Spark

  • Protections de contenu : Spark dispose de protections intégrées contre les contenus dangereux, haineux ou offensants.
  • Signalement de contenu : vous pouvez signaler des contenus problématiques ou offensants via les commentaires, ou signaler un spark comme abusif ou comme spam. Des exemples de contenu offensant doivent être signalés à copilot-safety@github.com, accompagnés de l’URL du spark.
  • Runtime sécurisé : l’intégration au runtime de Spark utilise les meilleures pratiques pour les déploiements web afin de garantir des déploiements sécurisés et évolutifs.

10. Meilleures pratiques pour le déploiement et l’adoption de fonctionnalités agentiques GitHub Copilot

L’IA responsable est un engagement partagé entre GitHub et ses clients. Bien que GitHub crée des applications IA avec sécurité, équité et transparence au cœur, les clients jouent un rôle essentiel dans le déploiement et l’utilisation de ces technologies de manière responsable dans leurs propres contextes. Pour prendre en charge ce partenariat, nous proposons les meilleures pratiques suivantes pour les déploiements et les utilisateurs finaux afin d’aider les clients à implémenter efficacement une IA responsable.

  • Exercise la prudence et évalue les résultats lors de l’utilisation de fonctionnalités agentiques Copilot pour des décisions consécutives ou dans des domaines sensibles : Les décisions consécutives sont celles qui peuvent avoir un impact juridique ou significatif sur l’accès à l’éducation, à l’emploi, aux plateformes financières, aux prestations gouvernementales, aux soins de santé, au logement, à l’assurance, aux plateformes juridiques ou qui pourraient entraîner des dommages physiques, psychologiques ou financiers. Les domaines sensibles, tels que les plateformes financières, les soins de santé et le logement, nécessitent des soins particuliers en raison du risque d’impact disproportionné sur différents groupes de personnes. Lorsque vous utilisez l’IA pour prendre des décisions dans ces domaines, assurez-vous que les parties prenantes concernées peuvent comprendre comment les décisions sont prises, faire appel des décisions et mettre à jour les données d’entrée pertinentes.

  • Évaluez les considérations légales et réglementaires : Les clients doivent évaluer des obligations légales et réglementaires spécifiques potentielles lors de l’utilisation de toutes les plateformes et solutions IA, ce qui peut ne pas convenir à une utilisation dans chaque secteur ou scénario. En outre, les plateformes ou solutions IA ne sont pas conçues pour et peuvent ne pas être utilisées de manière interdite en termes de service applicables et les codes de conduite pertinents.

  • Exercer une surveillance humaine le cas échéant : la surveillance humaine est une protection importante lors de l’interaction avec les applications IA. Bien que nous améliorions continuellement nos applications IA, l’IA peut encore faire des erreurs. Les sorties générées peuvent être inexactes, incomplètes, biaisées, mal alignées ou non pertinentes par rapport à vos objectifs prévus. Cela peut se produire pour diverses raisons, telles que l’ambiguïté dans les entrées ou les limitations des modèles sous-jacents. Par conséquent, les utilisateurs doivent examiner les réponses générées par Copilot fonctionnalités agentiques et vérifier qu’elles correspondent à leurs attentes et exigences.

  • Tenez compte du risque de sur-dépendance : La dépendance sur l’IA se produit lorsque les utilisateurs acceptent des sorties IA incorrectes ou incomplètes, principalement parce que les erreurs dans les sorties IA peuvent être difficiles à détecter. Pour l’utilisateur final, une dépendance excessive peut entraîner une baisse de productivité, une perte de confiance, un abandon de l’application, une perte financière, des dommages psychologiques, des dommages physiques, entre autres. (par exemple, un médecin accepte un résultat erroné généré par l’IA).

  • Soyez prudent lors de la conception de l’IA agentique dans des domaines sensibles : Les utilisateurs doivent faire preuve de prudence lors de la conception et/ou du déploiement d’applications IA agentiques dans des domaines sensibles où les actions de l’agent sont irréversibles ou hautement indirectes. Des précautions supplémentaires doivent également être prises lors de la création de l’IA agentique autonome, comme décrit plus loin dans Termes GitHub.

  • Utilisez Copilot révision du code pour compléter les révisions humaines, et non pour les remplacer : Bien que Copilot révision du code puisse être un outil puissant pour améliorer la qualité du code, il est important de l’utiliser comme outil, plutôt que de remplacer les révisions humaines. Vous devez toujours passer en revue et vérifier les commentaires générés par Copilot révision de code, et compléter les commentaires de Copilot avec une révision humaine minutieuse pour vous assurer que votre code répond à vos besoins.

  • Donner votre avis : Si vous rencontrez des problèmes ou des limitations avec la revue de code avec Copilot, nous vous recommandons d’envoyer vos commentaires à l’aide des boutons Pouce levé et Pouce baissé dans les commentaires de Copilot. Cela peut aider GitHub améliorer l’outil et à résoudre les problèmes ou limitations.

  • Configurer des instructions personnalisées : vous pouvez configurer des instructions personnalisées pour Copilot vous aider à comprendre votre style de codage et vos bonnes pratiques, en améliorant la pertinence et la qualité des commentaires de révision.

  • Assurez-vous que les tâches de l’agent cloud sont bien étendues : plus l’invite que vous attribuez à l’agent cloud est plus claire et bien étendue, plus les résultats sont améliorés. Un problème idéal inclut une description claire du problème, des critères d’acceptation complets et des conseils sur les fichiers à modifier.

  • Personnalisez l’agent cloud avec un contexte supplémentaire : l’agent cloud a accès à la recherche de code sémantique, ce qui lui permet de trouver du code pertinent en fonction de la signification plutôt que des correspondances de texte exactes, ce qui lui permet d’effectuer des tâches plus rapidement. Pour améliorer les performances, implémentez des instructions de Copilot personnalisées pour aider l’agent à mieux comprendre votre projet et comment générer, tester et valider ses modifications.

  • Utilisez l’agent cloud en tant qu’outil, et non en remplacement : vous devez toujours examiner et tester le contenu généré par l’agent cloud pour vous assurer qu’il répond à vos besoins et est exempt d’erreurs ou de problèmes de sécurité avant la fusion.

  • Utilisez des pratiques de codage et de révision de code sécurisées avec l’agent cloud : bien que l’agent cloud puisse générer du code syntactiquement correct, il peut ne pas toujours être sécurisé. Suivez les bonnes pratiques pour sécuriser le codage et la révision du code. Prenez les mêmes précautions que vous le feriez avec n’importe quel code qui utilise du matériel que vous n’avez pas provenant indépendamment, y compris des tests rigoureux, l’analyse IP et la vérification des vulnérabilités de sécurité.

  • Restez à jour : l’agent cloud est une technologie en constante évolution. Restez à jour avec les nouveaux risques de sécurité ou les meilleures pratiques qui peuvent apparaître.

  • Utilisez l’interface CLI Copilot en tant qu’outil, pas un remplacement : vous devez toujours examiner et vérifier les commandes et le code générés par Copilot CLI pour vous assurer qu’ils répondent à vos besoins et sont exempts d’erreurs ou de problèmes de sécurité.

  • Vérifier les commandes avant exécution (CLI) : redoublez de prudence lorsque Copilot CLI propose d’exécuter des commandes, en particulier celles qui modifient ou suppriment des fichiers. Vous êtes finalement responsable des commandes que vous autorisez l’exécution de l’agent.

  • Conservez les tâches CLI bien délimitées : plus l’invite que vous fournissez est claire et bien étendue, plus les résultats sont améliorés. Incluez une description claire du problème, des critères d’acceptation et des conseils sur les fichiers à modifier.

  • Provide feedback (CLI) : si vous rencontrez des problèmes ou des limitations avec Copilot CLI, fournissez des commentaires à l’aide de la commande /feedback.

  • Valider le comportement de l’agent personnalisé (SDK) : testez soigneusement des agents, des outils et des hooks personnalisés avant de déployer des applications créées avec le Kit de développement logiciel (SDK) en production. Assurez-vous que les configurations des outils et les instructions système entraînent le comportement attendu, en toute sécurité.

  • Auditez les connexions de serveur MCP (SDK) : connectez-vous uniquement aux serveurs MCP approuvés. Passez en revue les outils et les données que chaque serveur expose et assurez-vous qu’ils s’alignent sur les exigences de sécurité de votre application.

  • Implémenter des crochets de sécurité (SDK) : utilisez les crochets de cycle de vie du SDK pour implémenter des garde-fous tels que le filtrage de contenu, la journalisation d’audit et les flux de travail d’approbation des outils dans vos applications.

  • Définissez correctement le périmètre des sessions (SDK)  : configurez chaque session SDK avec uniquement les outils, les agents et les autorisations nécessaires à la tâche à accomplir. Évitez d’accorder un accès étendu lorsqu’un périmètre restreint suffit.

  • Passez en revue les stratégies de fournisseur BYOK (SDK) : si vous utilisez des configurations bring-your-own-key, vérifiez que les conditions d’utilisation et les stratégies de gestion des données de votre fournisseur de modèles choisis répondent aux exigences de votre organisation.

  • Gardez les prompts Spark précis et centrés sur le sujet : plus vous serez précis quant aux comportements et interactions attendus, meilleur sera le résultat. L’incorporation d’un contexte pertinent, tel que des scénarios spécifiques, des maquettes ou des spécifications, aidera Spark à comprendre votre intention. Spark intègre le contexte des invites précédentes, de sorte que les invites hors rubrique peuvent entraver les performances sur les révisions suivantes.

  • Utilisez des modifications ciblées dans Spark : les modifications ciblées vous permettent de spécifier des éléments au sein de votre application pour l’affinement ciblé. Lorsque cela est possible, l’utilisation de modifications ciblées, plutôt que d’invites globales, entraîne des modifications plus précises et moins d’effets secondaires.

  • Vérifiez la sortie de Spark : utilisez toujours l’aperçu de l’application fournie par Spark pour vérifier que votre application se comporte comme prévu dans différents scénarios. Si vous êtes à l’aise avec le code, passez en revue le code généré pour vous assurer qu’il répond à vos normes de qualité.

  • Ensurer les fonctionnalités d’inférence agissent comme prévu (Spark) : si votre application Spark utilise des fonctionnalités d’inférence via le SDK GitHub Models, vous êtes chargé de tester les invites que vous créez pour vous assurer qu’elles produisent des résultats appropriés.

11. En savoir plus sur les fonctionnalités agentiques GitHub Copilot

Pour obtenir des conseils supplémentaires sur l’utilisation responsable des fonctionnalités agentiques Copilot, nous vous recommandons de consulter la documentation suivante :

En savoir plus sur l’IA responsable