GitHub Copilot's App Lets Developers Run and Ship Multiple Agents at Once

GitHub launched a dedicated Copilot desktop app, sandboxes, an SDK, and CLI voice mode to manage multiple parallel coding agents from one place.

·
·
·
  • GitHub launched the Copilot app, a desktop control center for running multiple parallel coding agents.
  • Each agent session runs in its own git worktree for isolated, conflict-free parallel work.
  • Canvases provide bidirectional work surfaces where humans and agents edit plans, PRs, and dashboards together.
  • Cloud and local sandboxes let agents execute code safely with enterprise policy enforcement.
  • The Copilot SDK is generally available in Node, Python, Go, .NET, Rust, and Java.
  • CLI adds on-device voice input, scheduled /every tasks, and a redesigned TUI.

GitHub just turned its agent strategy into an actual product surface. At Microsoft Build, the company unveiled the GitHub Copilot app, a dedicated desktop experience built specifically for running, steering, and shipping work produced by multiple coding agents in parallel. Along with it came a generally available Copilot SDK, sandboxed execution environments, a voice-enabled CLI, and a meaningfully upgraded code review system.

The pitch is straightforward: 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. Most IDEs assume a single human driver. Once you have three or four agents fanning out across a repo, that model breaks down.

A control center for parallel agents

The new app gives you a single My Work view where you can see work in motion across connected repositories: active sessions, issues, pull requests, and background automations. It is in technical preview for existing Copilot Pro, Pro+, Business, and Enterprise customers, with a new Copilot Max tier aimed at people running heavy agent workloads.

The interesting architectural choice is isolation. Every session runs in its own git worktree, a real, isolated copy of your branch. This helps parallel agent sessions work without stepping on each other. Worktrees are managed automatically, so you do not end up with a stack of half-finished branches to clean up after the agents finish.

On the shipping side, GitHub introduced Agent Merge, which monitors CI, tracks required reviewers, addresses failing checks, and waits for all conditions to be satisfied before merging. You decide how aggressive that autopilot gets, from simply fixing red CI to merging when conditions clear.

Canvases instead of endless chat scroll

The most genuinely new interaction primitive here is the canvas. Chat is fine for instruction, but once an agent has been running for ten minutes, scrolling through tool calls and corrections to figure out what it actually did is painful. Canvases are bidirectional work surfaces for humans and agents. A canvas might show a plan, pull request, browser session, terminal, deployment, dashboard, or workflow state.

The split is conceptually clean: chat is where ambiguity gets resolved, canvases are where the resulting artifacts live and can be edited, reordered, or redirected by either party. GitHub is calling this layer agent experience (AX), a term you will probably hear more of.

Sandboxes, local and cloud

Letting an agent run code on your laptop is a security problem. GitHub is addressing it with two execution modes. With local sandboxing, Copilot runs in an isolated environment directly on your machine, with restricted access to filesystems, network connectivity, and system capabilities. Policies can be configured centrally by an organization, which matters for enterprise rollouts.

In the cloud, each sandbox runs in a fully isolated, ephemeral Linux environment hosted by GitHub, and sessions are portable across devices. The net effect is that agents can actually execute, test, and iterate on changes rather than just suggesting diffs, without you having to wire up your own container infrastructure.

Code review gets tiers and skills

As agents pump out more pull requests, the bottleneck shifts to review. Copilot code review is responding with a model-routing approach.

GitHub Copilot code review suggesting ConcurrentHashMap to fix a race condition in SessionManager.java

Copilot code review now offers medium tier review, which routes pull requests to a higher-reasoning model for better precision and recall. Admins can set guidelines for individual repositories to low or medium. The practical implication is that you can use cheap models on low-risk repos and reserve more expensive reasoning for whatever ships to production.

Two skills got promoted: /security-review for security-focused evaluation, and /rubberduck, now generally available, which uses multiple model families to critique your implementation and find novel issues. Reviews can also be extended with custom agent skills, MCP server connections, and Actions workflows so they reflect your own internal standards. Azure DevOps users get native Copilot code review as well.

One SDK, six languages

For teams that want to embed agentic behavior into their own products, the GitHub Copilot SDK is now generally available. It is generally available in Node.js/TypeScript, Python, Go, .NET, Rust, and Java, and it exposes the same agentic runtime that powers the Copilot app.

This matters because it means the runtime is no longer locked behind a single UI. An internal code analysis tool, a release-notes generator, or a support-workflow agent can all be built on the same foundation rather than gluing together model APIs, retrieval, and tool execution from scratch.

CLI gets voice and a scheduler

The Copilot CLI picked up three things worth mentioning. A redesigned TUI in /experimental mode adds tabbed access to pull requests, issues, and gists. Voice mode uses on-device speech-to-text, so audio never leaves your machine. And /every schedules recurring prompts and background tasks from the terminal.

On the persistence side, Memory++ and /chronicle are designed to give Copilot continuity across the app, CLI, VS Code, and github.com, so a session started on one surface can be queried from another.

The bigger picture

The throughline across all of these announcements is that GitHub is treating agents as a long-term primitive rather than a feature bolted onto Copilot Chat. The Copilot app is essentially admitting that the IDE was the wrong abstraction for managing fleets of agents. Worktrees, canvases, sandboxes, and tiered review are all answers to problems that only exist once you accept that pattern.

For teams already standardized on GitHub, this is mostly additive: existing Copilot subscriptions get access to the technical preview, and the SDK opens up the same runtime for custom internal tools. The real test will be whether the trail of plans, sandbox runs, and canvas state actually makes agent output easier to review than the current chat-scroll model, because the value of letting agents do more work is entirely capped by how fast a human can verify it.

Trending
  • No trending articles

Comments

avatar

Next Reads