GitHub Copilot App: The Standalone Agent Desktop Is Now in Technical Preview

At a glance: On June 2, 2026, GitHub expanded the technical preview of the GitHub Copilot app — a standalone desktop client for macOS, Windows, and Linux — to all Copilot Pro, Pro+, Business, and Enterprise subscribers (GitHub Blog, June 2, 2026). This is not an IDE extension. It’s a new interface category: a control center for managing multiple parallel agent sessions, each running in its own isolated git worktree. Key features include the My Work view, canvases, Agent Merge, and cloud sandboxes. The Copilot SDK is now generally available in six languages (GitHub Changelog, June 2, 2026). Update: the app itself has since moved past technical preview — GitHub shipped it to general availability on June 17, 2026 and opened it to every Copilot plan, including Free, on July 7, 2026; see the Access section below. Part of our Builder’s Log.

What This Is (and What It Isn’t)

This is easy to misread, so let’s be precise.

The GitHub Copilot app is a standalone desktop application — separate from GitHub.com, separate from VS Code, and separate from any IDE extension. It runs natively on macOS, Windows, and Linux. It connects to your GitHub account and repositories, and it’s designed to be a control center for managing AI agent workflows at a level that doesn’t fit inside an editor’s side panel.

This is different from:

• GitHub Copilot in VS Code — the editor extension with chat, completions, and Copilot Edits
• GitHub Copilot in Visual Studio 2026 — the IDE-integrated agents covered in our Visual Studio Build 2026 article
• Copilot Workspace — GitHub’s browser-based task-to-PR pipeline

The Copilot app is what you run when you want to supervise multiple agents doing real work across multiple repositories, simultaneously, without living in an editor.

My Work View

The central interface is the My Work view: a unified dashboard showing everything in motion across your connected repositories.

What it surfaces:

• Active sessions and their current state
• Open pull requests and issues
• Background automations running on your behalf
• Scheduled jobs that have run or are queued

GitHub frames this as a shift in the developer’s role: as agents handle more of the execution — investigating bugs, implementing issues, working through review feedback, each in its own isolated environment — the developer’s job becomes inspecting, redirecting, testing, and merging the resulting changes rather than writing all of them (GitHub Blog — Copilot App: The Agent-Native Desktop Experience). My Work is the surface where that oversight happens.

Sessions and Worktrees: No More Branch Juggling

Each agent session in the Copilot app runs in its own git worktree — a real, isolated copy of a branch checked out at a separate path on your machine or in a cloud sandbox. The app creates and manages all worktrees automatically (GitHub Blog — Copilot App: The Agent-Native Desktop Experience).

The practical implication: you can run multiple sessions against the same repository simultaneously and they will not conflict (GitHub Blog — Copilot App: The Agent-Native Desktop Experience). No manual setup, no cleanup, no stashing or switching branches between tasks.

Sessions can run:

• Locally — in isolated environments on your machine
• In cloud sandboxes — ephemeral Linux environments hosted by GitHub (more on those below)

When a session finishes, its worktree is cleaned up. The output is a pull request, a plan, or a canvas — not a pile of branches to untangle.

Canvases: Shared Work Surfaces

A canvas is what GitHub calls a bidirectional work surface for a session (GitHub Blog — Copilot App: The Agent-Native Desktop Experience). It’s not just an output log — it’s a structured, interactive surface where both agents and humans can read and write.

What a canvas might contain:

• A plan (structured as editable steps)
• A pull request diff with review and comment interface
• A terminal session output
• A browser session snapshot (from agentic browser control)
• A deployment state
• A dashboard or workflow visualization

The interaction model: the agent updates the canvas as it works. The developer can edit, reorder, approve, flag problems, or redirect the agent — on the same surface. It’s closer to a shared document than a chat transcript.

This matters for workflows where you want to stay in the loop without driving every step. You define the destination; the agent populates the canvas; you review and unblock.

Agent Merge: PR to Merged, Autonomously

Agent Merge handles the PR-through-merge lifecycle — specifically the part that normally requires a developer to babysit: waiting for CI, responding to review comments, re-running checks, and finally merging (GitHub Blog — Copilot App: The Agent-Native Desktop Experience).

What it does:

• Monitors CI runs and responds to failures
• Tracks required reviewers
• Addresses review comments (with configurable scope)
• Merges when all conditions are met

How much autonomy you give it is configurable: drive CI back to green, address feedback, or merge only when the conditions you specify are met. “You decide what automation is enabled and what ships,” per GitHub’s announcement.

One important boundary: GitHub’s Copilot coding-agent documentation states the agent “is also subject to any branch protections and required checks for the working repository,” and that it cannot mark a PR “Ready for review” or approve/merge it without satisfying those requirements (GitHub Docs — Risks and mitigations for GitHub Copilot cloud agent). Even so, GitHub’s own guidance is that organizations requiring human approval before merge should verify their branch protection rules are configured to enforce it — Agent Merge automates the mechanical parts, but it’s on the repo admin to make sure governance policies are actually wired up to constrain it.

Sandboxes: Agents Work Without Breaking Things

The Copilot app provides two sandbox environments for agent sessions:

Cloud sandboxes — Fully isolated, ephemeral Linux environments hosted by GitHub. Each cloud session gets its own environment, torn down after the session, enabling remote control and continuity across devices (GitHub Blog — Copilot App: The Agent-Native Desktop Experience).

Local sandboxes — Isolated environments on your machine, with restricted access to the filesystem, network, and system capabilities, and centrally configurable policy. Agents can run, test, and iterate code without touching your working environment or production infrastructure.

Both sandbox types give agents a bounded place to act. The agent can install packages, run tests, build artifacts, and make filesystem changes inside the sandbox — and none of that reaches anything outside the boundary.

Copilot SDK: Now GA in Six Languages

Alongside the app expansion, GitHub announced the GitHub Copilot SDK is now generally available “in six languages” (GitHub Changelog — Copilot SDK is now generally available):

• Node.js / TypeScript
• Python
• Go
• .NET
• Rust
• Java

The SDK exposes the same agent runtime that powers the Copilot app (GitHub Blog — Copilot App: The Agent-Native Desktop Experience). If you want to build custom agent tools or integrate Copilot-style agent workflows into your own systems, the SDK is the entry point — not a preview integration, but a GA API.

Third-party integrations are already shipping: GitHub’s announcement lists partner-built agent apps from LaunchDarkly, Bright, Amplitude, Sonar, Endor Labs, Octopus Deploy, Packfiles, PagerDuty, and Miro that integrate with GitHub Copilot to automate tasks, generate code, analyze context, and execute actions (GitHub Blog — Copilot App: The Agent-Native Desktop Experience).

Other Features Worth Noting

Voice input — On-device speech-to-text so audio never leaves your machine; GitHub shipped this as a Copilot CLI feature (voice mode docs) rather than the desktop app specifically, but it’s part of the same session infrastructure the app uses.

Chronicle — GitHub calls the underlying feature “Memory++,” queried via the /chronicle command, giving Copilot continuity across devices and over time — you can ask what happened in previous sessions started from the app, CLI, VS Code, or GitHub.com (GitHub Blog — Copilot App: The Agent-Native Desktop Experience).

Scheduled automations — Set up cloud sessions to run on a schedule, respond to GitHub events, open issues, and leave comments (GitHub Blog — Copilot App: The Agent-Native Desktop Experience).

Copilot CLI integration — The CLI has a redesigned interface and connects to the same session infrastructure.

Rubber duck skill — /rubberduck is now generally available and uses multiple model families to critique your implementation and find issues, for problem-solving discussion rather than having an agent execute changes (GitHub Blog — Copilot App: The Agent-Native Desktop Experience).

Custom review skills — Copilot code review now offers a medium review tier that routes PRs to a higher-reasoning model, configurable per repository, plus custom skills like /security-review for a dedicated security-focused evaluation path (GitHub Blog — Copilot App: The Agent-Native Desktop Experience).

Access: Who Could Use It at Launch (and Who Can Now)

The technical preview expanded on June 2, 2026 at Build 2026. At that point, access looked like this (GitHub Changelog — Expanded Technical Preview Availability):

This has since moved on. The app reached general availability for macOS, Windows, and Linux on June 17, 2026 (GitHub Changelog — GitHub Copilot app generally available), and on July 7, 2026 GitHub opened it to every Copilot plan, including Copilot Free and GitHub Education, with a bring-your-own-key option that needs no Copilot subscription at all (GitHub Changelog — GitHub Copilot app available to all). Business and Enterprise admins still need the Copilot CLI policy enabled in org settings for the app to work.

Platform: macOS, Windows, Windows on Arm (ARM64), and Linux (GitHub Copilot app releases).

The Copilot Max Tier

For high-volume agent usage — sustained parallel sessions, heavy Agent Merge usage, large amounts of cloud sandbox time — GitHub has introduced Copilot Max at $100/month (GitHub Blog — Copilot Individual Plans, Flex Allotments, and Max).

Copilot Max includes $100/month in GitHub AI Credits plus a $100 flex allotment, for $200 in total monthly included usage. Additional credits can be purchased beyond the allotment.

Context: agent sessions consume AI credits (token-based billing, not seat-based). For background on how GitHub’s credit billing works, see our Copilot AI credits builder guide.

Sign-up status has changed since launch. GitHub paused new sign-ups for Copilot Student, Pro, Pro+, and Max in April 2026 due to agentic-workflow compute demand, then began gradually reopening them on June 17, 2026 (GitHub Changelog — Copilot individual plan sign-ups are reopening). As of this audit, GitHub’s own pricing page shows a live “Get started” button for Max, indicating new sign-ups are open (GitHub Copilot Plans and Pricing) — check that page for current status before assuming a pause.

Builder Decision Guide

Adopt now if:

• Your team manages 10+ open PRs at any time and Agent Merge’s CI/review automation would recover meaningful time
• You’re running parallel agent workstreams (refactoring, testing, migration, docs) and need proper isolation between them
• You’re building tools on the Copilot SDK — it’s GA, the surface is stable

Adopt cautiously if:

• You’re on a Copilot Business or Enterprise plan and haven’t verified your security team is comfortable with cloud sandboxes processing your code
• Your workflows depend on custom branch protection policies — confirm Agent Merge respects them as documented before relying on it

Wait if:

• You’re a light single-repository user — the IDE extension covers your use case; the app’s value is in multi-repo, multi-session scale
• You need Mac-specific enterprise MDM management of the app — check GitHub’s documentation for current enterprise deployment support

(Note: at original publish, Copilot Free was waitlist-only. As of the July 7, 2026 rollout, the app is available on every plan including Free, so this is no longer a reason to wait — see the Access section above.)

On Copilot Max: Run the math against your actual session volume first. $100/month is a significant step up from Pro+. If you’re running background automations and parallel sessions daily, the credit allotment may justify it. If you’re primarily using it for interactive sessions, it probably doesn’t yet.

What to Watch

At original publish, the technical preview framing meant the feature set wasn’t final — that has since played out: the app went GA on June 17, 2026 and opened to all plans on July 7, 2026 (see Access section above). What’s still worth watching:

• Enterprise deployment support — IT-managed rollout, MDM, and network proxy support details
• Copilot SDK ecosystem — which third-party integrations ship and their quality
• Chronicle and scheduling capabilities — both were mentioned at announcement but details were thin at the time

This is a substantive shift in what GitHub Copilot is. The IDE extension model — you write, the assistant suggests — is no longer the only offering. The Copilot app is a bet that developers increasingly want to manage agents doing work, not just get suggestions while writing code themselves.

Whether that bet lands depends on how Agent Merge, canvases, and the SDK ecosystem develop over the next several months.

Sources: GitHub Blog — Copilot App: The Agent-Native Desktop Experience, GitHub Changelog — Expanded Technical Preview (June 2, 2026), GitHub Changelog — Copilot SDK is now generally available, GitHub Changelog — GitHub Copilot app generally available (June 17, 2026), GitHub Changelog — Copilot individual plan sign-ups are reopening, GitHub Changelog — GitHub Copilot app available to all (July 7, 2026), GitHub Docs — Risks and mitigations for GitHub Copilot cloud agent, GitHub Blog — Copilot Individual Plans and Max, GitHub Copilot Plans and Pricing, GitHub Copilot app releases