GitHub Copilot Review 2026: Pricing, Models, Agent Mode

GitHub Copilot is the most widely deployed AI coding tool in the world and, for a lot of developers, the default. In 2026 it stopped being just “autocomplete that finishes your function” and turned into a sprawling product family: inline completions, IDE chat, multi-file edits, an autonomous agent inside your editor, a cloud agent that opens its own pull requests, a CLI, a code-review bot, and a Workspace surface that ties it all together. It’s also multi-model now — Claude, GPT-5, Gemini, and the OpenAI o-series all run behind the same UI. This review covers what Copilot is great at, what’s quietly getting more expensive, and how it stacks up against Cursor and Claude Code in real work.

What makes GitHub Copilot different in 2026

Copilot’s edge isn’t a single model or a clever UI trick — it’s distribution. GitHub hosts most of the world’s open source and a huge share of private code, and Copilot is wired directly into that fabric. When you open an issue, Copilot can grab it. When you open a PR, Copilot reviews it. When CI fails, Copilot can iterate on the fix. The competition has better individual surfaces in places — Cursor’s tab UX, Claude Code’s terminal autonomy — but no one else gets to start a coding session from a GitHub issue link without setup.

The 2026 shape of the product is roughly four layers stacked on top of each other:

• Completions — the original Copilot. Inline ghost-text suggestions in VS Code, JetBrains, Visual Studio, Xcode, Vim/Neovim, Eclipse, and Zed.
• Chat and Edits — IDE-side chat for Q&A, plus targeted multi-file edits when you want a small, scoped change rather than a full agent run.
• Agent mode — autonomous in-IDE agent that picks files, runs terminal commands, watches tests, and iterates. GA in March 2026 in VS Code, with JetBrains and Visual Studio in preview.
• Coding agent (cloud) — assign a GitHub Issue to Copilot and it runs on Actions runners, branches the repo, writes the code, runs tests, and opens a PR. Reachable from GitHub.com, IDEs, Jira, Slack, and Linear.

The honest summary: Copilot is no longer the best at any single thing, but it’s the only assistant where all four of those layers share the same auth, the same repo context, and the same billing. For teams already standardized on GitHub, that integration tax savings often outweighs the per-feature gaps.

Real workflows: code completion, Chat, Edits, Agent mode

Code completion is still the workhorse. Ghost-text suggestions appear as you type in any supported editor and are tuned heavily on GitHub’s training data. For boilerplate, conventional patterns, and the next two or three lines of obvious code, it’s near-instant and usually right. It’s not differentiated anymore — every competitor does this competently — but it’s the feature you’ll touch a thousand times a day.

Chat lives in the IDE, on GitHub.com, in GitHub Mobile, and in Windows Terminal. Use it for the questions where you want to stay in context: “explain this function,” “why is this test failing,” “how do we handle auth in this repo.” Quality depends entirely on which model you’ve selected (more on that below) and how much context Copilot can pull. This is where Cursor still has a real edge — its repo retrieval is more aggressive — but for most everyday “what does this code do” questions, Copilot Chat is good enough and already authenticated to your repos.

Edits are the middle ground between completion and full agent autonomy. You describe a scoped change (“rename this prop everywhere it’s used and update the tests”), Copilot proposes a diff across multiple files, and you accept or reject. This is the mode I reach for most often: faster than agent mode, more powerful than chat, and the failure modes are easy to spot because you see the diff before anything lands.

Agent mode is the headline 2026 feature. Hand it a task, walk away, come back to a working diff (sometimes). Inside the editor it picks files itself, runs terminal commands, watches the test suite, and re-prompts itself when things break. When it works, it’s genuinely impressive. When it doesn’t, it burns through premium requests fast and you still have to clean up the PR by hand. Treat it like a junior pair programmer with infinite stamina: great for well-scoped, test-covered tasks; risky for anything subtle or load-bearing. For prompt strategy that helps autonomous runs succeed more often, see how to write AI prompts.

Copilot Workspace and the cloud coding agent

Copilot Workspace is GitHub’s attempt to give async AI coding a proper home. It’s task-scoped — one workspace per issue or feature — and it pairs a spec, a plan, and an implementation in a single collaborative surface. Humans and the agent edit the same plan; the agent runs the implementation; reviewers comment in line. It’s where the cloud coding agent and a developer converge.

The cloud coding agent itself is the more dramatic product. The flow is simple: assign a GitHub Issue to Copilot. The agent spins up on an Actions runner, clones the repo, writes a plan, makes changes on a branch, runs tests, and opens a PR for human review. You can trigger it from GitHub.com directly, but also from Jira, Slack, and Linear via Copilot Extensions. Cold start got 20% faster in 2026 thanks to custom Actions images, which matters because every minute the agent runs is a minute you’ll pay for once usage-based billing lands.

Where it’s great: well-defined bugs, dependency bumps, test additions, doc updates, conventional refactors. Where it struggles: ambiguous tickets, cross-cutting changes, anything that requires real product judgment. The honest pattern we’ve seen is that maybe 40-60% of cloud-agent PRs are merge-ready as-is, another 20-30% are useful starting points that a human finishes, and the rest are noise. That’s a real productivity win — but it’s not magic, and the failure rate is going to feel different once Actions minutes start counting against your bill.

Spaces, knowledge bases, and PR review

Copilot Spaces are curated knowledge bundles — pick a set of repos, docs, and transcripts, and Copilot grounds its answers in them for tasks scoped to that Space. It’s the “give the model the right context” mechanism, exposed as a first-class object. It works well, but it’s manual: someone has to curate the Space, keep it updated, and decide what belongs. Sourcegraph Cody’s automatic code search feels more effortless if you’re comparing one feature to one feature; Spaces win when you want the curation to be deliberate and shareable across a team.

Knowledge bases add organization-level repo indexing and custom instructions, both GA in 2026. This is where larger teams get real leverage — instruct Copilot once on coding standards, deployment patterns, internal libraries, and that context flows into every chat, edit, and agent run from anyone in the org. Combined with admin-controlled model allowlists at the Business and Enterprise tiers, it turns Copilot from “an assistant each developer configures” into “a tool the platform team can shape.”

PR review launched as agentic in March 2026. When you open a pull request, Copilot reviews it the way a senior engineer would: gathers project context, leaves inline comments, suggests concrete fixes, and — this is the new part — can hand any of those fixes off to the cloud coding agent to auto-implement and push back to the same branch. It’s available to non-licensed users on public repos, which means Copilot is now reviewing a meaningful fraction of public open-source PRs whether the maintainers asked for it or not. Reviews are useful but not infallible; treat them as a smart first pass, not a substitute for human review.

Multi-model: Claude, GPT-5, Gemini, o-series

Copilot stopped being OpenAI-only a while ago. As of May 2026 the supported model lineup includes:

• Anthropic — Claude Haiku 4.5, Sonnet 4 / 4.5 / 4.6, Opus 4.5 / 4.6 / 4.7.
• OpenAI — GPT-5, GPT-5 mini, GPT-5.5, the o-series reasoning models, and Codex inside the cloud agent. (GPT-5.2 and GPT-5.2-Codex were sunset earlier in 2026.)
• Google — Gemini 2.5 Pro.

In practice you’ll bounce between three of these: Sonnet 4.6 for everyday chat and edits, Opus 4.7 when you need real reasoning on hard refactors or design decisions, and GPT-5 mini as the cheap default that auto-selection tends to route to. Gemini 2.5 Pro is solid for long-context reads. The o-series shines for genuinely thorny algorithmic work where you want the model to think for a while before committing.

Two important gating notes. First, Opus 4.7 — the strongest model in the lineup for serious code reasoning — is restricted to Pro+, Business, and Enterprise tiers only. Pro users lost Opus access in April 2026. If your workflow leans on Opus the way ours does, $10/month Pro won’t cut it; you’re effectively pushed to $39/month Pro+. Second, Copilot’s auto-selection sometimes routes to weaker mini models silently, especially in agent mode. If quality matters on a given task, pin the model explicitly rather than trusting the auto-router.

Pricing: Free vs Pro vs Pro+ vs Business vs Enterprise (and the June 2026 usage-based shift)

Pricing is the messiest part of Copilot in 2026, and the part most likely to surprise you. Here’s the May 2026 picture:

• Free — $0. 50 premium requests/month, 2,000 completions/month. Models include Claude Haiku 4.5, GPT-5 mini, and capped access to Sonnet and Gemini 2.5 Pro. A genuinely useful tier for hobby work and learning.
• Pro — $10/user/month. 300 premium requests/month with $0.04/request overage; unlimited inline completions; unlimited chat/agent on GPT-5 mini. Mid-tier model set. Opus 4.7 is no longer included on Pro as of April 2026. New Pro signups were paused April 20, 2026 — meaning if you don’t already have Pro, you may not be able to subscribe to it at all right now.
• Pro+ — $39/user/month. 1,500 premium requests/month, full frontier model set including Claude Opus 4.7, GPT-5 / 5.5, and Gemini 2.5 Pro. Includes GitHub Spark and third-party agent delegation. New Pro+ signups also paused.
• Business — $19/user/month. 300 premium requests/user, unlimited completions, org policy and license management, audit logs, full model set with admin-controlled allowlists.
• Enterprise — $39/user/month. 1,000 premium requests/user, all models, IP indemnity, deep GitHub.com integration, FedRAMP-authorized model variants, US/EU data residency.

Two things make this pricing harder to plan around than it looks. First, the April 20, 2026 changes: Microsoft paused new Pro and Pro+ signups, removed Opus from Pro mid-cycle, and restricted Opus 4.7 to Pro+ only. That kind of mid-cycle gating is unusual in dev tooling and it stings if you signed up for Pro because of Opus access.

Second, the June 1, 2026 shift to usage-based billing. Copilot is moving away from monthly request quotas toward consumption pricing, and code review will start consuming GitHub Actions minutes. Heavy agent-mode users on Pro routinely burn through 300 premium requests by the middle of the month already; under the new model, every long autonomous run will also rack up Actions minutes. Forecast accordingly. If your team uses agent mode aggressively, it would not be shocking for real costs to land north of $39/month/user even on Pro+ once the new billing kicks in.

Practical rule of thumb: if you only need completions and light chat, Free or Pro is fine. If Opus 4.7 matters to you, Pro+ is unavoidable. If you’re a team, jump straight to Business — the policy and audit features are worth more than the price delta. And whichever tier you pick, watch your usage closely through June and July 2026.

Copilot vs Cursor vs Claude Code

These are the three serious contenders in mid-2026, and they’re genuinely different products solving overlapping problems.

Copilot is the editor-agnostic, GitHub-native option. It runs everywhere (VS Code, JetBrains, Visual Studio, Xcode, Vim, Eclipse, Zed) and wins decisively on GitHub-hosted surfaces: PR review, Actions integration, issue-to-PR cloud agent, organization-wide knowledge bases, IP indemnity at Enterprise. If your code is on GitHub, it’s the lowest-friction option.

Cursor is an editor fork (a customized VS Code) with the most polished tab/edit UX in the category and aggressive automatic context retrieval. For pure in-editor coding flow, it usually feels better than Copilot — predictions land more often, multi-file edits are tighter, the chat sidebar pulls more relevant context without you having to curate a Space. Where it loses to Copilot: anything outside the editor. No native PR review on GitHub, no cloud coding agent assigned to issues, no GitHub Actions integration. See our Cursor review for the full breakdown.

Claude Code is Anthropic’s terminal/SDK agent, optimized for long autonomous runs with Opus 4.7 specifically. It’s not an IDE assistant — it’s a command-line agent that lives in your terminal and works on your filesystem directly. For multi-hour autonomous tasks where you want maximum reasoning quality and minimal IDE overhead, it’s the best option in the category right now. Copilot CLI is comparable in spirit but more tightly bound to GitHub auth and repos. See our Claude AI review for context.

Honest recommendation: most teams should run two of these, not one. Copilot for the GitHub-native surfaces (PR review, cloud agent, completions) plus either Cursor or Claude Code for the deeper coding work. The combined cost — roughly $20-50/user/month — is still cheaper than one mediocre contractor hour, and the productivity delta is real. For more options across the broader category, see our AI tools directory.

Getting started: the 30-minute on-ramp

If you’ve never used Copilot, here’s the fastest path from zero to productive:

• Minute 0-5: Sign up on the Free tier. Go to github.com/features/copilot and enable Copilot on your account. Free gets you 50 premium requests and 2,000 completions a month — enough to evaluate it on real work without committing.
• Minute 5-10: Install in your editor. The Copilot extension exists for VS Code, JetBrains, Visual Studio, Xcode, Neovim, Eclipse, and Zed. Sign in with your GitHub account and completions should start working immediately.
• Minute 10-15: Open Chat in your IDE. Ask it three questions about a real file you’re working on: “explain this function,” “what could go wrong here,” “write tests for this.” This is the fastest way to feel where the quality bar is.
• Minute 15-20: Try Edits. Pick a small refactor — rename a variable across files, extract a helper function, add error handling — and use the Edits surface instead of accepting line-by-line completions. Watch the diff before you accept.
• Minute 20-25: Run Agent mode on a contained task. Pick a scoped task that has tests already (this matters — agent mode iterates against your test suite). Watch what it does. Stop it the first time it goes off the rails. This is how you build intuition for when to trust it.
• Minute 25-30: Decide on a tier. If you mostly use completions and chat, stay on Free. If you’re hitting limits, go Pro at $10/month. If you depend on Claude Opus 4.7 for hard work, accept that you need Pro+ at $39/month. If you’re a team, skip straight to Business.

A few practical things we’d do differently if starting over: pin a specific model in chat rather than trusting auto-selection; treat agent mode as a junior dev who needs supervision rather than an autopilot; build a Copilot Space for any repo you spend more than a few hours in; and check the GitHub Changelog every few weeks because the product moves fast and the pricing moves with it.

Copilot in 2026 is genuinely good, sometimes great, and occasionally frustrating in ways that don’t show up in marketing material. The pricing is in flux, the model gating moves around, and agent mode is more “promising” than “reliable.” But the GitHub integration is unmatched, multi-model access is real, and for any team already on GitHub, the friction-to-value ratio is hard to beat. Just go in with eyes open about what June 2026’s billing change is going to do to your monthly invoice.