Back to articles

AI costs

GitHub Copilot Pricing 2026: Credits, Max Plan, Real Cost

GitHub Copilot 2026 pricing explained: credits, the Max plan, and real costs. Learn which model price breakpoints drive your bill most.

GitHub CopilotPricingAI CodingDeveloper ToolsCost Optimization
O-mega Team
O-mega Team
•

64 min read

Every Copilot plan is now a dollar allowance spent at per-token model prices. Here is what each plan includes, what each model costs inside it, and what a real task burns.

GitHub Copilot no longer has a price in the old sense. Since June 1, 2026, every Copilot plan has been a monthly allowance of GitHub AI Credits, each worth one cent, spent at the published per-token price of whichever model does the work - GitHub Docs. On November 17, that price list gained OpenAI's GPT-6.2 Astra at $8 per million input tokens and GPT-6.2 Sol at $2 - GitHub Changelog. The same day, Microsoft's own MAI Code 2 arrived at a promotional $0.50 per million input tokens, a price that doubles in May 2027 - GitHub Changelog.

That price list is now the real Copilot price, and it changes how to think about the subscription. Priced with GitHub's own rates, one ordinary 30-step agent task costs about 21 credits on MAI Code 2 and about 365 credits on GPT-6.2 Astra, a spread of more than seventeen times. The gap between the cheapest paid plan ($10) and the most expensive individual plan ($100) is tenfold. In other words, the model you pick moves your bill further than the plan you buy, and most of the confusion about "GitHub Copilot pricing" comes from reading the plan table without the model table beside it.

This guide puts both tables side by side. It covers every plan from Free to Max and the team plans, how AI credits and the variable "flex" allowance actually work, the full model price list including the November 17 additions, worked examples of what real tasks cost, the costs that sit outside the credit meter, the usage levels at which each plan becomes the cheaper one, how Copilot compares with Cursor, Claude Code and Codex, and the tactics that cut a Copilot bill without cutting the work.

This guide reflects GitHub's published plans and prices as of November 20, 2026. Several prices discussed here are promotions with end dates (Copilot Fusion's discount ends November 30, two Gemini promotions end December 1, MAI pricing doubles after May 17, 2027), and GitHub says its flex allowance "will vary over time," so verify current figures before committing a budget.

Contents

  1. GitHub Copilot Pricing at a Glance (November 2026)
  2. How Copilot Got Here: From Premium Requests to AI Credits
  3. How AI Credits Work: Base Credits, Flex and the One-Cent Rule
  4. Every Individual Plan in Detail: Free, Student, Pro, Pro+ and Max
  5. Copilot for Teams: Business, Enterprise and the New Copilot Access
  6. The Model Price List: What Each Model Costs Inside Copilot
  7. What November 17 Changed: GPT-6.2 Astra, GPT-6.2 Sol and MAI Code 2
  8. The Real Cost of a Task: Worked Examples and Reported Bills
  9. Copilot Fusion and Auto Mode: Paying for Routing
  10. The Costs Outside the Credit Meter
  11. Which Plan Fits: The Breakpoints for Individuals and Teams
  12. Copilot vs Cursor, Claude Code and Codex: Pricing Compared
  13. How to Cut Your Copilot Bill Without Cutting the Work
  14. Where Copilot's Pricing Works, Where It Fails, and How It Can Go Wrong
  15. Outlook: Where Coding-Tool Pricing Goes Next

1. GitHub Copilot Pricing at a Glance (November 2026)

The short version is a table, and the longer version is everything that table hides. GitHub sells three kinds of Copilot: free plans that route every request through automatic model selection, individual paid plans that bundle a dollar allowance with a variable bonus, and team plans that pool allowances across seats - GitHub Docs. Here is every plan as GitHub lists it today:

PlanPriceIncluded usage per monthAI creditsModel access
Copilot Free$0Limited chat and agent use, 2,000 completionsNot publishedAuto model selection only
Copilot Student$0 for verified studentsAn allowance GitHub does not publishNot publishedAuto model selection only
Copilot Pro$10$15 ($10 base + $5 flex)1,500Most models, no Opus, Fable or GPT-6.2
Copilot Pro+$39$70 ($39 base + $31 flex)7,000Every model, including Opus, Fable and GPT-6.2
Copilot Max$100$200 ($100 base + $100 flex)20,000Every current model, priority access
Copilot Business$19 per seat$19 per seat, pooled1,900 per seatPremium models, admin policy
Copilot Enterprise$39 per seat$39 per seat, pooled3,900 per seatPriority access to premium models
Copilot access$0 with a GitHub Enterprise Cloud license, or $10 standaloneNone, metered from first use0Same as Enterprise

Three facts explain almost everything in that table. The first is the one-cent rule: one AI credit equals $0.01 and buys exactly as many tokens as one cent buys at the model's per-token price. GitHub bills partner models such as GPT-6.2 at provider list pricing - GitHub Changelog. A plan's credit count is therefore just its dollar allowance multiplied by 100.

The second is that completions are free. Code completions and next edit suggestions are not billed in credits and stay unlimited on every paid plan, which means the feature most people still picture when they hear "Copilot" costs nothing at the margin - GitHub Docs. What consumes credits is everything else: Copilot Chat, the Copilot CLI, the cloud agent, Copilot Spaces, Spark and third-party coding agents.

The third is flex, the variable bonus on the individual plans. Base credits match the subscription price and, in GitHub's words, "will always stay the same," while flex was designed to adapt to model pricing, new models and efficiency gains - GitHub Blog. Flex is the only reason a Copilot individual plan buys more inference than the same dollars spent directly at a lab's API, and it is the one number on the page GitHub can change without changing the price. Team plans have no flex at all.

Which Copilot are you pricing?

A large share of people searching for Copilot pricing are looking at the wrong product, because Microsoft uses the name for two unrelated families. GitHub Copilot is the coding assistant this guide covers, billed in GitHub AI Credits. Microsoft 365 Copilot is the assistant inside Word, Excel, Teams and Outlook, sold as a business license; its business add-on is listed at $18 per user per month, paid yearly, down from $21 under an offer that runs from July 1 to December 31, 2026 - Microsoft.

The confusion deepened at Ignite on November 17, because Microsoft 365 now has its own app builder called Copilot Code, alongside Autopilot and Copilot Cowork. Microsoft's FAQ says those advanced experiences "use Copilot Credits," a separate currency from GitHub's AI Credits, managed in the Microsoft 365 admin center - Microsoft. Microsoft's agent governance product, Agent 365, costs $15 per user per month standalone or comes inside Microsoft 365 E7 - Microsoft Security Blog. E7 itself lists at $99 per user per month and bundles Microsoft 365 E5, Microsoft 365 Copilot, Entra Suite and Agent 365 - Microsoft Tech Community. None of those licenses include GitHub Copilot, and no GitHub plan includes them. For the Microsoft 365 side, our Copilot Cowork analysis covers that product family.

2. How Copilot Got Here: From Premium Requests to AI Credits

Copilot's current pricing makes sense only as the end of a specific economic failure, and understanding that failure is the best predictor of what GitHub will do next. Start from first principles. A flat subscription works when the cost of serving each customer is roughly similar, because the price can sit comfortably above the average cost. It breaks when the cost of serving one customer can be a hundred times the cost of serving another, because the customers whose usage costs more than the price are exactly the ones who stay.

That is what agents did to Copilot. In June 2025, GitHub introduced premium requests, which capped Pro at 300 a month and Enterprise at 1,000 and charged $0.04 for each request beyond - InfoWorld. A request was a unit of interaction, not of cost. A one-line chat question and a multi-hour agent session that read half a repository could each count as one request, so the price per unit stayed fixed while the cost per unit spread across orders of magnitude.

By April 2026 the spread had become unmanageable. On April 20, GitHub paused new sign-ups for Pro, Pro+ and Student, tightened usage limits and removed Opus models from Pro, explaining that "Agentic workflows have fundamentally changed Copilot's compute demands" and that "it's now common for a handful of requests to incur costs that exceed the plan price!" - GitHub Blog. Two days later it paused self-serve Copilot Business sign-ups for organizations on GitHub Free and Team plans - GitHub Changelog.

On April 27, Chief Product Officer Mario Rodriguez announced the structural fix. "Agentic usage is becoming the default, and it brings significantly higher compute and inference demands," he wrote, adding that GitHub had absorbed much of the escalating inference cost and that "the current premium request model is no longer sustainable" - GitHub Blog. From June 1, premium requests would be replaced by AI credits consumed per token at each model's published API rate, and the old fallback to a cheaper model after an allowance ran out would disappear. Greyhound Research's Sanchit Vir Gogia framed the deeper point: per-seat pricing itself was breaking, and "The dashboards do not lower the bill. The architecture lowers the bill." - InfoWorld

The video below, from developer Theo Browne, explains from the user's side why the old model could not last. His own description is blunt: the request-based scheme let him spend "thousands of dollars worth of tokens for just $40." The first part of the video walks through how a single premium request could drive a long agent session, which is precisely the unit mismatch GitHub was pricing away.

The transition then moved quickly. On May 12, GitHub added flex allotments to Pro and Pro+ and announced the $100 Max plan - GitHub Blog. On June 1, usage-based billing went live for every plan, Copilot code review started consuming GitHub Actions minutes, and Max opened as an upgrade for existing subscribers - GitHub Changelog. On June 17, sign-ups for Student, Pro, Pro+ and Max began reopening - GitHub Changelog. A week later, Free and Student moved to automatic model selection as their only option - GitHub Changelog.

The autumn added the pieces that define the current price list. On October 28, GitHub made Copilot Fusion generally available, a router that picks models for you, and introduced Copilot access, which lets eligible GitHub Enterprise customers give Copilot to every licensed user with no seat fee and pay only for usage - GitHub Changelog. And on November 17 came GPT-6.2 Astra, GPT-6.2 Sol and MAI Code 2, the three models that now anchor the expensive, middle and cheap ends of the picker.

The pattern across all of this is consistent. Every step moved cost risk from GitHub to the customer and gave the customer controls (budgets, model choice, routing) in exchange. Whether that is a better deal depends entirely on how you use Copilot, which is what the rest of this guide quantifies.

3. How AI Credits Work: Base Credits, Flex and the One-Cent Rule

Every Copilot bill is computed the same way, and once the mechanism is clear the plan table stops being mysterious. Each request to a model consumes input tokens (what Copilot sends: your prompt, instructions, open files, tool results and conversation history), cached input tokens (the part of that input the provider has seen recently and can serve from cache), and output tokens (what the model writes, including its reasoning). Each type has a per-million price for each model, the total is converted to dollars, and dollars are converted to credits at 100 credits per dollar - GitHub Docs.

On an individual plan, base credits are spent first. When they run out, the flex allotment applies automatically "at the same rates across your IDE, GitHub.com, and Copilot CLI," with nothing to switch on - GitHub Docs. The allowance resets at 00:00 UTC on the first day of each calendar month, regardless of the date you signed up, and unused credits are forfeited rather than rolled over. A plan bought on the 25th therefore gets a full allowance that expires within a week.

When included credits run out, an individual has three choices. You can upgrade, paying only the price difference and receiving the new plan's allowance minus what you have already used. You can set a budget for additional usage, billed at the same one-cent rate. Or you can wait for the reset. GitHub notes that for individual plans it "may limit" additional credits based on usage patterns, billing history and account verification status, so paying for overage is not guaranteed to be available on a new account - GitHub Changelog.

The safe default for anyone who wants a hard ceiling is documented on the price page itself: create or edit a "Bundled AI credits" budget, set it to $0, and enable "Stop usage when budget limit is reached" - GitHub Docs. With that in place, the subscription price is the most you can be charged. Without it, a long agent session that runs past your allowance becomes a line on next month's card statement. One related detail catches mobile users: people who bought Pro, Pro+ or Max through the iOS or Android app stores cannot buy extra credits there, so any usage beyond the allowance is billed to a payment method on GitHub according to their budget settings.

Why the one-cent rule matters more than the plan price

The one-cent rule has a consequence that is easy to miss. Because Copilot charges list price per token, a Copilot credit is worth exactly what the same cent would buy at the model provider's own API. The plan does not give you cheaper tokens. What it gives you is a prepaid allowance at list price, plus flex on individual plans, plus tools (the editor integration, the cloud agent, code review, the router) that you would otherwise have to build or buy.

So the real "discount" of each individual plan is its flex ratio: Pro buys $15 of inference for $10 (1.5 times), Pro+ buys $70 for $39 (about 1.8 times), and Max buys $200 for $100 (2 times). Business and Enterprise buy exactly what they pay for, one to one, before any promotions. That single ratio, more than any feature list, is what you are comparing when you compare Copilot plans.

4. Every Individual Plan in Detail: Free, Student, Pro, Pro+ and Max

The individual ladder is built for a range of usage that runs from a handful of chat questions a month to full-time agent work. Each rung changes three things at once: the size of the allowance, the share of it that is flex, and which models you may pick. The chart shows the first two.

Copilot Free

Free is a trial with a meter you cannot see. It includes up to 2,000 completions a month and "limited chat and agent usage" - GitHub. Since June 24, Free and Student use automatic model selection as their default and only option, so you cannot choose a model - GitHub Changelog. Free includes Copilot CLI, the Copilot app, agent mode and MCP, but not the cloud agent, and code review is limited to reviewing a selection in VS Code. Since November 17, the small MAI Code 2 Flash is one of the models auto can choose for free users - GitHub Docs.

Free is the right plan for evaluating Copilot's editor experience and for people who mostly want completions. It is the wrong plan for evaluating agent work, because the allowance is too small to complete anything substantial and you cannot pick the model whose behavior you want to judge.

Copilot Student (and free Pro for teachers and maintainers)

Verified students get Copilot Student at no cost. It includes the cloud agent and code review but excludes third-party agents, and it uses automatic model selection only - GitHub Docs. GitHub documents that Student has an AI credit allowance but does not publish its size. One student reported on GitHub's community forum that the plan showed 200 credits, worth $2.00, and that all 200 were gone on June 1 after roughly 10 to 20 agent-mode requests - GitHub Community. Treat the figure as one user's account, not a guarantee, but the lesson is general: agent mode spends credits in large steps.

Verified teachers and maintainers of popular open-source repositories can get Copilot Pro free instead, with eligibility re-evaluated every month - GitHub Docs. GitHub does not define "popular," so the only way to know is to check your own account's Copilot settings.

Copilot Pro: $10 for $15 of usage

Pro is the entry paid plan and the one most people should start on. It includes $15 of usage (1,000 base credits plus 500 flex), unlimited completions, the cloud agent, code review and access to third-party agents, which GitHub's plan page names as Claude Code and Codex - GitHub. Its model list is broad but deliberately capped at the middle of the market: Claude Haiku 4.5 and 5.5, Claude Sonnet 4.6, 5 and 5.5, Gemini 3.8 Flash and Gemini 4 Hydrogen, GPT-5.3-Codex, GPT-5.6 Luna, GPT-6 Luna, GPT-6.1 Terra, Grok 4.5 through 4.7, Kimi K3 and the MAI models - GitHub Docs.

What Pro excludes matters as much. There is no Claude Opus or Claude Fable, no GPT-6.2 Astra or Sol, and no Fusion High or Max. Since November 17, the strongest model available on Pro for agent work is arguably MAI Code 2, which Microsoft says matches most of GPT-6.1 Sol's coding performance at a fraction of the cost (Section 7), alongside Claude Sonnet 5.5 for harder tasks.

Copilot Pro+: $39 for $70 of usage

Pro+ is where Copilot becomes a frontier-model product. It includes $70 of usage (3,900 base plus 3,100 flex), every model GitHub lists, including Claude Opus 5.5, Claude Fable 5.2, GPT-6.2 Astra and GPT-6.2 Sol, the High and Max levels of Copilot Fusion, and audit logs. GitHub's plan page markets it as "4x+ included usage than Pro," which matches the arithmetic: 7,000 credits against 1,500 is about 4.7 times - GitHub.

The flex share is what makes Pro+ interesting. Of its $70, $31 is flex, 44% of the allowance, compared with 33% on Pro. Pro+ is therefore the plan whose value depends most on GitHub keeping flex where it is. If GitHub ever cut Pro+ flex to zero, it would become a $39 prepayment for $39 of inference plus model access.

Copilot Max: $100 for $200 of usage

Max is GitHub's answer to heavy agent users and to the $100 and $200 tiers sold by Anthropic, OpenAI and Cursor. It includes $200 of usage (10,000 base plus 10,000 flex), every current model, and "priority access to new models and features," and GitHub describes it as built "for sustained, high-volume agent workflows" - GitHub. The page labels it "Best value," and on the flex ratio alone that is accurate: it is the only plan where flex equals the base, so every dollar of subscription buys two dollars of list-price inference.

Max has two caveats. Half of its value is flex, which is variable by design, so the "$200" is a current number rather than a contract. And Max only beats Pro+ financially for someone who would otherwise spend more than about $131 a month in list-price inference (Section 11). For anyone below that, Max is an expensive way to buy capacity they will forfeit at the end of the month.

5. Copilot for Teams: Business, Enterprise and the New Copilot Access

Team pricing follows a different logic from individual pricing, and in one respect it is less generous: there is no flex. A Business seat costs $19 and contributes 1,900 credits to a shared pool; an Enterprise seat costs $39 and contributes 3,900 - GitHub Docs. Usage beyond the pool costs $0.01 per credit, and completions remain unlimited.

The pool is the feature that makes team pricing work. Credits are pooled at the billing entity, so an enterprise with 100 Business users gets one shared pool of 190,000 credits rather than 100 separate buckets. Adding licenses mid-cycle grows the pool immediately; removing them shrinks it at the next cycle - GitHub Docs. Because most teams have a few heavy agent users and many light ones, pooling lets the light users' unused allowance fund the heavy users' sessions, which recovers much of the value an individual plan would forfeit.

When the switch happened, GitHub cushioned it with promotional credits for June through August: $30 a month per Business seat and $70 per Enterprise seat - GitHub Blog. Those promotions have ended, so a team budget built on summer usage reports is built on an allowance that no longer exists.

The default that surprises administrators

One default matters more than any price. The AI credits paid usage policy is enabled by default for Copilot Business, Copilot Enterprise and Copilot access, so when the pool runs out, usage continues and is billed unless an administrator explicitly disables the policy in AI Controls - GitHub Docs. GitHub provides the controls to stop this: user-level budgets that "always enforce a hard stop," cost-center budgets, organization budgets and enterprise spending limits. But someone has to set them.

A second default compounds the first. Under default model enablement, new models are switched on automatically for Business and Enterprise users unless an administrator has turned off the global default or disabled the model, and that applied to both GPT-6.2 Astra and MAI Code 2 on November 17 - GitHub Changelog. In practice, a model priced at $40 per million output tokens can appear in every developer's picker the day it launches, with paid overage enabled, without anyone in finance making a decision.

Copilot access: the seat fee becomes optional

The most structurally important pricing change of the year got the least attention. Since October 28, enterprises working with a GitHub or Microsoft account team can switch to Copilot access: users with a GitHub Enterprise Cloud license have no Copilot seat charge, users without one can get Copilot Standalone for $10 per user per month, there are no included credits, and metered usage is billed from the first request - GitHub Docs. Copilot access has the same feature and model eligibility as Copilot Enterprise, and code completions and next edit suggestions keep working even when no budget is available.

The arithmetic is worth doing from first principles. An Enterprise seat costs $39 and includes $39 of credits, so a team on Enterprise seats pays the larger of $39 per seat or its actual usage. A team on Copilot access pays its actual usage. The second can never exceed the first. Take an illustrative 50-person team where 10 heavy users each consume $120 of inference a month and 40 light users each consume $8: actual usage is $1,520. On Enterprise seats the bill is $1,950, because the pool's 195,000 credits must be paid for whether or not they are used. On Copilot access the bill is $1,520, with the same features.

There are real constraints. Copilot access is available only through account teams for now, self-serve customers will get it "in the coming weeks," it is not offered to GitHub Free or Team organizations, and it cannot be mixed with Business or Enterprise seats inside the same enterprise. It also presumes a GitHub Enterprise Cloud license, which has its own cost. But the direction is unmistakable. For the largest customers, GitHub has turned Copilot from a seat license into a metered utility, and the seat fee survives mainly as a prepayment for teams that prefer a predictable floor.

6. The Model Price List: What Each Model Costs Inside Copilot

This is the table that actually sets your bill. GitHub publishes per-million-token prices for every model in Copilot, and for models a lab also sells through its own API, Copilot charges the provider's list price - GitHub Changelog. Here are the models most people will choose between, with standard (shorter-context) prices:

ModelInputCached inputOutputLowest planNotes
MAI Code 2 Flash$0.05$0.005$0.25Free (via auto)Promotional until May 17, 2027, then $0.10 / $0.01 / $0.50
GPT-6 Luna$0.10$0.01$0.50ProLightweight
Claude Haiku 5.5$0.10$0.01$0.50ProRises to $0.50 / $2.50 above 100K input tokens
MAI Code 2$0.50$0.025$2.50ProPromotional until May 17, 2027, then $1.00 / $0.05 / $5.00
GPT-6.1 Terra$1$0.05$5ProVersatile
Gemini 4 Hydrogen$1.50$0.075$7.50ProVersatile
Claude Sonnet 5.5$2$0.10$10ProVersatile
Grok 4.7$2$0.50$6ProDoubles above 200K input tokens
GPT-6.2 Sol$2$0.10$10Pro+New Nov 17
Gemini 4 Carbon$2$0.10$10Pro+Promotional until Dec 1, 2026, then $4 / $0.20 / $20
Gemini 4 Neon$3$0.15$15Pro+Released Nov 18
Claude Opus 5.5$4$0.20$20Pro+Powerful
Claude Fable 5.2$8$0.20$40Pro+Prompts retained by default for safety classifiers
GPT-6.2 Astra$8$0.40$40Pro+New Nov 17; $16 / $0.80 / $60 above 272K input tokens

Prices in USD per million tokens. Every Copilot price and promotion comes from GitHub's models and pricing page. Which plan includes each model comes from GitHub's plans page.

The table rewards a slower read than it usually gets. Four features of it decide real bills far more than the headline input price.

Cached input is the price that matters in agent loops. An agent resends its growing context on every step, and providers serve most of that repeated context from cache. In a typical agent session, nine of every ten input tokens can be cache hits, so the cached price is multiplied by the largest token count. This is why Grok 4.7, with a headline input price equal to Sonnet 5.5's, is meaningfully more expensive for agent work: its cached price of $0.50 is five times Sonnet's $0.10. Section 8 shows the effect in dollars.

Cache writes cost extra on OpenAI and Anthropic models. GitHub's full table lists a cache-write price for every OpenAI and Anthropic model, typically 25% above the input price ($10 against $8 for GPT-6.2 Astra, $5 against $4 for Opus 5.5). New context that a harness writes to cache, such as the output of a file read or a test run, is billed at that rate. OpenAI's own documentation for GPT-6.2 Astra lists the same $10 cache-write price for 30-minute retention and $20 for 12-hour retention - OpenAI.

Long context costs more, and it is opt-in. GPT models double their input price above 272,000 input tokens and raise output by half; Claude Haiku 5.5 multiplies its price fivefold above 100,000; Grok doubles above 200,000. GitHub's model documentation notes that the 1-million-token context window is available only in VS Code and Copilot CLI, and that "Choosing a larger context window or higher reasoning will impact AI credits consumption" - GitHub Docs. The cheapest habit in Copilot is leaving both settings at their defaults unless a task needs more.

Promotions are real money with expiry dates. MAI Code 2 and MAI Code 2 Flash are at half price until May 17, 2027; Gemini 4 Argon and Gemini 4 Carbon are promotional until December 1, 2026; Gemini 3.8 Flash is promotional through December 31, 2026. A routing habit that depends on a promotional price is a habit whose cost will change on a known date.

The full list is longer than this table. It also includes older models still available (GPT-6 Astra at $10 input and $50 output, Claude Opus 4.8, Claude Fable 5 and 5.1, GPT-5.6 Sol), Kimi K3 at $3 input and $15 output, a fast mode for Claude Opus 4.8 in preview at double price, and image generation with GPT Image 2.5 Flare billed separately from your session model.

7. What November 17 Changed: GPT-6.2 Astra, GPT-6.2 Sol and MAI Code 2

November 17 reshaped the Copilot picker from both ends at once. OpenAI launched GPT-6.2 Astra and GPT-6.2 Sol that day, rolling them out to ChatGPT Plus, Pro, Business, Enterprise and Edu users in ChatGPT Work and Codex, and to developers as gpt-6.2-astra and gpt-6.2-sol - OpenAI. GitHub made both generally available in Copilot the same day, and Microsoft used the opening of Ignite to put its own coding models into the same picker.

The screenshot GitHub published shows the two new OpenAI models sitting between Gemini 4 Carbon and Claude Fable 5.2, which is the commercial reality of Copilot in one image: the frontier models of three labs competing for the same click, each at its own list price.

GPT-6.2 Astra: the frontier, 20% cheaper

GPT-6.2 Astra costs $8 per million input tokens, $0.40 cached and $40 output, with a context window of 1,050,000 tokens and up to 128,000 output tokens - OpenAI. That is 20% below GPT-6 Astra's $10 and $50, and the cached price fell from $1.00 to $0.40, a 60% cut that matters more than the headline in agent work - TestingCatalog. GitHub's changelog says that in early testing Astra caught more code review issues than GPT-6 Astra while using fewer tokens.

On independent measurement, Artificial Analysis gives GPT-6.2 Astra at max effort a score of 62 on its Intelligence Index, ranked third of 95 models, at $4.00 per index task - Artificial Analysis. Claude Fable 5.2 at max effort leads at 65, but at $26.54 per task, because it spent 275 million output tokens on the index against Astra's 65.8 million - Artificial Analysis. The comparison is the most important pricing lesson in this guide: two models with an identical per-token price can differ more than sixfold in cost per task, because one of them thinks out loud four times as much. Our GPT-6.2 Astra vs Claude Fable 5.2 cost analysis works through that gap in detail.

GPT-6.2 Sol: the same price, a better model

GPT-6.2 Sol keeps GPT-6.1 Sol's price of $2 input, $0.10 cached and $10 output. GitHub's changelog claims that in early testing Sol "caught nearly twice as many real issues as GPT-6.1 Sol" in code review - GitHub Changelog. Artificial Analysis scores Sol at 57 at max effort for $1.01 per index task, a quarter of Astra's cost for five points less - Artificial Analysis. OpenAI itself says new consumer chats in ChatGPT Work default to Sol, not Astra, which tells you which model its own economics favor for everyday work - OpenAI. For the full benchmark picture, see our GPT-6.2 Astra and Sol benchmark guide.

There is one plan detail to note. Both GPT-6.2 models are available on Copilot Pro+, Max, Business and Enterprise, not on Pro. A Pro user who wants OpenAI's newest models has to upgrade; a Pro user who wants OpenAI-class cost efficiency on Pro now has MAI Code 2.

MAI Code 2: Microsoft's house brand at a promotional price

MAI Code 2 is the more consequential launch for Copilot's economics. Microsoft AI says that, averaged across four coding benchmarks (DeepSWE 1.1, Terminal-Bench 2.1, SWE-Atlas and FrontierCode v1.1), MAI Code 2 delivers 98% of the performance of GPT-6.1 Sol at 40% of the cost and 96% of Claude Opus 5.5's performance at 5% of the cost - Microsoft AI. Every model in that comparison ran at max reasoning effort, through the GitHub Copilot CLI, and MAI's costs used the 50% promotional price. Microsoft also says plainly that the models are "explicitly not yet tuned for harder problems, like fundamental science research and very long-horizon agentic work."

In Copilot, MAI Code 2 costs $0.50 input, $0.025 cached and $2.50 output until May 17, 2027, then $1.00, $0.05 and $5.00 - GitHub Docs. It is available on Pro, Pro+, Max, Business and Enterprise; MAI Code 2 Flash reaches those plans plus Free and Student. The headline claims deserve the scrutiny we gave them in our MAI Code 2 analysis, which found that the four benchmarks were chosen to match everyday Copilot work and that the advantage shrinks on harder terminal tasks.

The strategic logic is simple when reasoned from first principles. When a Copilot user picks GPT-6.2 Astra or Claude Opus 5.5, GitHub pays another company for the inference and charges list price. When a user picks MAI Code 2, the whole price stays inside Microsoft. A promotional price on its own model is therefore a customer-acquisition cost: Microsoft gives up half of revenue it would keep entirely, to move routine traffic away from partners' models. For the user, that is a genuine subsidy for routine work through May 2027, and it is the main reason the cheapest sensible Copilot setup in November 2026 looks very different from the one in October.

8. The Real Cost of a Task: Worked Examples and Reported Bills

Per-token prices are hard to feel. What people actually want to know is what a question, a bug fix or an afternoon of agent work costs, and how many of those a plan covers. GitHub does not publish typical token counts per task, so the honest approach is to show the arithmetic with stated assumptions, then check it against costs that GitHub and users have actually reported.

Why agent tasks cost so much more than chat

The mechanism is worth understanding because it explains every surprise bill. A chat question is one model call: Copilot sends your question plus instructions and some file context, and the model answers. An agent task is a loop. The model reads files, runs commands, edits code and checks results, and each step is a new model call that resends the entire conversation so far, including every file it read and every tool output it saw. Context therefore grows with each step, and total input tokens grow roughly with the square of the number of steps.

Caching softens this. Providers charge much less for input they served recently, so the repeated part of the context is billed at the cached price, and only the new part of each step is billed at the full or cache-write price (our guide to prompt caching covers the mechanism across providers). That is why the cached column of the price list matters so much, and why a model with cheap cached input can be cheaper in agent work than one with a cheaper headline input price.

Three worked examples

The examples below apply GitHub's published rates to three illustrative task profiles. The profiles are assumptions chosen to be typical rather than measurements of any particular run: a quick question (15,000 input tokens, 12,000 of them cached, and 800 output tokens); an agent task such as fixing a bug across a few files (30 model calls averaging 60,000 tokens of context, so 1.8 million input tokens, 90% of them cached, and 30,000 output tokens); and a long autonomous run such as a cloud agent implementing a feature (150 calls averaging 120,000 tokens, so 18 million input tokens, 95% cached, and 150,000 output tokens). New tokens are billed at the cache-write price where GitHub lists one, otherwise at the input price.

ModelQuick questionAgent taskLong runAgent tasks covered by Pro+ ($70)
MAI Code 2 Flash (promo)0.04 credits2.5 credits17 creditsabout 2,850
Claude Haiku 5.50.09 credits5 credits179 creditsabout 1,300
MAI Code 2 (promo)0.4 credits21 credits125 creditsabout 340
MAI Code 2 (from May 17, 2027)0.8 credits41 credits250 creditsabout 170
GPT-6.1 Terra0.8 credits46 credits273 creditsabout 150
Claude Sonnet 5.51.7 credits91 credits546 creditsabout 77
GPT-6.2 Sol1.7 credits91 credits546 creditsabout 77
Gemini 4 Neon2.3 credits123 credits751 creditsabout 57
Grok 4.71.7 credits135 credits1,125 creditsabout 52
Claude Opus 5.53.3 credits182 credits1,092 creditsabout 38
Claude Fable 5.26.4 credits332 credits1,842 creditsabout 21
GPT-6.2 Astra6.7 credits365 credits2,184 creditsabout 19

Computed from GitHub's models and pricing page at the assumptions stated above. One credit is $0.01. Claude Haiku 5.5's long run uses its above-100K price. These examples assume every model uses the same number of tokens, which real models do not (see below).

Three results stand out. First, chat is nearly free on every model: even GPT-6.2 Astra answers a quick question for under seven credits, so a Pro allowance covers hundreds of questions on any model Pro offers. The budget problem is entirely an agent problem. Second, within the agent column, what you feed the agent costs more than what it writes. On GPT-6.2 Astra, new context billed at the cache-write price accounts for about half of the $3.65 task, cached reads for about a sixth, and output for about a third. That is why tactics that keep context small (Section 13) beat tactics that make the model terser. Third, Grok 4.7 lands above Gemini 4 Neon despite a lower headline price, purely because of its cached-input price.

The token-efficiency correction

The equal-token assumption understates the real gap between models, sometimes dramatically. Models differ in how many tokens they spend reasoning, and Artificial Analysis publishes that difference directly. At max effort on its Intelligence Index, Claude Opus 5.5 spent 218 million output tokens and cost $10.04 per task - Artificial Analysis. Set beside Fable 5.2's 275 million and GPT-6.2 Astra's 65.8 million (Section 7), that is why measured costs per task diverge so widely despite similar or identical token prices.

These index tasks are not coding tasks, so the dollar figures do not transfer directly to Copilot work. The ratios are the useful part. They say that a model's verbosity can multiply its per-token price several times over, and that the cheapest model per token is not necessarily the cheapest model per finished task. Gemini 4 Neon, released November 18, illustrates the middle of the market: a score of 61 at xhigh effort for $6.44 per task - Artificial Analysis. A team choosing a default model should look at cost per completed task in its own work, not at the price column.

What GitHub and users have actually reported

Two kinds of real-world numbers anchor the worked examples. GitHub itself publishes cost estimates for Copilot code review by effort level: about $0.25 on average for Lite (typically $0.05 to $1), about $1.50 for Balanced ($0.25 to $5), and about $10 for Max ($1.50 to $25), with the model chosen automatically and not disclosed - GitHub Docs. Those figures sit comfortably within the range of the agent-task profiles above.

Users' reports from the first days of credit billing fall in the same range, with more variance. The Register collected accounts of a Pro+ developer who used about 8% of a 7,000-credit allowance in two hours, another who spent more than $6 on a single request, and a Reddit user who used 1,180 credits, 16% of a Pro+ month, fixing a couple of issues with a Claude model - The Register. Those are anecdotes rather than measurements, but they are consistent with frontier-model agent tasks costing between one and a dozen dollars each, which is exactly what the arithmetic predicts.

The practical conclusion is a set of rules of thumb rather than a single number. On a frontier model, budget roughly $2 to $4 for an ordinary agent task and $10 to $25 for a long autonomous run. On a mid-tier model such as Sonnet 5.5 or GPT-6.2 Sol, expect a quarter to a half of those figures. On MAI Code 2 at its promotional price, expect roughly a tenth to a twentieth. Then multiply by the number of agent tasks you actually run in a month, and you have a better forecast of your Copilot bill than any plan table can give you.

9. Copilot Fusion and Auto Mode: Paying for Routing

If the model choice is the biggest lever on a Copilot bill, the obvious question is whether Copilot can make that choice for you. That is what Copilot Fusion sells. GitHub describes it as "an intelligent runtime model router and orchestrator": you select Fusion in the model picker, and for each prompt it decides which models to use and how they should work together - GitHub Docs.

As the menu shows, you choose an effort level rather than a model. Fusion Standard balances cost, quality and latency and is included on every plan. Fusion High and Fusion Max favor more capable models for harder work and are included on Pro+, Max, Business and Enterprise, not on Free, Student or Pro. Behind each level, Fusion picks one of three execution patterns per prompt, which GitHub illustrates in its documentation.

The diagram makes the billing implication visible. In the Single pattern you pay for one model. In Cascade, a cheaper model drafts and a judge model decides whether to accept the draft or escalate to a stronger repair model, so you pay for the draft, the judge and sometimes the repair. In Critique, you pay for a draft, one or more critics and a revision. GitHub states the rule directly: "you're billed for each model it uses, at that model's standard rate," with no separate Fusion fee.

GitHub's short official walkthrough shows Fusion handling tasks from a small UI tweak to a multi-pass feature build, and it is the quickest way to see when each pattern kicks in.

What routing is worth

GitHub's claim for Fusion is strong and specific. On the Artificial Analysis Coding Agent Index, Fusion Max scored 60, within two points of Claude Code running Opus 5.5 at max effort, while using about half the average API cost per task, about half as many tokens and about 40% less time - GitHub Changelog. That index combines FrontierCode, Terminal-Bench 4.1 and SWE-Atlas tasks with equal weight - Artificial Analysis. The result is vendor-reported, but the mechanism behind it is plausible: most prompts in a coding session do not need a frontier model, and a cascade that sends easy work to cheap models and escalates only the hard parts should beat any single model on cost per finished task.

Two discounts make routing cheaper still. Through November 30, 2026, paid plans get a 30% discount on model costs when using Fusion, and paid plans get a standing 10% discount when using auto model selection in Copilot Chat or the cloud agent - GitHub Docs. Until November 30, Fusion is the cheapest way to run frontier-quality work in Copilot by a wide margin; after that, its value rests on routing alone.

There are honest caveats. GitHub does not publish Fusion's model pool, which "changes as new models become available," so you cannot audit which model answered a given prompt from the documentation alone. Fusion only uses models your organization's policies allow, so a restrictive policy also restricts the router. And discarded drafts are not rolled back: edits a draft already made to your workspace "aren't undone automatically," which means a cascade can leave changes behind that you need to review before committing.

The first-principles reading is that routing is the only pricing lever GitHub has left on partner models. It cannot sell partner tokens below list price, and it does not need to: if it can route a prompt to a model that costs a fifth as much without a quality loss, it lowers your cost per task by more than any discount would. That is also why our guide to AI model routing argues that routing, not model price cuts, is where most agent cost savings now come from.

10. The Costs Outside the Credit Meter

AI credits are the visible part of a Copilot bill. Several other charges sit beside them, and they are where teams most often get surprised.

GitHub Actions minutes and cloud compute

Since June 1, every Copilot code review on a private repository also consumes GitHub Actions minutes from your plan's entitlement, billed at standard Actions rates beyond the included amount; public repositories remain free - GitHub Changelog. Reviews run on a standard GitHub-hosted runner by default, and larger or self-hosted runners are billed at their own rates. A team that turns on automatic review for every pull request is buying both credits and compute for each one.

The cloud agent draws on the same compute. GitHub's documentation says cloud and GitHub Actions compute "draw on the same monthly GitHub account allowance, separate from AI credits" - GitHub Docs. On October 28, GitHub turned that allowance into a single dollar-based compute entitlement covering standard runners, cloud sandboxes and (on Team and Enterprise Cloud) larger runners, with usage deducted "at each product's published rate." An editor's note added on November 19 says billing for cloud sandbox usage begins on November 23, 2026 - GitHub Changelog. From November 23, a long cloud agent run therefore spends from two meters at once: AI credits for the model and compute entitlement for the environment it runs in.

Annual subscribers on the old system

People who held an annual Pro or Pro+ plan on June 1 were left on the old premium-request system until their plan expires, with model multipliers that increased on June 1 for annual subscribers only - GitHub Blog. At expiration they move to Copilot Free unless they choose a paid monthly plan, and they can convert early with prorated credits for the remaining annual value. GitHub's legacy documentation notes that advanced reasoning models can consume five or twenty times the standard request rate under that system - GitHub Docs. If you are on an annual plan, the price list in this guide is not yet your price list, and the honest comparison is between your current multipliers and what the same work would cost in credits.

Plan changes and seat assignments

Two rules about plan changes are worth knowing before they happen to you. If a Pro, Pro+ or Max subscriber is assigned a Business or Enterprise seat, the personal plan is canceled automatically with a prorated refund - GitHub Docs. And cancellation takes effect at the end of the billing cycle, while usage incurred before canceling, downgrading or setting a $0 budget is still charged, sometimes on a later statement.

Bring your own key and local models

The one way to use Copilot's interface without spending credits is to bring your own model access. In VS Code, provider-backed models configured with your own API key are "billed directly by that provider and does not count against GitHub Copilot request quotas," and they work without a Copilot plan at all, though BYOK covers chat and agent tasks rather than standard completions - VS Code Blog. GitHub's documentation extends user BYOK to JetBrains, Xcode, Copilot CLI, the Copilot app and the Copilot SDK, and Business and Enterprise administrators can disable it by policy - GitHub Docs. The same page notes that a local Windows model, MAI Code 1.1 Flash, can be added directly from Copilot CLI, the Copilot app or VS Code, which costs nothing per token beyond your own hardware. BYOK makes sense for anyone who already has cheaper access to a model through an enterprise agreement, credits from a provider, or a local machine capable of running an open model.

11. Which Plan Fits: The Breakpoints for Individuals and Teams

Because Copilot meters everything at list price, choosing a plan reduces to one question: how much list-price inference will you actually use in a month? The chart plots the total monthly cost of each individual plan against that number, assuming you pay for overage at one cent per credit rather than upgrading mid-month.

The lines cross at two points, and those two numbers are the whole plan decision for individuals. Pro+ becomes cheaper than Pro at $44 of monthly usage: below that, Pro plus occasional overage costs less; above it, Pro+ wins. Max becomes cheaper than Pro+ at $131: below that, Pro+ plus overage costs less; above it, Max wins. Max is not the cheapest option for anyone using less than $131 a month, which means that for a large majority of developers, Max is a convenience, not a saving.

Model access cuts across these breakpoints. If you need Claude Opus 5.5, Claude Fable 5.2, GPT-6.2 Astra or GPT-6.2 Sol at all, Pro+ is your floor regardless of volume, because Pro cannot select them. And upgrading mid-month is usually better than paying overage on a lower plan, because you pay only the price difference and receive the higher plan's flex.

Translated into work, using the worked examples from Section 8, the breakpoints look like this:

Your typical monthList-price usageCheapest plan
Mostly completions and chat, a few agent tasks on mid-tier modelsUnder $15Pro
A daily agent task or two on Sonnet 5.5 or MAI Code 2$15 to $44Pro, with a budget for overage
Daily agent work with some Opus 5.5 or GPT-6.2 sessions$44 to $131Pro+
Full-time agent work, several long runs a week on frontier modelsOver $131Max
You need GPT-6.2, Opus or Fable at any volumeAnyPro+ at minimum

For teams

For a team, the breakpoint logic changes because there is no flex and the pool absorbs variance. Business and Enterprise both buy credits one-for-one, so the choice between them is a choice of features and data controls, not of value per dollar. Enterprise's extra $20 per seat is converted entirely into credits, so a team that consumes its whole pool is effectively getting Enterprise's features at no extra cost; a team that leaves most of its pool unused is paying for credits it forfeits.

Consider an illustrative 50-seat Business organization. Its pool holds 95,000 credits, worth $950 a month. At the worked-example rates, that covers roughly 4,600 agent tasks on MAI Code 2 at its promotional price, about 1,040 on Sonnet 5.5 or GPT-6.2 Sol, about 520 on Opus 5.5, or about 260 on GPT-6.2 Astra. The same arithmetic tells a team leader what a policy decision is worth: setting the organization's default from Opus 5.5 to Sonnet 5.5 doubles the work the pool covers, and setting it to MAI Code 2 for routine tasks multiplies it again.

For enterprises eligible for Copilot access, the decision is simpler still. If you already pay for GitHub Enterprise Cloud licenses and your developers' usage is uneven, metered access with no seat fee will cost no more than Enterprise seats and usually less, as Section 5 showed. The case for keeping seats is predictability: a seat-based pool gives finance a floor and a ceiling it can plan around, while pure metering requires budgets and alerts to do the same job.

12. Copilot vs Cursor, Claude Code and Codex: Pricing Compared

Every major coding tool has now moved to some version of pooled or metered usage, but they meter different things, and the differences decide which one is cheaper for a given developer. Here is how the four most common choices are priced today:

ProductEntry paid planMiddle tier$100 tier$200 tierHow usage is metered
GitHub CopilotPro $10 ($15 usage)Pro+ $39 ($70 usage)Max $100 ($200 usage)noneDollar credits at list price per token; completions free
CursorPlus $8 (Grok only)Premium $30 (4x Plus)Super $100 (15x Plus)Ultra $200 (50x Plus)Weekly pool shared with Grok; other labs' models at API price
Claude (Claude Code)Pro $20noneMax $100 (5x Pro)Ultra $200 (10x Pro weekly)Five-hour and weekly usage windows; Max and Ultra add API credits
ChatGPT (Codex)Go $8, Plus $20nonePro $100Pro $200, Pro $500Usage limits shared between Codex and ChatGPT Work; extra credits

Each row comes from the vendor's own pricing page, as linked in the sections below, read on November 20, 2026.

Cursor: a house-brand pool with list-price frontier models

Cursor's pricing page now lists Plus at $8 with Grok models only, Premium at $30 with four times Plus's usage, Super at $100 with fifteen times and Ultra at $200 with fifty times, all on a pool "shared across Cursor and Grok" that refreshes weekly - Cursor. From Premium up, third-party models are available "billed separately by usage" at API list price. That makes Cursor's structure strikingly similar to Copilot's: a house-brand model gets the included allowance, and the frontier labs' models cost list price. The difference is the house brand: Grok in Cursor, MAI in Copilot.

Cursor's supply of frontier models has also become less certain. After SpaceX acquired Cursor's parent, OpenAI notified SpaceX that it intended to wind down its contract providing OpenAI models to Cursor, with a proposed shutoff date of November 12, 2026 - InfoWorld. Our coverage of the SpaceX deal covers that story. Our list of Cursor alternatives covers where Cursor users have been moving. For pricing purposes, the point is simple: Copilot offers OpenAI's, Anthropic's, Google's, xAI's and Microsoft's newest models in one picker at list price, which Cursor currently cannot match for OpenAI.

Claude Code: a lab subscription with usage windows

Anthropic's plans include Claude Code from Pro upward: Pro at $20 a month ($17 billed annually), Max at $100 with five times Pro's usage, Ultra at $200, plus Team and Enterprise seats - Claude. Anthropic renamed its tiers on October 30, turning Max 5x into Max and Max 20x into Ultra at unchanged prices; Ultra now offers ten times Pro's weekly usage with no five-hour limit for verified accounts, and Max and Ultra include $100 and $200 a month of API credits respectively - The Next Web.

The economic difference from Copilot is the unit. Claude plans meter usage in windows (five hours and a week) rather than in published dollars, so there is no clean conversion between a Claude Max subscription and Copilot credits. What can be said is structural: Anthropic sets the price of its own models in its own subscription and can subsidize heavy users as a matter of strategy, while Copilot passes through Anthropic's list price. A developer who works almost entirely on Claude models and runs long agent sessions daily is the profile most likely to get more work per dollar from a Claude plan; a developer who switches between labs' models is the profile Copilot serves better. Our Claude Code pricing guide covers Anthropic's plans in depth.

Codex: a lab subscription with the newest OpenAI models

OpenAI sells Codex inside ChatGPT plans: Free, Go at $8, Plus at $20, Pro from $100 (with tiers at $100, $200 and $500), and Business at $25 per user monthly or $20 billed annually, with ChatGPT Work and Codex sharing "pricing, credits, and usage limits" - OpenAI. GPT-6.2 Astra and Sol reached Codex on November 17 for Plus, Pro, Business, Enterprise and Edu users, and Ultrafast mode is reserved for Pro tiers and eligible enterprise workspaces. Our Codex pricing guide explains the limits and resets.

The same structural point applies. A ChatGPT Plus subscription gives access to GPT-6.2 Astra and Sol in Codex for $20, which Copilot cannot offer below Pro+ at $39. For a developer who wants OpenAI's newest models above all and works mainly in OpenAI's own agent, Plus or Pro is the natural comparison; for a developer who wants those models inside the GitHub workflow, alongside Claude and Gemini, with completions and code review included, Copilot Pro+ is.

Where each one wins on price

Reasoned from the unit each vendor sells, the comparison resolves into a few clear cases. Copilot wins for multi-model work inside GitHub, for teams that need pooled budgets and policy controls, for anyone who values unlimited completions, and for routine agent work on MAI Code 2 while its promotion lasts. Cursor wins for developers happy to work mainly on Grok and Cursor's own models within a weekly pool. Claude plans win for heavy daily use of Claude models in Claude Code. ChatGPT plans win for heavy daily use of OpenAI models in Codex, especially at the $20 entry point. Our comparison of the best AI coding CLIs covers the tools themselves rather than their prices.

There is also a category that sits one level above all four. Coding assistants price the act of writing code; some teams would rather buy the finished outcome. Platforms such as O-mega build and operate an entire autonomous company through AI (website, app, billing and back office) from one conversation, which is a different purchase from a coding seat and makes sense for founders who want a running product rather than a faster editor.

13. How to Cut Your Copilot Bill Without Cutting the Work

Every tactic that works follows from the mechanics in Sections 3 and 8: a bill is model price multiplied by tokens, and agent tokens grow with context size and step count. So the levers are the model, the context and the number of steps, plus the controls that stop a mistake from becoming expensive.

Barbara Forbes's walkthrough, recorded just before the switch, remains one of the clearest practical explanations of those levers. The models she names have since been replaced, but the mechanics have not, and her tips from the 10:30 mark onward map directly onto the tactics below.

Make a cheap model your default and escalate deliberately. The single largest saving is changing the default. With a mid-tier or MAI model as the everyday choice and a frontier model reserved for the tasks that fail on the cheaper one, the same allowance covers several times as much work. On Pro, that means MAI Code 2 or Sonnet 5.5 by default; on Pro+ and Max, it means reaching for GPT-6.2 Astra, Opus 5.5 or Fable 5.2 when a task has already defeated GPT-6.2 Sol or MAI Code 2, not before.

Keep sessions short and start fresh often. Because every agent step resends the conversation, a session that has wandered through several tasks carries all of their context into the next step. Starting a new session for a new task resets that cost to zero, and as Forbes notes at the 10:30 mark, short sessions are the easiest saving to adopt.

Feed the agent less. The worked examples showed that new context, not output, is the largest part of a frontier-model agent task. Reference specific files rather than whole folders, keep instruction files lean (they are sent on every call), and avoid pasting large logs when a filtered excerpt would do.

Leave context size and reasoning at their defaults. The 1-million-token window and the higher reasoning levels both multiply tokens. GitHub's own documentation recommends the regular context window and regular reasoning by default, and the long-context price tiers (above 272,000 tokens on GPT models, above 100,000 on Haiku 5.5) make an oversized context more expensive per token as well as larger.

Plan before you execute. An agent that misunderstands a task spends a full session's tokens producing the wrong change, then spends another session undoing it. A planning pass in a cheap model, reviewed by you, is a small cost that prevents the expensive one, which is why Forbes puts Plan mode at the end of her list (14:05).

Use the free parts of Copilot for small edits. Completions and next edit suggestions cost nothing on paid plans. For small, local changes, typing with completions is free; asking an agent to make the same change is not.

Use the routing discounts while they last. Fusion's 30% discount runs until November 30, and auto model selection carries a standing 10% discount in Chat and the cloud agent. For work you would otherwise route manually, letting Copilot route is now cheaper as well as easier.

Set budgets before you need them. For individuals, a $0 "Bundled AI credits" budget with "Stop usage when budget limit is reached" caps your bill at the subscription price. For teams, user-level budgets enforce a hard stop per developer, and administrators should decide deliberately whether to keep the paid-usage policy on and whether new models should be enabled automatically.

Run code review at the effort the change deserves. GitHub's estimates put a Lite review at about a sixth of a Balanced one and a fortieth of a Max one. Reserving Max reviews for security-sensitive or large changes, and remembering that private-repository reviews also consume Actions minutes, keeps automatic review affordable at scale.

Watch the calendar. The Fusion discount ends November 30, Gemini 4 Argon and Carbon promotions end December 1, cloud sandbox billing starts November 23, and MAI Code 2's price doubles after May 17, 2027. A cost plan that works today should be rechecked on each of those dates.

14. Where Copilot's Pricing Works, Where It Fails, and How It Can Go Wrong

Usage-based pricing is neither a price hike nor a price cut. It is a transfer of variance: GitHub stopped absorbing the difference between light and heavy users, and each user now pays roughly what their own usage costs, plus or minus flex. Whether that is good news depends on which side of the old average you were on.

Where it works

It works well for light and moderate users, who used to subsidize heavy users and now pay for a smaller share of the system. A developer who mostly uses completions and chat, with occasional agent tasks on mid-tier models, gets more from Pro today than the old premium-request cap allowed, because chat on most models costs a fraction of a credit.

It works for multi-model teams. Copilot is the only mainstream coding product that offers OpenAI's, Anthropic's, Google's, xAI's, Moonshot's and Microsoft's newest models in one picker at transparent list prices, with pooled budgets, per-user hard stops and model policies. For a platform team that wants to let developers choose the right model per task while keeping spending visible, that combination is hard to replicate.

It works for predictable organizations that set controls. With user-level budgets, a deliberate model policy and a decision about paid overage, a Copilot bill becomes a forecastable line rather than a surprise, and Copilot access removes the seat-fee waste entirely for eligible enterprises.

Where it fails

It fails for heavy single-lab agent users, who were the main beneficiaries of the old model and are now paying close to raw API prices with a flex bonus of up to two times. For that profile, a lab's own subscription is often the better deal, because the lab can subsidize its own models in a way GitHub cannot subsidize a partner's.

It failed, at least initially, on communication. When billing switched on June 1, developers reported burning a large share of their allowance within hours, and some threatened to leave; GitHub's response pointed to spending limits, usage dashboards, model selection and the new Max plan - The Register. The underlying problem was that a credit balance tells you how much you have spent but not how much a task will cost before you run it, and that is still largely true.

How it can go wrong

The failure modes are specific enough to list, and each has a preventive habit.

  • Runaway agent sessions. A cloud agent or long CLI session on a frontier model can spend tens of dollars before anyone looks. Prevent it with budgets and a cheaper default model.
  • Silent model upgrades in organizations. New models are enabled automatically by default, so a frontier model can reach every developer on launch day. Prevent it by turning off the global default and approving models deliberately.
  • Paid overage left on by default. Organizations keep spending after the pool runs out unless an administrator disables the policy. Prevent it by deciding, in writing, whether overage is allowed.
  • Promotions treated as prices. MAI and Gemini promotions end on known dates. Prevent surprises by recording them in your cost plan.
  • Flex treated as permanent. GitHub explicitly says flex varies. A Pro+ or Max decision that only makes sense with today's flex should be rechecked when it changes.
  • Two meters for one cloud task. From November 23, cloud sandbox usage draws from the compute entitlement in addition to credits for the model.
  • The wrong product. Microsoft 365 Copilot, its Copilot Code feature and Copilot Credits are separate from GitHub Copilot and GitHub AI Credits; budgets in one do not govern the other.

There is also a quieter risk in the benchmark claims that drive model choice. Vendor numbers (Microsoft's for MAI Code 2, GitHub's for Fusion, OpenAI's for GPT-6.2) are measured in harnesses and on task sets the vendor chose, and they rarely transfer cleanly to a specific codebase. Our analysis of why coding benchmarks mislead explains the mechanics. The safest pricing decision is one checked against a week of your own usage data in Copilot's dashboard.

15. Outlook: Where Coding-Tool Pricing Goes Next

The structural forces behind Copilot's pricing are visible enough to reason about without guessing at dates. Start with the input that drives everything: agents consume tokens in proportion to the work they attempt, and the work agents attempt keeps growing. Long-running agents that work for hours (covered in our guide to long-running coding agents) turn a coding assistant from a per-keystroke tool into a per-outcome worker, and no flat price survives a product whose heaviest users consume a hundred times its lightest.

That force explains the convergence across vendors. GitHub meters dollars, Cursor meters a weekly pool, Anthropic meters usage windows, OpenAI meters shared limits plus credits, and Microsoft 365 meters Copilot Credits. The units differ, but every one of them ties price to consumption, and every one of the coding tools now sells a tier of $100 or more for heavy users. Expect that convergence to continue, because the cost structure underneath is the same for everyone.

The second force is the house brand. When a platform resells other labs' models at list price, its margin on those requests is limited by what the labs charge it; when it serves its own model, it keeps the whole price. That is why Copilot now leads with MAI Code 2 at a promotional price, why Cursor's included allowance runs on Grok, and why both put frontier partner models behind usage billing. The likely result is a two-tier market inside each tool: cheap, heavily promoted house models for routine work and list-price frontier models for hard problems, with routing deciding which is which.

The third force is routing as the product. Fusion's pitch is that you stop choosing models and the router optimizes cost per task for you. If that works as GitHub claims, the visible price list matters less over time, and the value of a coding tool shifts toward how well it decides. That is good for users when routers are transparent and bad when they are not; GitHub's decision not to publish Fusion's model pool is the detail worth watching.

The fourth force is the disappearing seat. Copilot access already lets eligible enterprises run Copilot with no seat fee at all, metered from the first request. Once seats become optional for the largest customers, the pressure to make them optional for everyone grows, and the subscription increasingly becomes what flex already is on individual plans: a prepayment with a bonus.

Pressure-test that conclusion from the other side. If the price per task keeps falling (GPT-6.2 Astra is 20% cheaper than its predecessor per token and more efficient per task, Sol improved at the same price, and MAI Code 2 undercuts both), why would bills rise? Because cheaper tasks invite more tasks. The historical pattern with every cheaper computing input is that total spending grows as new uses become affordable, and agentic coding is following it: per-task cost falls, the number of tasks rises faster, and the monthly bill for an active developer goes up even as each unit gets cheaper. GitHub's flex mechanism is designed for exactly that tension, and how GitHub moves flex as models get cheaper will be the clearest signal of whether Copilot's pricing becomes more generous or less.

The bottom line

For most developers, the right Copilot plan is Pro with a cheap default model and a budget cap, upgraded to Pro+ when they need OpenAI's GPT-6.2 models, Claude Opus or Fable, or when their usage passes about $44 a month. Max is worth it only above about $131 a month of list-price usage. For teams, Business with deliberate model policies and per-user budgets covers most needs, Enterprise makes sense when the pool is actually consumed, and Copilot access is the cheapest option for eligible GitHub Enterprise Cloud customers with uneven usage. And for everyone, the most important pricing decision in Copilot is not on the plans page at all: it is which model you let do the work.

What this article rests on

Every model figure above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.

  • GPT-6.2 Astra (OpenAI): $8 in and $40 out per million tokens, cached input $0.40, a 1.05M token window, listed 17 November 2026.
  • GPT-6.2 Sol (OpenAI): $2 in and $10 out per million tokens, cached input $0.10, a 1.05M token window, listed 17 November 2026.
  • GPT-6 Luna (OpenAI): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1.05M token window, listed 22 September 2026.
  • Claude Haiku 5.5 (Anthropic): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1M token window, listed 7 October 2026.
  • GPT-6.1 Terra (OpenAI): $1 in and $5 out per million tokens, cached input $0.05, a 1.05M token window, listed 26 October 2026.
  • Gemini 4 Hydrogen (Google): $1.50 in and $7.50 out per million tokens, cached input $0.075, a 1M token window, listed 12 November 2026.
  • Claude Sonnet 5.5 (Anthropic): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 28 September 2026.
  • Grok 4.7 (SpaceXSI): $2 in and $6 out per million tokens, cached input $0.50, a 500K token window, listed 21 September 2026.
  • Gemini 4 Neon (Google): $3 in and $15 out per million tokens, cached input $0.15, a 1M token window, listed 18 November 2026.
  • Claude Opus 5.5 (Anthropic): $4 in and $20 out per million tokens, cached input $0.20, a 1M token window, listed 22 September 2026.
  • Claude Fable 5.2 (Anthropic): $8 in and $40 out per million tokens, cached input $0.20, a 1M token window, listed 9 November 2026.

In this topic: AI costs

What do AI models and agents cost, and how do you cut it? Every guide on it