Pendant des années, GitHub Copilot a vécu dans l’ombre des IDE : un panneau de chat dans VS Code, une suggestion qui s’affiche en grisé au fil de la frappe, un outil utile mais discret. Depuis Microsoft Build 2026 et les annonces de juillet, ce chapitre est définitivement clos. GitHub Copilot App est une application de bureau autonome, conçue dès le départ pour orchestrer des agents IA, pas pour assister un développeur ligne par ligne.

La bascule s’est accélérée avec deux sorties successives : le 1er juillet 2026, les browser tools pour Copilot dans VS Code passent en disponibilité générale, et le 2 juillet, le streaming de session agent entre en public preview. Ces deux briques font de Copilot App une plateforme d’exécution, pas une simple aide à la complétion. Ce guide fait le point sur ce qui est disponible maintenant, comment en tirer parti et ce que ça change concrètement face aux alternatives comme OpenCode ou Devin Desktop.

Pourquoi GitHub avait besoin d’une vraie application Copilot

L’extension Copilot dans VS Code résolvait un problème précis : suggérer du code dans l’éditeur ouvert. Dès que les agents IA sont entrés en scène, cette architecture a montré ses limites. Un agent qui modifie plusieurs fichiers en parallèle, lance des tests, navigue sur le web pour vérifier une API, puis propose une pull request ne peut pas fonctionner dans un panneau latéral.

GitHub a annoncé Copilot App à Microsoft Build 2026 (2 juin) avec une promesse claire : transformer Copilot en centre de contrôle pour agents. L’application récupère un contexte large, la vue « My Work », qui rassemble en un écran les sessions actives, les issues ouvertes, les pull requests et les automatisations en arrière-plan sur tous les dépôts connectés. Le développeur voit ce que ses agents font, pas seulement ce qu’ils lui suggèrent.

La preview technique a ouvert aux abonnés Copilot Pro, Pro+, Business et Enterprise en juin 2026. Elle est disponible sur Windows 11, macOS et Linux. L’adoption a été rapide : en trois semaines, les équipes utilisatrices rapportent un gain de contexte notable sur les projets multi-repos, selon les retours publiés sur GitHub Discussions.

Architecture agent-native : worktrees isolés et sessions parallèles

Le point technique le plus important de Copilot App est l’isolation par worktree. Chaque session agent tourne dans son propre worktree git, une copie légère du dépôt qui partage l’historique mais isole les modifications. Deux agents peuvent travailler simultanément sur le même repository sans jamais se marcher dessus.

En pratique, si vous lancez un agent pour refactoriser le module d’authentification pendant qu’un second agent corrige des tests en échec dans la suite CI, les deux travaillent en parallèle, dans des branches séparées, avec des états de fichiers indépendants. Quand les deux terminent, vous recevez deux pull requests distinctes que vous pouvez réviser, fusionner ou abandonner indépendamment.

# Lancer deux sessions Copilot Agent en parallele sur le meme repo
gh copilot agent start 
  --repo monorg/monrepo 
  --task "refactor: extract auth middleware to separate module" 
  --branch feature/auth-refactor

gh copilot agent start 
  --repo monorg/monrepo 
  --task "fix: repair failing integration tests in /tests/api" 
  --branch fix/api-tests

# Lister les sessions actives
gh copilot agent list

# Exemple de sortie :
# ID          STATUS     BRANCH                   TASK
# agn_x7k2p   running    feature/auth-refactor    refactor: extract auth middleware...
# agn_m9q3r   running    fix/api-tests            fix: repair failing integration tests...

L’interface de Copilot App affiche ces sessions avec une timeline d’activité, les fichiers touchés et les diffs accumulés. Le développeur reste maître : il peut pauser, reprendre ou stopper une session à tout moment depuis l’application ou via la CLI.

Browser tools en GA depuis le 1er juillet : l’agent pilote votre navigateur

Les browser tools pour GitHub Copilot dans VS Code ont quitté la preview le 1er juillet 2026 pour entrer en disponibilité générale. Activées par défaut, elles donnent aux agents la capacité de piloter un vrai navigateur Chromium intégré, de naviguer sur des pages web, d’interagir avec des formulaires, de capturer des screenshots et de retourner le contenu dans le contexte du chat.

Concrètement, un agent Copilot peut maintenant : vérifier qu’une API publique renvoie bien le format attendu, tester le rendu d’une page en production avant de suggérer un correctif CSS, remplir un formulaire de staging pour simuler un parcours utilisateur, ou crawler la documentation d’une dépendance externe pour construire une réponse précise.

// Exemple : utiliser les browser tools dans un agent Copilot custom
// via le GitHub Copilot Extensions SDK (TypeScript)
import { CopilotAgent, BrowserContext } from "@github/copilot-sdk";

const agent = new CopilotAgent({
  tools: ["browser", "filesystem", "terminal"],
});

agent.on("task", async (ctx) => {
  // L'agent ouvre le navigateur, navigue et analyse
  const page: BrowserContext = await ctx.browser.newPage();
  await page.goto("https://api.example.com/v2/health");

  const responseBody = await page.evaluate(() => document.body.innerText);
  const parsed = JSON.parse(responseBody);

  if (parsed.status !== "ok") {
    await ctx.reply(
      `L'API renvoie status "${parsed.status}". Voici un diagnostic...`
    );
    // L'agent peut enchainer en lisant les fichiers du repo, proposer un fix, etc.
  }
});

Les browser tools respectent la politique de sécurité de l’entreprise : les administrateurs peuvent restreindre les domaines accessibles via la configuration managed-settings.json. En entreprise, il est courant de limiter l’accès aux seuls domaines internes et à la liste blanche des API de production. La fonctionnalité s’appuie sur Playwright en arrière-plan, ce qui signifie que les scripts d’automatisation existants sont réutilisables avec très peu d’adaptation.

Session streaming en public preview depuis le 2 juillet

Le 2 juillet 2026, GitHub Enterprise Cloud a introduit le streaming de session agent en public preview. Cette fonctionnalité expose en temps réel chaque prompt, chaque réponse et chaque appel d’outil effectué par un agent Copilot, sur tous les clients : Copilot App, VS Code, CLI, Visual Studio, JetBrains, Eclipse.

Pour les équipes et les responsables IT, c’est une fenêtre directe sur l’activité IA de l’organisation : qui a demandé quoi, quel modèle a répondu, quels outils ont été appelés, combien de tokens ont été consommés. Cette visibilité est indispensable pour les audits de conformité et pour diagnostiquer un agent qui part dans une mauvaise direction avant qu’il ne valide un commit problématique.

import requests
import json

# Recuperer le stream de session via l'API GitHub Enterprise (public preview)
# Necessite un token avec scope "copilot" et un plan Enterprise Cloud

ENTERPRISE = "votre-org"
SESSION_ID = "ses_abc123xyz"
TOKEN = "ghp_votre_token"

url = f"https://api.github.com/enterprises/{ENTERPRISE}/copilot/session/{SESSION_ID}/stream"
headers = {
    "Authorization": f"Bearer {TOKEN}",
    "Accept": "text/event-stream",
    "X-GitHub-Api-Version": "2026-07-01",
}

with requests.get(url, headers=headers, stream=True) as resp:
    resp.raise_for_status()
    for line in resp.iter_lines():
        if line.startswith(b"data: "):
            event = json.loads(line[6:])
            event_type = event.get("type")
            if event_type == "tool_call":
                print(f"[OUTIL] {event['tool']} args={event['args']}")
            elif event_type == "message":
                print(f"[MSG]   {event['role']}: {event['content'][:80]}...")

Le streaming de session est particulièrement utile pour les pools de crédits IA que GitHub introduit en parallèle : les administrateurs peuvent associer chaque session à un centre de coûts et monitorer la consommation en temps réel, pas seulement en fin de mois. Les données de stream sont conservées 90 jours dans l’audit log de l’organisation.

GitHub Copilot SDK en GA : intégrez Copilot dans vos propres outils

En parallèle des features de l’App, GitHub a annoncé la disponibilité générale du Copilot SDK dans six langages : Node.js/TypeScript, Python, Go, .NET, Rust et Java. Le SDK permet de construire des agents Copilot personnalisés, des extensions qui apparaissent dans l’interface comme n’importe quel autre agent intégré.

Les cas d’usage sont nombreux : un agent spécialisé dans les conventions de codage de votre équipe, un agent qui connaît vos runbooks d’infra, un agent connecté à votre instance JIRA pour créer des tickets directement depuis le chat. Le SDK est open source (MIT) et s’intègre avec le registre d’extensions de GitHub Marketplace.

// Exemple minimal d'agent Copilot en Go avec le SDK officiel
package main

import (
    "fmt"
    copilot "github.com/github/copilot-sdk-go"
)

func main() {
    agent := copilot.NewAgent(copilot.AgentConfig{
        Name:        "mon-agent-runbook",
        Description: "Repond aux questions sur nos runbooks internes",
        Tools:       []string{"search_runbooks", "create_incident"},
    })

    agent.OnMessage(func(ctx *copilot.Context, msg string) {
        results := searchRunbooks(msg)
        if len(results) == 0 {
            ctx.Reply("Aucun runbook trouve pour cette requete.")
            return
        }
        ctx.Reply(fmt.Sprintf("Runbook : %snn%s",
            results[0].Title, results[0].Content))
    })

    agent.Listen(":8080")
}

Le SDK unifie les interactions avec tous les modèles accessibles depuis Copilot, notamment Claude Sonnet 5 et GPT-5.6 Terra qui sont disponibles comme modèles alternatifs selon le plan souscrit. Pour les développeurs qui utilisent déjà des frameworks d’agents comme LangGraph ou CrewAI, le SDK offre un pont direct vers l’écosystème GitHub sans réécrire l’orchestration existante.

Copilot App face à OpenCode, Cursor et Devin Desktop

Le marché des agents de codage est dense. OpenCode (160 000 étoiles GitHub) mise sur l’open source et l’agnosticisme de modèle avec 75+ providers. Cursor reste l’IDE hybride le plus adopté avec une base active dans 50% des entreprises Fortune 500. Devin Desktop (ex-Windsurf) se positionne sur l’autonomie maximale de l’agent avec Devin Local et son score de 73,4% sur SWE-Bench Pro en mode solo.

GitHub Copilot App joue une carte différente : l’intégration dans l’infrastructure GitHub existante. Les dépôts, les issues, les pull requests, les actions CI/CD sont déjà là, et l’App en tire parti nativement. Là où OpenCode requiert une configuration manuelle des MCP servers et où Cursor demande d’importer les projets, Copilot App démarre avec le contexte complet de votre organisation GitHub.

# Comparatif des agents de codage en juillet 2026 (score /5)
#
# Critere                  Copilot App  OpenCode  Cursor  Devin Desktop
# Integration GitHub             5          2        3         2
# Isolation par worktree         4          3        2         5
# Browser tools integres         4          2        4         3
# Agnosticisme modele            3          5        4         3
# Monitoring temps reel          4          2        2         3
# Open source                    non        oui      non       non
# Prix d'entree (USD/mois)       10 Pro     0/10     20        0/30
#
# -> Copilot App : meilleur sur l'integration GitHub et le monitoring
# -> OpenCode    : meilleur sur la liberte de modele et le cout
# -> Devin Desktop : meilleur sur l'autonomie agentique pure

Une différence notable : le comparatif Cursor vs Copilot plugin portait sur la complétion de code. Avec Copilot App, la comparaison change de dimension : ce n’est plus « quel outil complète le mieux », mais « quelle plateforme orchestre le mieux vos agents ». C’est une transition fondamentale dans la manière de penser les outils de développement.

Prise en main et migration depuis l’extension VS Code

Si vous utilisez déjà Copilot dans VS Code, la migration vers Copilot App est progressive. L’extension VS Code reste en place et continue de fonctionner. Copilot App s’installe en parallèle depuis github.com/copilot/app et se connecte au même compte GitHub.

Les sessions lancées depuis Copilot App apparaissent dans VS Code dans le panneau « Sessions actives », et inversement. La synchronisation est en temps réel via WebSocket. Vous pouvez commencer une conversation dans VS Code et la reprendre dans l’App sans perte de contexte. La courbe d’apprentissage est faible pour les utilisateurs Copilot existants, car le paradigme conversationnel est conservé.

## Installation et configuration de Copilot App (Linux / macOS)

# 1. Telecharger l'installeur depuis GitHub Releases
curl -fsSL 
  https://github.com/github/copilot-app/releases/latest/download/copilot-app-linux-x64.tar.gz 
  | tar -xz -C /usr/local/bin/

# 2. Authentification via OAuth GitHub
copilot-app auth login

# 3. Connecter les repos de votre organisation
copilot-app repos connect --org monorg --all

# 4. Lancer l'interface graphique
copilot-app start

# 5. Configuration enterprise : restreindre les browser tools
mkdir -p ~/.config/copilot-app
cat > ~/.config/copilot-app/managed-settings.json <<'EOF'
{
  "copilot.agent.browserTools.allowedDomains": [
    "*.internal.monentreprise.com",
    "api.github.com"
  ],
  "copilot.agent.model": "auto",
  "copilot.agent.maxParallelSessions": 4
}
EOF

Pour les équipes qui travaillent sur de gros monorepos, la commande copilot-app repos sync --shallow permet de mettre à jour l’index des worktrees sans resynchroniser l’historique git complet, ce qui évite les téléchargements de plusieurs gigaoctets à chaque session. Le flag --depth=1 est suffisant pour la grande majorité des tâches agentiques.

Disponibilité, accès et ce qui vient après la preview

Copilot App est actuellement en preview technique pour les abonnés Copilot Pro ($10/mois), Pro+ ($19/mois), Business ($19/utilisateur/mois) et Enterprise ($39/utilisateur/mois). Les utilisateurs Free n’y ont pas accès pour le moment. La feuille de route publiée par GitHub indique une disponibilité générale prévue pour le quatrième trimestre 2026.

Parmi les fonctionnalités annoncées pour les prochaines versions : les espaces de travail partagés (plusieurs développeurs humains et plusieurs agents dans la même session), l’intégration GitHub Actions permettant à un agent de déclencher et monitorer des workflows CI/CD directement depuis l’App, et une marketplace d’agents tiers utilisant le Copilot SDK.

Le signal le plus important vient de l’adoption enterprise : GitHub signale que plusieurs grandes entreprises Fortune 500 ont migré leurs workflows de revue de code vers Copilot App, avec une réduction de 30 à 40% du temps passé sur les pull requests selon les retours internes. Ce n’est plus un outil d’assistance, c’est une couche d’automatisation à part entière.

Pour les développeurs qui évaluent leur stack d’outils IA en 2026, Copilot App représente le choix le plus cohérent si votre code est hébergé sur GitHub et que vous voulez une intégration sans friction. Si vous cherchez la liberté de modèle maximale ou l’autonomie agentique la plus avancée, OpenCode ou Devin Desktop restent de bons candidats. Mais le fait que GitHub ait construit une vraie application dédiée, et non pas une extension de plus, dit beaucoup sur la direction que prend le développement logiciel en 2026.

Sources

G
WP Admin Lab

Architecte web full-stack. WordPress, performance, data et sécurité. Notes de terrain, tests reproductibles et retours d'expérience.