GitHub shipped the Copilot App to general availability on June 17, 2026. Not an IDE extension. Not a VS Code plugin. A standalone desktop application for macOS, Windows, and Linux — available on Copilot Pro, Pro+, Business, and Enterprise plans.
The announcement framing called it an “agent-native desktop experience.” That framing is worth examining, because the most genuinely interesting feature in the release is the one that gets least attention in the headline: Agent Merge.
What the Copilot App Is#
The Copilot App is GitHub’s acknowledgment that useful AI development tools don’t have to live inside an IDE. You launch it the way you’d launch a terminal or a browser, not the way you install an extension.
The core experience is a canvas — bidirectional work surfaces where agents present plans, pull request diffs, terminal output, and browser sessions. You can edit, reorder, approve, or redirect work at any canvas surface. If the agent writes a plan you disagree with, you edit the plan. If it takes a wrong turn in a terminal session, you redirect.
Parallel sessions ship with worktree isolation. Each agent session gets its own branch copy of the repository; no manual git worktree add required. You can run three agents on three different issues simultaneously without them stepping on each other.
Cloud Automations schedule and trigger agent runs in GitHub’s cloud — which means the automation runs when your machine is off. Create a recurring prompt to triage new issues every morning, or trigger an agent run when a specific label is applied to a PR. This is the feature most comparable to Claude Code Routines or Cursor 3.5 Automations, and it’s the feature that most clearly extends Copilot beyond the IDE.
BYOM (Bring Your Own Model) is enterprise-oriented: admins can configure approved third-party model endpoints (Azure OpenAI, Anthropic, Google) and developers in that org can route sessions to them. For teams that have already standardized on Anthropic’s API for compliance reasons, this means the Copilot App becomes a front-end for Claude while staying in the GitHub billing and permission model.
Agent Merge Is the Real Story#
Here’s what Agent Merge does: after an agent completes a pull request, it monitors the merge conditions and handles them without human intervention.
That means:
- Watch CI and wait for all required checks to pass
- Identify which required reviewers still need to approve and surface reminders
- Address failing checks — if a test fails because of a missing environment variable or a flaky test retry, the agent handles it
- Wait for the merge queue to clear
- Execute the merge when all conditions are satisfied
This is a qualitatively different feature from “AI writes code.” Writing code is the easy part. The hard part of shipping is the loop of: CI fails → investigate → fix → push → CI fails again → investigate more → eventually get approvals → merge. Agent Merge automates that loop.
The implicit admission here is significant. GitHub is acknowledging that the real developer productivity bottleneck in 2026 is not code generation — it’s the pipeline from generated code to merged code. That’s exactly what most AI coding tools have ignored. They make writing faster and leave the rest of the process unchanged.
Copilot Agent Merge is the first feature in GitHub’s AI suite that treats the PR lifecycle as the unit of work rather than the edit.
How It Compares to Claude Code#
GitHub is careful not to say that the Copilot App is autonomous. The canvas and agent monitoring surfaces are all about human oversight — you watch the agent work, you can intervene at any point. That’s the design philosophy throughout.
Claude Code’s model is different: you give the agent a task, it runs, and you review the output. The agent’s execution is not continuously visible to you while it works; the transcript is. You’re a reviewer, not a supervisor.
Neither model is strictly superior. Claude Code’s approach scales better when you trust the agent with longer horizons — you don’t need to watch. Copilot App’s approach is better for developers who want to stay in the loop on exactly what the agent is doing and redirect it in real time. The canvas interface in particular is well-designed for that use case.
The structural difference is the execution environment. Claude Code runs in your terminal or in Anthropic’s cloud infrastructure via Routines. The Copilot App runs in GitHub’s cloud for Cloud Automations, but the core agent execution for interactive sessions is still running on your machine or in a cloud VM GitHub provisions. You must have the app open for interactive work.
For fully autonomous workflows — agents that run overnight, that spawn subagents, that manage their own context across multi-day tasks — Claude Code’s architecture is still the right choice. The Copilot App is better positioned for interactive, human-supervised development work where the developer wants to remain in the loop.
The Copilot SDK#
The Copilot SDK went GA alongside the app, with support for Node.js/TypeScript, Python, Go, .NET, Rust, and Java. This is the programmatic interface to Copilot’s agent capabilities — the equivalent of Claude Code’s --print and API integration patterns, but wrapped in GitHub’s ecosystem.
The SDK enables CI/CD pipelines to invoke Copilot agents, build internal tools on top of the agent runtime, and compose agent workflows outside of the desktop app. For teams already heavily invested in GitHub Actions, this is the natural path to scripted agent invocation without switching tools.
Memory and context persistence ship as /chronicle — a cross-device context store that works across the desktop app, CLI, VS Code, and github.com. An agent’s working knowledge of your codebase, your preferences, and your recent work travels with you between interfaces.
The Billing Question#
Every Copilot feature in 2026 comes with a billing question attached, given the June 1 transition to GitHub AI Credits. Agent Merge and Cloud Automations consume credits. Parallel sessions consume credits. The app is not a flat-rate product for heavy use.
GitHub has not published a per-task cost breakdown for Agent Merge, which is characteristic of how Copilot has handled billing transparency generally — you find out what something costs by using it. Given the experiences some developers have had with week-two billing, it’s worth enabling budget alerts in your GitHub settings before running Agent Merge on a large backlog.
What This Means#
The Copilot App is the most sophisticated thing GitHub has shipped for AI-assisted development. Agent Merge is a genuinely novel feature. Cloud Automations bring GitHub into the scheduled-agentic-workflows space. The canvas interface is well-executed.
It’s still fundamentally a supervised tool. Every meaningful decision surface has a human approval gate. That’s not a flaw — it’s appropriate for many development workflows. But it means the Copilot App is competing with Cursor and IDE-embedded tools more than it is competing with Claude Code’s fully agentic terminal model.
The autonomy ceiling is still there. What GitHub has done is raise it noticeably, and build a better dashboard for working up against it.
Sources: