Researched
This analysis is based on documentation, public user reports, and vendor materials — not yet on our own hands-on testing. How we rate
The change that reframes Copilot
On 1 June 2026, GitHub replaced Premium Request Units with GitHub AI Credits. One credit equals one cent, and billing now tracks actual token consumption — input, output, and cached — at each model's listed API rate.
Sticker prices didn't move. Pro is still $10, Business still $19 a seat.
What moved is what those prices buy, and the trade press summarized the reaction bluntly: "You will get less, but pay the same price."
But there's a detail in the new model that most coverage buries, and it changes how you should think about the whole product:
Code completions remain unmetered.
Tab to accept, the thing Copilot was originally built to do, costs nothing beyond your seat. What consumes credits is Chat, agent mode, code review, the cloud agent, Copilot CLI, and Copilot Apps.
So the expensive Copilot is the agent. The cheap Copilot — the one that made it the default AI coding tool for millions of developers — is still cheap.
What each plan includes
| Plan | Price | Included credits |
|---|
| Free | $0 | Limited; supports CLI and agent mode |
| Pro | $10/mo | $15 |
| Pro+ | $39/mo | $70 |
| Max | $100/mo | $200 |
| Business | $19/user/mo | $19 (org-pooled) |
| Enterprise | $39/user/mo | $39 (org-pooled) |
Look at the individual tiers again. Pro costs $10 and includes $15 of credits. Pro+ costs $39 and includes $70. Max costs $100 and includes $200.
That's GitHub subsidizing the consumer plans — you get one and a half to two times your money back in usage allowance. Business and Enterprise seats are one-to-one, no subsidy.
It's an unusual structure and worth noticing, because it means the individual plans are better value than the headline suggests, and the team plans are exactly what they say.
What it actually costs to use
The included credits sound generous until you meter real work.
A Pro user doing mostly tab completion with occasional Chat runs roughly $1-3 of credits per day.
Do the arithmetic: three dollars across twenty working days is $60, against a $15 included allowance. A light month fits comfortably. A moderate month overflows.
Agent-heavy work goes considerably higher, because agent mode isn't one call — it plans, edits several files, runs commands, reads output, and iterates. Each of those steps meters.
Practical advice: check your billing dashboard after two weeks, not at month end. GitHub added a preview bill experience specifically so you can see projected costs, and admins are encouraged to set budgets. That's the tooling to use before the invoice arrives rather than after.
Also worth knowing: fallback experiences for exhausted credit pools are going away. Under the old system, running out downgraded you to something. Increasingly, running out means stopping.
If you're on an annual plan, read this
This is the part that genuinely disadvantages people, and it runs opposite to how grandfathering usually works.
Annual Pro and Pro+ subscribers didn't migrate to credits. They stayed on premium-request pricing until their plan expires.
That sounds protective. It wasn't — because the model multipliers increased sharply for them on 1 June:
| Model class | Old multiplier | New multiplier |
|---|
| Claude Opus-class | 7.5x | 27x |
| GPT-5-class | 1x | 6x |
A multiplier means one prompt to a frontier model counts as that many requests against your quota. Going from 7.5x to 27x is a 3.6-fold increase in what a single Opus-class prompt costs you.
So prepaying for a year didn't lock in a rate. It locked you into a system that got more expensive while everyone else moved to a different one.
At expiry, annual plans convert to Copilot Free with the option to upgrade to a monthly paid plan. GitHub does offer prorated credits if you convert to monthly before expiry, which is worth calculating — if you're mid-term on an annual plan and using frontier models, converting early may cost less than serving out the multipliers.
For reference on how these multipliers bite: Copilot code review alone carries a multiplier of 13 under the legacy system. Each pull request review consumes thirteen premium requests.
Where Copilot is genuinely good
Having spent most of this on billing, credit where it's due — because the product is strong.
Inline completion is still the best in the category, and it's unmetered. For a developer who mainly wants AI finishing their lines and occasionally answering a question, $10 a month is excellent value and always has been.
Agent mode reached general availability on JetBrains in March 2026, having been VS Code only. That's a real unlock for the substantial population of Java, Kotlin, and Python developers who don't use VS Code.
It's everywhere. VS Code, JetBrains, Visual Studio, Neovim, the CLI, and GitHub.com itself. Native integration with pull requests, issues, and Actions is something no third-party tool can match, because it's the same company.
Team economics undercut Cursor at every comparable tier, most dramatically at scale. For an engineering organization already living inside GitHub, that's usually decisive.
Where it stops making sense
Heavy agent use. If you're in agent mode most of the day, credits vanish and the overage adds up. That's the specific case where Cursor's flat pricing with unmetered Auto mode can work out cheaper, and where Claude Code's subscription economics also look better.
Model flexibility. Copilot gates its best models behind higher-priced plans. Cursor lets you bring your own API keys and switch models freely, and Cline lets you point at any provider at all.
Cost predictability. Token metering means your bill tracks your workload, which is honest and unpredictable. Teams that need a fixed number will find that uncomfortable.
Copilot vs the alternatives
Against Cursor: Cursor is a purpose-built AI editor at $20 with more mature agent workflows and free model switching. Copilot is $10, works in the editor you already use, and completions don't meter. For inline assistance on a budget, Copilot; for agent-heavy work, Cursor's flat tiers usually cost less at volume.
Against Claude Code: Claude Code is terminal-native and agentic, with subscription economics that beat API billing decisively at real volume. Copilot is editor-native with better completion. Different modes — many developers run Copilot for completions and Claude Code for delegated tasks.
Against Cline: Cline is free and open source, bring your own API key, with no seat fee at all. You pay only for inference, and failed work costs what it costs. For developers who want control and don't mind managing keys, that's the cheapest serious option. Copilot is the turnkey one.
Against Tabnine: Tabnine runs locally with a privacy-first posture, which matters for teams that can't send code to a vendor. Copilot is cloud-based with better raw capability. For compliance-constrained work, Tabnine; otherwise Copilot.
Against Augment Code: Augment indexes 400,000-plus files for cross-repo context that Copilot doesn't match on large codebases. It's credit-priced and considerably more expensive. For sprawling multi-repo estates, Augment; for everyday work, Copilot.
Pricing 2026
| Plan | Monthly | Credits included | Best for |
|---|
| Free | $0 | Limited; CLI and agent mode supported | Trying it, light personal use |
| Pro | $10 | $15 | Most individual developers |
| Pro+ | $39 | $70 | Frontier models and regular agent use |
| Max | $100 | $200 | Sustained high-volume agent workflows |
| Business | $19/user | $19, org-pooled | Teams needing admin controls |
| Enterprise | $39/user | $39, org-pooled | Large orgs, compliance, policy management |
Pricing checked August 2026 against GitHub's plans page. AI Credits replaced Premium Request Units on 1 June 2026; one credit equals $0.01, billed on token consumption at listed model API rates. Completions remain unmetered. Chat, agent mode, code review, cloud agent, CLI, and Apps consume credits, with usage varying by model. Annual Pro and Pro+ subscribers remain on legacy request pricing with increased multipliers until expiry. Additional usage can be purchased on paid plans; admins should set budgets.
Plan guidance:
Pro at $10 remains the best value in AI coding tools for anyone whose usage is mostly completions. Unmetered completion plus $15 of credits covers a light-to-moderate month, and the price hasn't moved.
Pro+ at $39 is for developers using frontier models and agent mode regularly. The $70 of included credits is where the subsidy is largest.
Max at $100 is for sustained agentic workflows, and it's new territory for Copilot — a tier that exists because the product became something you delegate to rather than something that autocompletes.
Business at $19 is the team default and undercuts equivalent Cursor seats meaningfully. Note the pooled allowance: credits are shared org-wide, so one heavy user draws from everyone's balance.
If you're on annual, run the numbers on converting early. Prorated credits plus escaping 27x multipliers may beat serving out the term.
Our Verdict
GitHub Copilot is still the sensible default for most developers, and the June 2026 billing change doesn't alter that as much as the headlines suggested. Completions remain unmetered, which means the core experience that made Copilot ubiquitous — good inline suggestions in whatever editor you use — still costs $10 flat. Agent mode reaching JetBrains, native GitHub integration, and team pricing that undercuts Cursor at every tier keep it the default for organizations already inside the ecosystem.
The honest problems are all downstream of metering. Token-based credits mean agent-heavy work costs more than it did, and a moderate month on Pro tips into overage at $1-3 of credits a day. Annual subscribers got a worse deal rather than protection — multipliers on Opus-class models went from 7.5x to 27x while everyone else moved to a different system entirely. Fallback experiences for exhausted pools are being removed. And gating better models behind higher tiers is a real constraint against tools that let you bring your own keys.
There's a fair counterargument to all of it: premium requests were a fixed bucket where light users subsidized heavy ones, and per-token credits make the actual cost of each task visible. That's a more honest structure, and it will probably push agent design toward efficiency. It just feels worse to pay for.
For completion-first developers, recommend at Pro — it's still the best $10 in this category. For agent-heavy work, price Cursor and Claude Code before assuming Copilot is cheapest.
Note: GitHub Copilot does not currently have an active affiliate program with AIVario. We earn no commission, and this rating carries no commercial incentive.
Best for: Developers who mainly want excellent inline completion, teams already inside GitHub, JetBrains users now that agent mode has arrived, cost-conscious engineering organizations
Not ideal for: All-day agent mode users (credits go fast), developers wanting free model choice, teams needing a fixed predictable bill, anyone mid-term on an annual plan using frontier models
Bottom line: Completions are still unmetered and still excellent, which keeps Pro at $10 the best value in AI coding. The agent is what bills now — check your dashboard at week two, not month end.
- Cursor — purpose-built AI editor with flat tiers that suit agent-heavy work
- Claude Code — terminal-native agent with favourable subscription economics
- Cline — free and open source, bring your own API key
- Tabnine — local, privacy-first completion for compliance-constrained teams
- Augment Code — deep cross-repo context for large multi-repo codebases
Frequently Asked Questions about GitHub Copilot
What changed in Copilot's pricing on June 1, 2026?
GitHub replaced Premium Request Units with GitHub AI Credits, where one credit equals one cent. Instead of counting requests at a flat rate regardless of workload, billing now tracks actual token consumption — input, output, and cached — using each model's listed API rates. Base subscription prices didn't change, but what those prices buy did, particularly for agent mode, code review, and long repository-wide tasks. GitHub's own framing was that request units were no longer precise enough to represent what modern Copilot usage consumes.
How much does GitHub Copilot cost in 2026?
Free at $0, Pro at $10/month including $15 in credits, Pro+ at $39 including $70, and Max at $100 including $200. Business is $19 per user monthly including $19 in credits, and Enterprise $39 per user including $39, both drawing from an organization-pooled allowance. Note that individual plans include more credit value than they cost while business seats are one-to-one — a quiet subsidy on the consumer tiers.
Do code completions use credits?
No, and this is the most important thing to understand about the new model. Inline completions — the original Copilot behaviour, tab to accept — remain unmetered. What consumes AI Credits is Chat, agent mode, code review, the Copilot cloud agent, Copilot CLI, and Copilot Apps. So a developer who mostly writes code with completions running alongside will barely touch the allowance, while someone living in agent mode will exhaust it. The expensive Copilot is the agent.
What does real usage actually cost?
For a Pro user doing mostly tab completion with occasional Chat, roughly $1-3 of credits per day. Against the $15 monthly allowance that stretches a light month comfortably, and a moderate month tips into overage — three dollars a day across twenty working days is $60 against a $15 included balance. Agent-heavy work runs considerably higher. The practical advice is to check your billing dashboard after the first fortnight rather than at month end.
I'm on an annual plan. Am I grandfathered?
Not in a good way, and this deserves attention. Annual Pro and Pro+ subscribers stayed on premium-request pricing until their plan expires rather than migrating — but the model multipliers increased sharply for them on June 1. Claude Opus-class models went from 7.5x to 27x, and GPT-5-class from 1x to 6x. So prepaying didn't lock in your rate; it locked you into a system that got more expensive. At expiry the plan converts to Copilot Free with the option to upgrade monthly, and GitHub offers prorated credits if you convert early.
What is a model multiplier?
Under the legacy request system, one prompt to a frontier model counted as several requests rather than one. Copilot code review carried a multiplier of 13, meaning each pull request review consumed thirteen premium requests from your quota. The multipliers were the mechanism that made frontier model access expensive without changing the headline number, and their sharp increase on June 1 for annual subscribers is why prepaid plans got materially worse rather than staying flat.
Is agent mode available in JetBrains?
Yes, since March 2026 agent mode is generally available on both VS Code and JetBrains. That mattered more than it sounds — it had been VS Code only, which excluded a large share of Java, Kotlin, and Python developers who work in JetBrains IDEs. Agent mode plans and executes multi-step tasks: it decides which files need changing, edits across them, runs terminal commands, reviews the output, and iterates. Every one of those steps consumes credits.
Copilot or Cursor — which costs less?
Copilot undercuts Cursor at every comparable tier, most dramatically at the team level, which keeps it the default for cost-conscious engineering organizations already inside GitHub. The exception is heavy agent use — if you regularly exhaust your credit allowance and $39 for Pro+ feels steep, Cursor's flat pricing with unmetered Auto mode can work out cheaper. Cursor also allows bringing your own API keys and switching models freely, where Copilot gates its best models behind higher tiers.
What did developers say about the change?
The prevailing reaction was captured in one trade headline as 'you will get less, but pay the same price.' Comments on GitHub's own FAQ thread raised reduced included value, less predictable usage, model access concerns, missing rollover details, and whether Copilot still competes against direct model APIs and rival tools. A counterargument worth noting: credits make per-task cost visible where premium requests were a fixed bucket that quietly subsidized heavy users at light users' expense. That's a more honest structure even if it feels worse to pay.
