GitHub's new Copilot desktop app gives you a control room for parallel AI agent sessions

Running multiple AI coding agents at once is powerful in theory. In practice, it tends to mean a lot of context-switching, tangled branches, and uncertainty about what any given agent is actually doing. GitHub’s answer to that problem is the new GitHub Copilot app, a standalone desktop application for Windows, macOS, and Linux built specifically around agent-driven development. It hit technical preview in May and got a significant feature expansion at Microsoft Build 2026 on June 2nd.

This is not a reskin of VS Code, and it is not a Copilot chat window bolted onto a file browser. It is a separate app, built from the ground up for the workflow of directing agents rather than writing code yourself.

The My Work dashboard

The centrepiece is a view called My Work, which pulls your active agent sessions, open pull requests, issues, and background automations into one place. If you have three agents working on three different features simultaneously, this is where you see all of them, check their status, and step in where needed.

Each session runs in its own git worktree, which is a real, isolated copy of your branch on disk. The app handles the worktree lifecycle automatically. You do not set them up, name them, or clean them up. The point is that agents never touch each other’s work, and you never have to think about branch hygiene while they are running.

Three ways to work with an agent

Sessions come in three modes. Interactive keeps you in the loop continuously, collaborative back and forth. Plan mode has the agent lay out what it intends to do before touching anything, giving you a chance to approve or redirect. Autopilot hands the agent a task and lets it run to completion on its own.

You can pick the mode per session, which matters for different kinds of work. A speculative spike might suit Autopilot. A refactor touching core business logic probably warrants Plan mode, so you see the approach before any code changes.

Agent Merge: letting Copilot shepherd a PR to completion

Once an agent opens a pull request, Agent Merge can take over the process of getting it merged. You define the conditions: pass CI, address reviewer comments, merge when approved. Copilot monitors the PR state and follows through. For teams handling a lot of agent-generated PRs, this removes a significant category of low-value churn from the human review queue.

Canvases: a shared surface between you and the agent

Canvases are new in the June update. The idea is that a conversation with an agent benefits from a structured surface alongside it, somewhere for the output to live and be edited. A canvas might show a plan, a pull request, a terminal session, a deployment checklist, or a live dashboard. As the agent works, it updates the canvas. You can edit, reorder, or reject what is there without leaving the session. GitHub is calling this the beginning of “agent experience” design, abbreviated AX, and it is worth watching as a concept even if the current implementation is early.

Sandboxing: local and cloud options

The app offers two sandboxing approaches for agents that need to run code. Local sandboxing runs in an isolated environment on your own machine, with restricted filesystem access and network policies that an admin can configure centrally. Cloud sandboxing spins up an ephemeral Linux environment hosted by GitHub, fully isolated per session and accessible from any device via remote control.

For enterprise teams, the cloud sandbox option has an obvious appeal for security posture. Agents are not touching production systems, the environments are disposable, and the remote control feature means a developer can hand off a session started on their laptop to their phone without losing state.

The Copilot SDK is now generally available

The GitHub Copilot SDK that powers the app is now GA across six languages: Node.js/TypeScript, Python, Go, .NET, Rust, and Java. This is the same agentic runtime the app itself uses, now available for teams who want to build their own tooling on top of it or integrate Copilot’s agent infrastructure into existing workflows.

For platform and tooling teams, that GA status matters. It means the API surface has settled enough to build against without expecting breaking changes.

A few things worth knowing before you install it

The app is in technical preview today on Windows 11 (including Arm), macOS, and Linux. It requires a Copilot Pro, Pro+, Business, or Enterprise subscription. Copilot Free users can join a waitlist.

For Business and Enterprise organisations, there is an administrative prerequisite that is easy to miss. Two policy settings need to be enabled at the org or enterprise level: Preview Features and Copilot CLI. Without both, the app will not function even after installation. If you are rolling this out to a team, check those settings first.

What this means for individual developers

If you have been using Copilot agents through VS Code, the desktop app is not a replacement for that workflow. It is an alternative for work that does not need a full IDE, or for managing agents while you are doing something else. The ability to kick off several agents, check on them from a single dashboard, and let Agent Merge handle PR follow-through is a meaningful reduction in the overhead that currently comes with agentic development.

The /chronicle command is also worth noting. It queries data from any past Copilot session, including ones started outside the app. If you need to pick up context from a session you ran yesterday, that is the access point.

What this means for engineering teams

The isolation model, one worktree per agent, one branch per session, with CI gating and configurable merge conditions, gives teams a cleaner story around governance for agent-generated code. It does not replace your review process, but it integrates with it in a way that the ad hoc “agent writes code, developer pastes it in” approach does not.

Teams using Azure DevOps also get native Copilot code review with inline comments and committable fix suggestions as part of this update, so the governance improvements are not limited to GitHub-hosted repositories.

The partner integrations announced alongside the app, covering LaunchDarkly, Amplitude, Sonar, PagerDuty, and others, suggest GitHub is building toward a broader ecosystem where agents can interact with the tools already in your stack. That is worth tracking as those integrations mature.

GitHub’s platform now handles close to 1.4 billion commits a month. The infrastructure for agent-driven development is clearly being built at scale. The Copilot app is where that infrastructure becomes something a developer can actually sit in front of and use.