GitHub’s Copilot App Turns Developers Into AI Fleet Managers

The GitHub Copilot App, unveiled June 2 at Microsoft Build in San Francisco, turns a developer’s screen into a control center for supervising multiple AI agents at once, each writing code in its own isolated branch while a single dashboard tracks sessions, pull requests, and background automations. GitHub had a specific reason to build it: the platform now logs 1.4 billion commits per month, nearly double year-over-year, a volume the old chat-based tooling was never designed to handle.

The app is in technical preview for Copilot Pro, Pro+, Business, and Enterprise subscribers on Windows 11, macOS, and Linux. GitHub says Copilot Free users will get access later; a waitlist is open now.

From Autocomplete to Fleet Management

When GitHub launched Copilot in 2021, the pitch was autocomplete that understood context: a line, sometimes a function, suggested while a developer typed. The developer still wrote the code. Then came the agentic turn, where AI systems began taking an open GitHub issue, writing the feature, running the tests, and submitting the pull request themselves, without manual keystroke guidance.

That shift created its own problem. Context scatters across windows, developers lose track of which agent is handling which task, and code arrives in pull requests with no trail of what the agent tried or where human judgment applied. Agent-driven workflow fragmentation on GitHub’s own platform is the stated reason the app exists as a standalone product rather than another VS Code sidebar. GitHub Actions minutes crossed 2 billion per week on the platform, driven largely by machine-generated activity that existing tools weren’t designed to supervise at that scale.

GitHub had been building toward this incrementally. The single-agent mode for VS Code and JetBrains reached general availability in March 2026, giving Copilot the ability to edit files, run terminal commands, and iterate on errors without step-by-step guidance. The Copilot App is the coordination layer above that foundation, for teams running multiple agents in parallel across the same codebase at once.

The new app is a standalone desktop application, distinct from the VS Code Copilot extension. Where the extension assists a developer inside the editor on a single task, this app runs outside any IDE (integrated development environment), connects directly to GitHub repositories, and manages multiple isolated worktrees simultaneously, one per agent session. Mario Rodriguez, GitHub’s chief product officer, called it “the agent-native desktop experience built on GitHub,” framing the shift as agents moving from a side panel to a first-class component of the workflow.

A Cockpit Built on Three Surfaces

The app structures its workflow around three interaction layers, each handling a distinct phase of agent output.

GitHub calls Canvas “the beginning of agent experience (AX): interfaces designed not only for people to use, but for people and agents to operate together.” Chat handles instructions and reasoning through ambiguous requirements. Canvas gives those instructions somewhere to land as visible, inspectable, steerable work instead of a transcript that scrolls away.

Agent Merge is where the most autonomy, and the sharpest governance tension, concentrates. The Copilot App’s expanded technical preview changelog describes three configurable levels: monitoring and notifying at minimum, driving CI back to passing and responding to review feedback at maximum. Repository branch protection rules apply throughout, so a protected branch requiring human approval waits for it regardless of Agent Merge’s configuration. GitHub defaults to the conservative end, requiring agent permission before each write operation. Moving to full autopilot is an opt-in a team makes deliberately.

Running Code Without Breaking Anything

Agents that can only suggest code can’t verify much. The sandbox layer gives agents a contained environment to run code, execute tests, and iterate on failures before anything touches a production system.

GitHub offers two modes. Local sandboxing runs Copilot inside an isolated environment on the developer’s machine, with restricted access to the filesystem, network connectivity, and system capabilities; organizations can centrally define and enforce the access policies for what’s allowed within those boundaries. Cloud sandboxing runs each agent session in a fully isolated, ephemeral Linux environment hosted by GitHub, resumable from any device. A session started in VS Code on a workstation can be picked up from a phone.

The operational context for those guarantees matters. GitHub’s availability report for April 2026 disclosed 10 incidents that produced degraded performance across its services. As agents drive more parallel workloads through GitHub’s infrastructure, platform reliability becomes a harder constraint than it was when a single developer controlled a single session. Rodriguez noted in the launch post that “hardening these systems so agent-native development is fast, available, and reliable enough for teams to depend on every day” is a direct commitment.

The Copilot SDK (software development kit), now generally available in Node.js/TypeScript, Python, Go, .NET, Rust, and Java, extends the same runtime to teams building internal tools. A CI triage agent or a custom release-note generator can now be built on the same infrastructure the app runs on, rather than assembling bespoke orchestration from scratch.

The Crowded Orchestration Layer

GitHub is not the only company that looked at fragmented agent workflows and decided a dedicated orchestration layer was the answer. The competitive field for that layer is dense.

• Cursor: crossed $1 billion in annual recurring revenue in under two years; shipped Build in Parallel and Composer 2.5 in May 2026 for IDE-native parallel agent execution
• Windsurf (now Devin Desktop): renamed by Cognition after its $250 million acquisition; bundles the Devin Cloud agent for delegated remote-VM sessions directly inside the editor
• Claude Code (Anthropic): terminal-native agent tool favored for large, complex codebase tasks; runs on Claude Opus 4.8 with a 1 million-token context window
• Google Antigravity 2.0: shipped May 19 with dynamic subagents, scheduled background tasks, and a public SDK; runs on Gemini 3.5 Flash at roughly four times the output speed of competing models

GitHub’s structural advantage is distribution. 4.7 million paid subscribers, 90% Fortune 100 adoption, and native ownership of the repositories, issues, CI pipelines, and code review workflows where agent work actually executes. The app supervises agents at the repository level: the full audit trail of each agent’s work sits alongside the code in issues, pull requests, and CI results. Cursor and Windsurf operate inside the editor, at the file level.

A dedicated application for directing and reviewing parallel agents reflects vendors competing to own the agent orchestration and coordination layer. As agents move to running workstreams and submitting pull requests, the developer surface shifts to directing and overseeing their output. The pressure lands on engineering leaders choosing where to standardize.

Mitch Ashley, VP and practice lead for software lifecycle engineering at The Futurum Group, made the comment to DevOps.com. He added that “agent autonomy stays bounded by what teams can verify,” putting Canvas surfaces and isolated worktrees in a different category from UX improvements: they are the trust infrastructure that determines how much autonomy a team can safely delegate, and for enterprise buyers they tend to matter more than benchmark scores.

Microsoft’s Own Model Takes Over in August

The app is not the only structural change arriving on GitHub’s platform this year. Project Polaris, Microsoft’s in-house AI coding model, replaces GPT-4 Turbo as the default engine for all Copilot subscribers in August, ending the platform’s dependence on OpenAI’s models. The shift follows Microsoft and OpenAI’s decision in April to end their seven-year exclusive partnership, giving Microsoft full ownership of its developer tooling stack for the first time.

Teams building on the Copilot SDK have a three-month optional fallback to GPT-4 Turbo to evaluate the change before automatic migration takes effect. For organizations where Copilot agent output feeds into production pipelines directly, that window is worth using. GPT-4 Turbo’s reasoning patterns and output format won’t map exactly onto Project Polaris, and catching differences before the switch matters for teams running automated agent workflows at scale.

Two days after Build, 1 million-token context windows became available in the Copilot App, VS Code, and Copilot CLI (command-line interface). For large codebases where prior sessions hit context limits mid-task, that’s a meaningful constraint removed. GitHub also redesigned the CLI: voice input via on-device speech-to-text, a tabbed mode for accessing pull requests and issues directly from the terminal, and a /every command for scheduling recurring agent tasks. Sessions started in the CLI now appear in the app’s My Work view, giving both surfaces a shared feed of what’s running.

Partner integrations announced at Build extend the ecosystem further: LaunchDarkly, PagerDuty, Sonar, and Miro are building agent apps directly into Copilot, so agents can interact with deployment flags, on-call alerts, code quality gates, and design workflows without custom SDK work on the team’s end.

The Skills No Subscription Covers

Rodriguez said at Build that developers “keep control of quality, policy, and delivery” in the new setup. Writing code has decades of structured pedagogy behind it, from bootcamps to CS degrees to Stack Overflow. Managing a fleet of AI agents that write code requires a different set of competencies, and the training infrastructure for those doesn’t exist in any comparable form.

Gartner projects 40% of enterprise applications will include task-specific AI agents by end of 2026, up from under 5% today. No equivalent projection exists for the share of developers who will know how to configure the policies and oversight layers those agents require.

The Agent Merge configuration sits in a part of the stack that most engineering teams haven’t thought about as a training or operations problem yet. When the agent is empowered to respond to reviewer feedback and push code without the developer reading those comments directly, the quality control question moves from “did the developer write good code” to “did the developer configure the right policies for the agent to respond appropriately.”

GitHub’s defaults acknowledge this. Agent sessions require permission before every write operation out of the box. Autopilot mode, where agents proceed without check-ins, has to be explicitly enabled. The 2026 AI coding agent landscape across Cursor, Copilot, Windsurf, and Claude Code shows the same pattern: the autonomy ceiling keeps rising, and the floor for what most teams are equipped to supervise safely hasn’t moved at the same rate.

GitHub has built the cockpit. The pilot certification program hasn’t been written yet.