GitHub shipped a technical preview of the Copilot desktop app last week, and in a surprise twist, the download is already lighting up for users on free plans—not just paid subscribers. The app, which lands on Windows 11, Windows 11 on Arm, macOS, and Linux, is a standalone control center that lets you dispatch multiple AI coding agents, watch their work in parallel, and steer how much autonomy they get.
When the preview was first announced during Microsoft Build 2026, GitHub said it would require a Copilot subscription. That left free-tier developers on the sidelines. But current documentation now states that access has opened to all GitHub Copilot plans, including the free tier in supported scenarios. If you’ve been waiting to see what agent-driven coding feels like without opening your wallet, this is your on-ramp.
A New Command Center for AI Coding Agents
The Copilot desktop app is not another chat panel. Think of it as an air-traffic-control screen for software development. Instead of pasting a prompt into an IDE sidebar and copying the output line by line, you assign a discrete chunk of work to an agent. The agent spins up an isolated workspace, pulls repository context, writes code, runs tests, and prepares a pull request—all while you monitor progress from a single dashboard.
You can have several sessions running at once. Each session gets its own Git worktree and branch, so an agent fixing a startup crash won’t trample on another agent’s test expansion. The app ties directly into GitHub repositories, issues, pull requests, and CI results. That means you can kick off work from an actual GitHub issue or a plain-language direction, and the agent will use the full context of the project rather than guessing from a few scattered files.
What You Can Actually Do with the App
The app organizes work around three modes that you choose per session:
- Interactive mode keeps you in the loop at every step. It’s suited for debugging a delicate subsystem, exploring an unfamiliar codebase, or working through a design decision where you want frequent course correction.
- Plan mode lets the agent inspect the repository and propose an approach before changing a single line. You can correct assumptions, shrink the scope, or add constraints, then authorize implementation. This is the safest default for anything touching authentication, data migrations, or public APIs.
- Autopilot mode gives the agent more independence for bounded, repeatable tasks—think bumping a package version, adding missing unit tests for a narrow module, or cleaning up lint violations. Autonomy is a spectrum, not a permission slip to merge blind.
Once an agent finishes, you inspect the diff, run any remaining validation—the app can surface CI results—and decide whether to open or update a pull request. The pull request remains the approval gate; the agent proposes, you dispose.
Is It Really Free? Pricing and Plans
The initial headline said “subscribers only.” And it’s true that early preview builds required an active Copilot Individual, Business, or Enterprise plan. But the situation has already shifted. GitHub’s own documentation now lists the app as available across all plans, and the download page does not gate installation behind a paid subscription. Free-plan users can download and authenticate today, though some capabilities—particularly those that consume heavy model inference or cloud sandbox time—may be metered or limited.
Microsoft has also confirmed a waitlist for background agents that run while you’re away from the keyboard; that tier will almost certainly be paid. For now, the core desktop app is essentially a free trial of the agentic workflow, with the meter running only when you lean on premium models or extended cloud sessions.
For Windows Developers: A Companion, Not a Replacement
If you live in Visual Studio 2022, Visual Studio Code, or JetBrains Rider, you won’t abandon your IDE. The desktop app sits beside those tools. You might debug a .NET memory dump in Visual Studio while the Copilot app quietly chews through a test-coverage gap for your API client and a dependency-update branch—all in parallel.
On Windows 11 on Arm, the app is particularly interesting. Arm-native developer tools are still catching up, and a lightweight agent console that can offload heavy lifting to cloud sandboxes could smooth over gaps in local toolchain support. Official platform documentation says Windows on Arm is supported, but if you’re working in a managed enterprise environment, check with IT on policy compatibility, proxy rules, and endpoint protection before depending on it.
How We Got Here: From Chat to Agents
Copilot started as an autocomplete tool, then grew a chat panel, then learned to open pull requests. But in the past year, the competition changed what developers expect. Cursor built an editor around repository-aware AI that can modify files across your project. Claude Code brought terminal-first agenting that reasons about architecture. Developers began demanding AI that does more than answer questions—they want it to make progress on real work while they focus on higher-level decisions.
The desktop app is GitHub’s answer. It leverages the one thing none of those competitors have: the deepest possible integration with the issues, PRs, Actions pipelines, and branch protections that structure modern development. That’s a big bet. It says that the AI assistant of the future isn’t a smarter autocomplete box; it’s a management layer that sits on top of your workflow, coordinating semi-autonomous helpers that speak your project’s language because they’re plugged into your GitHub life.
Getting Started: What You Need and How to Try It
Here’s the practical checklist:
- Download the app from desktop.github.com/download. It’s available for Windows, macOS, and Linux.
- Sign in with your GitHub account. If you have any Copilot plan—yes, including free—you should be able to authenticate. If you hit a paywall, join the waitlist; GitHub says general free-plan availability is coming.
- Pick a starter task. Don’t aim for a production hotfix right out of the gate. Try an isolated chore: add unit tests for a single function, update a well-documented dependency, or clean up a few lint errors.
- Use Plan mode first. Get the agent to explain what it intends to do. Review the plan, then let it execute. This builds muscle memory for supervision.
- Keep an eye on the clock. Agent sessions can be resource-hungry. If you’re on a free plan, note that cloud sandbox time and premium model calls may be limited. Start small and monitor your usage dashboard.
Administrators: For Copilot Business and Enterprise, the app requires that Copilot CLI-related policies be enabled by an admin. Don’t assume agents are blocked by default; verify in your org settings.
The Risks: What to Watch Out For
No matter how slick the dashboard, agents can still produce plausible-but-wrong code at surprising speed. Here’s where the sharp edges are:
- Context blindness. An agent that seems to understand your issue might miss an unspoken architectural rule or security constraint. Plan mode mitigates this, but it’s not a guarantee.
- Review fatigue. If agents start flooding your pull request queue with low-quality changes, the sign-off cost can outweigh the time saved. Gate autonomy carefully: the harder a change is to reverse or test, the less leash the agent gets.
- Security exposure. Agents can execute terminal commands, pull dependencies, and touch files. Worktree isolation prevents branch collisions but does not sandbox the system. Use cloud sandboxes or policy controls for anything risky, especially in enterprise environments.
- Cost surpises. Autonomous sessions eat compute. A long planning loop with a premium model or repeated CI reruns can burn through credits fast. Check your plan limits and stick to lighter models for simple tasks.
What’s Next
Microsoft has signaled that a paid tier for background agents—agents that run unattended, reviewing code or updating dependencies—is on the horizon. There’s also a larger restructuring afoot: all consumer and enterprise Copilot experiences are merging into one unified product by August, with underperforming features getting cut. For the desktop app, that likely means continued investment and tighter integration.
In the short term, treat this preview as a sandbox. Use it for low-risk tasks, build your supervision instincts, and pay attention to how the economics evolve. The app won’t replace your IDE, but it might just change how you dispatch and review work—especially on Windows, where the developer toolbox is finally getting a centralized agent dashboard that plays nicely with the platform you already run.