GitHub Copilot is the tool that established this category, and it’s spent the last year doing something unusual for a market leader: adding plans and features instead of raising the price and coasting. There’s now a free tier, three paid individual plans above it, and a model picker that lets you choose from Claude, Gemini, and GPT-5. Whether that makes it worth the money depends on which tier you’re actually looking at.

What GitHub Copilot is

Copilot is a plugin, not an editor. It runs inside VS Code, JetBrains IDEs, Neovim, Visual Studio, and Azure Data Studio. You don’t switch tools to use it — you install an extension into whatever you’re already using, and the AI features show up in a sidebar chat panel and as ghost-text completions as you type.

That’s its main structural advantage over Cursor or Devin Desktop: zero workflow change. If you’ve spent years building muscle memory in VS Code or IntelliJ, Copilot doesn’t ask you to give any of that up.

What it actually does

The feature set splits into three layers:

Inline completion is the original Copilot behavior. As you type, it suggests the next line, the rest of a function, or sometimes a whole block. You accept with Tab or ignore it. This is fast and mostly unobtrusive, and it’s what most people picture when they think “GitHub Copilot.”

Chat is a sidebar panel where you ask questions about your code, request explanations, generate tests, or describe what you want changed. It reads the files you have open and can reference specific functions or files you mention. Copilot also runs chat inside GitHub.com, GitHub Mobile, and the Windows Terminal — so you’re not limited to the IDE.

Agent mode goes further. You describe a task, and Copilot opens files, makes changes, runs your terminal commands, and iterates — right inside your editor. It’s not as deep as Cursor’s Composer, but it handles straightforward multi-file work without requiring you to steer each step. Agent mode is available even on the free plan, with limits. Worth keeping separate from it is the Copilot cloud agent: a different thing that runs a task in the background on github.com and opens a pull request when it’s done. That one is a paid feature, included from Pro up (not just Pro+).

Code review lets Copilot comment on a selection of code or a whole pull request inside VS Code or GitHub. On the free plan, this is limited to “review selection” in VS Code. Pro and above get full review capabilities, including PR-level review on GitHub.

Model selection

One of the bigger changes in 2026: Copilot lets you pick the model, and which ones you get depends on your plan. The clearest documented case is Claude. Pro gives you the Sonnet line — Sonnet 4.5 and 4.6 — plus Haiku 4.5. Pro+ and Max add the top tier: Opus 4.7, Opus 4.8, and Fable 5, Anthropic’s most capable model. No individual plan includes the older Opus 4.5 or 4.6 — those are reserved for the Business and Enterprise plans. The picker also carries Google’s Gemini models and OpenAI’s GPT-5 family (the agent run below used GPT-5 mini).

What the free tier includes isn’t pinned down. GitHub describes Free and Student access as a selection of models “subject to change” rather than a fixed list, so treat the free lineup as a moving target — don’t pick the free plan for a specific model.

In practice this means Copilot’s quality ceiling is as high as any tool in this category — you reach the Opus 4.8 and Fable 5 tier at Pro+. The question is which plan you actually need.

Plans and pricing

Above Pro+ sits a Max tier for the heaviest users — the Copilot page in our pricing tracker has the full verified list, including the Business and Enterprise seats. What separates the tiers is less the sticker price than what each unlocks:

Plan	Completions	Models	Agent
Free	2,000/mo (+ 50 chat requests)	A selection, subject to change	Agent mode only; no cloud agent
Pro	Unlimited	Sonnet 4.5 / 4.6, Haiku 4.5 (+ Gemini, GPT-5)	Cloud agent, $15 AI credits
Pro+	Unlimited	+ Opus 4.7 / 4.8, Fable 5	Cloud agent, $70 AI credits
Max	Unlimited	Same models as Pro+; highest limits	Cloud agent, $200 AI credits

A few things worth noting before you pick a plan:

The free tier’s 2,000 completions — plus a separate cap of 50 chat requests a month — go faster than the numbers sound. If you code for 4–5 hours a day with completions on, you’ll probably exhaust the monthly quota in the first week. It’s enough to evaluate the tool, not enough to replace a paid tier for serious use.

Pro is the obvious starting point for individual developers who want unlimited completions. It’s the cheapest paid option in the category. The main limitation at this tier is model access — you won’t get Opus for complex reasoning tasks.

Pro+ is a harder call. The jump in AI credits and Opus model access matters if you’re regularly doing heavy agentic work, but Pro+ costs about the same as a Cursor Teams seat. If you’re choosing between the two, that comparison is worth making directly.

Max is for power users who hit Pro+ limits and need priority access to every new model GitHub ships. Most developers won’t need it.

Two 2026 changes matter before you pick a plan. New sign-ups for the paid individual plans (Pro, Pro+, Max) were paused on April 20, 2026 — existing subscribers keep their plans and can upgrade, but new paid sign-ups may not be available when you read this, so check GitHub’s plans page. And on June 1, 2026 Copilot moved to usage-based billing built on GitHub AI Credits (1 credit = $0.01). The monthly price stays the same, and each plan includes a monthly credit allowance ($15 on Pro, $70 on Pro+, $200 on Max). Once it’s empty, extra usage is billed per token at each model’s rate — debiting credits, not a flat per-request fee — or you can set a spending cap to stop there. One catch: part of that allowance is a “flex” portion GitHub can adjust month to month, so treat the dollar figures as current, not guaranteed.

The real risk isn’t the headline price, it’s predictability. Frontier models burn credits fast — a model like Opus 4.8 or GPT-5.5 runs through them roughly 5–10× faster than a cheap one, and a single complex agent task on Opus can easily eat $0.50–$2.00 of credits in one go. For light use you won’t notice; for heavy agent use, watch the pool.

Who it’s for

Stick with the free tier if you want to evaluate Copilot properly before spending anything. Two thousand completions and the chat panel are enough for a real trial over a couple of weeks.

Pro makes sense if you’re an individual developer who wants unlimited completions in your existing editor without switching tools. It’s the lowest entry point for an unlimited paid tier in this category.

Pro+ is worth it for the premium models — Opus 4.7/4.8 and Fable 5 — and the larger monthly credit allowance. That model access is the real reason to pay the step up from Pro; the cloud agent isn’t, since Pro already includes it. Worth it if you regularly do heavy reasoning or agentic work, overkill if you don’t.

Max is for teams and heavy users who need the highest available limits and priority access to every model GitHub ships next.

Agent mode, tested

We ran Copilot’s Agent mode in VS Code on a real Python project — “add type hints to every function in models.py, packer.py, and engine.py, and a short docstring to each public function.” It planned the work, read the three modules in parallel, searched for every function definition, and applied correct edits across the files.

It got the job done correctly. The one thing that stood out against a side-by-side run in Cursor on the identical task: speed. Copilot took roughly 91 seconds where Cursor’s agent finished in about 56. Both produced shippable edits, so this is a latency difference, not a quality one — but if you lean on agent mode many times a day, the slower loop is noticeable. Treat that as one data point on one task, not a benchmark.

Our take

Copilot’s biggest strengths are structural: it lives in the editor you already use, and its model picker is the most flexible in the category — you can route a task to Claude, Gemini, or GPT-5 depending on what you’re doing. The Pro tier is the cheapest entry point for unlimited completions you’ll find. The caveats are the 2026 plan changes above (paused sign-ups, usage-based billing) and that its agent mode, while solid, is a step behind Cursor’s Composer on speed and on the hardest multi-file work. If agent mode stalls or completions stop showing up, check Copilot’s live status before you assume it’s your prompt or your credits. For developers who want AI without leaving VS Code or JetBrains, it remains the default — and for most people, Pro is the tier that makes sense. If your remaining question is what Copilot does with your code, we cover Copilot’s privacy and security settings separately.

---

See also: The complete guide to AI coding assistants · Cursor vs GitHub Copilot · Cursor review

• ai-coding-assistants
• github-copilot

Frequently asked questions

Is GitHub Copilot free?

Yes, there's a free tier at $0 with 2,000 code completions and 50 chat requests per month, plus a selection of models — GitHub describes the free lineup as subject to change rather than a fixed list. It's enough to evaluate the tool over a couple of weeks, but heavy users exhaust the 2,000 completions within the first week.

How much does GitHub Copilot cost?

There are four individual plans: Free, Pro at $10/month (unlimited completions, the Sonnet and Haiku Claude models, and the cloud agent), then Pro+ (adds the top models — Opus 4.7/4.8 and Fable 5 — plus more AI credits) and Max (highest limits). Pro is the cheapest unlimited tier in the category; the pricing snapshot in this review and our pricing tracker carry the verified current figures.

Which GitHub Copilot plan should I choose?

Pro is the right starting point for most individual developers who want unlimited completions in their existing editor. Step up to Pro+ only if you regularly run agent mode on complex tasks and need Opus-level reasoning. Max is for power users hitting Pro+ limits.

What changed with GitHub Copilot pricing in 2026?

Two things. New sign-ups for the paid individual plans were paused on April 20, 2026 (existing subscribers keep their plans), so check GitHub's plans page. And on June 1, 2026 Copilot moved to usage-based billing built on GitHub AI Credits (1 credit = $0.01): the monthly price is unchanged, but premium-model use now draws from a monthly credit allowance, and once it's empty extra usage is billed per token at each model's rate — not a flat per-request fee. You can set a spending cap to stop there.