GitHub Copilot App Lets Developers Run and Control Multiple AI Agents at Once

For the past year, AI coding agents have been doing more and more of the actual work: opening issues, writing code, submitting pull requests, responding to review feedback. The problem is that the tooling around them never caught up. Context scattered across windows, parallel agents stepped on each other's changes, and nobody had a clear view of what was running. At Microsoft Build 2026, GitHub shipped its answer: the GitHub Copilot app, a dedicated desktop experience built from the ground up to manage multiple AI agents at once.

The problem nobody was talking about

While the agentic shift has made development faster, it has also led to disjointed workflows, more context switching, and too much time spent reviewing agent-generated code. If agents are going to be a durable part of how software gets built, they need a real place in the developer workflow. Yet most developer tools were not designed for directing multiple agents in parallel. The scale of the problem is real: AI coding assistants started as autocomplete, and now they are running parallel workstreams, submitting pull requests, and managing their own review cycles. GitHub now sees commits nearly doubling year over year, crossing 1.4 billion per month, plus over 2 billion GitHub Actions minutes a week.

A control center, not just another chat window

GitHub unveiled the GitHub Copilot app, a new desktop experience designed around AI agents that can work alongside developers across the entire software development lifecycle, introducing a centralized environment where developers can launch, monitor, and guide multiple AI-powered coding agents while maintaining visibility into their work.

The core of the experience is a My Work view. The Copilot app provides a single "My Work" view showing active sessions, open issues, pull requests, and background automations across connected repositories. Under the hood, the isolation model is what makes parallel agents actually safe to run: every session runs in its own git worktree, a real, isolated copy of your branch, which helps parallel agent sessions work without stepping on each other. The app handles every worktree automatically with no manual setup, no cleanup, and no branch juggling.

Once an agent finishes its work, Agent Merge carries the pull request through review. It monitors CI, tracks required reviewers, addresses failing checks, and waits for all conditions to be satisfied before merging. You define how far it goes.

Canvases: seeing what the agent is actually doing

Chat is useful for giving instructions, but it falls apart once an agent starts doing real work. A long thread of decisions, logs, and corrections is hard to audit. GitHub's answer is Canvases, a new concept introduced alongside the app. Canvases are bidirectional work surfaces where both humans and agents operate. A canvas might show a plan, a pull request, a browser session, a terminal, a deployment, or a workflow state. Agents update the canvas as they work, and developers can edit, reorder, approve, or redirect that work on the same surface.

GitHub describes this as the beginning of agent experience (AX) (think UX, but for the interface between humans and agents): chat is where you instruct and reason through ambiguity, canvases are where that intent becomes visible, inspectable work. It is a meaningful shift from the current model where you prompt an agent and hope the output is right.

Sandboxes and code review that scale

Cloud and local sandboxes for GitHub Copilot are now in public preview. Sandboxed Copilot experiences provide isolated environments for Copilot's tool execution locally, as well as fully isolated cloud sandboxes hosted by GitHub. Local sandboxes run with restricted filesystem and network access, with policies that can be centrally configured and enforced. Cloud sandboxes run in ephemeral Linux environments, letting you pick up sessions on any device.

Code review gets an upgrade too. The new medium-tier review option routes pull requests to a higher-reasoning model for better precision. Admins can set review effort levels per repository, assigning lighter models to low-risk code and heavier models to high-impact repos. The /security-review skill gives Copilot a dedicated path for security-focused evaluation, and the /rubberduck skill, now generally available, uses multiple model families to critique your implementation and find novel issues.

Rayfin closes the last mile to production

Writing code is only part of the problem. Getting it into production, with a database, authentication, access controls, and compliance guardrails, has always been the slow part. That is where Rayfin comes in. Rayfin, a new open-source SDK and CLI now in preview, shortens that path significantly. Developers describe what to build in code or natural language, and Rayfin generates a complete backend including database, authentication layer, and access controls, then deploys it directly to Microsoft Fabric.

With Rayfin, developers or the coding agents working on their behalf define data models, APIs, business logic, access policies, and connections to existing data sources in one place. The definitions are strongly typed, so coding agents such as GitHub Copilot can read and modify them with the same reliability. Application data lands in OneLake by default, immediately available to Fabric's analytics, real-time data, and AI engines, and every deployment inherits the organization's existing Fabric security, governance, and compliance controls.

Build your own tools on the same foundation

You can build your own tools with the GitHub Copilot SDK, now generally available in Node.js/TypeScript, Python, Go, .NET, Rust, and Java. This means internal code analysis tools, custom release-notes generators, or agents embedded in support workflows all run on the same agentic runtime that powers the Copilot app itself, rather than a bespoke stack wired together from scratch.

The Copilot CLI also got a significant refresh: GitHub Copilot CLI is getting a major refresh at Microsoft Build 2026. Rubber duck, prompt scheduling, and voice input are generally available today, and a new experimental terminal interface, including tabs for working with issues, pull requests, and gists, is available to try via /experimental. Voice mode uses on-device speech-to-text, so audio never leaves your machine.

Who can use it and what it costs

The Copilot app is available in technical preview to existing Copilot Pro, Pro+, Business, and Enterprise subscribers. It will ship to Copilot Free users in the future, and there is a waitlist for those interested. It is available for Windows 11, Windows 11 on Arm, Mac, and Linux. No additional cost is required beyond your existing Copilot subscription, though Copilot Max is available as an upgrade for higher-volume agent usage.

What this means for the field

The move signals something important: managing AI agents has become its own workflow problem, and GitHub is trying to solve it. The features shipping here, isolated worktrees, Canvases, sandboxed environments, and Rayfin's strongly-typed backend definitions, are not just convenience features. They are the mechanisms that let teams actually trust what agents are doing. Visibility and verifiability are the foundation.

The broader assumption that needs updating is this: the developer's job is no longer primarily writing code. It is increasingly about directing, reviewing, and verifying the work of agents. The GitHub Copilot app is the clearest signal yet that GitHub is building its entire platform around that reality. The question for every engineering team is whether their current tooling is designed for the same world.