GitHub Copilot is entering a new phase. Starting June 1, 2026, GitHub is moving Copilot from premium request-based usage to usage-based billing built around a new unit called GitHub AI Credits. On paper, this is a pricing model change. In practice, it signals something bigger: AI coding tools are moving from subscription software economics to cloud compute economics. (Read more: The GitHub Blog)
That shift matters because Copilot is a lot more than just an autocomplete tool sitting quietly in the IDE. GitHub now describes Copilot as an agentic platform capable of long-running, multi-step coding sessions across repositories. Those workflows can consume dramatically more compute than a quick chat prompt or inline code suggestion. GitHub’s position is straightforward: the old model treated very different workloads as if they cost roughly the same, and that is no longer sustainable.
Developers, however, are not wrong to be frustrated. The new model may be more economically rational for GitHub, but it is also harder for users to predict. And in developer tooling, predictability matters almost as much as raw price.
Today, Copilot uses premium request units, or PRUs, for most advanced interactions. Under the new model, those PRUs are replaced by GitHub AI Credits. Credits are consumed based on token usage, including input tokens, output tokens, and cached tokens. GitHub defines one AI Credit as equal to $0.01 USD. (Read more: GitHub Docs)
Base subscription prices aren't changing. Copilot Pro remains $10 per month, Pro+ remains $39 per month, Business remains $19 per user per month, and Enterprise remains $39 per user per month. But what those plans include is changing. Copilot Pro includes 1,000 AI Credits per month, Pro+ includes 3,900, Copilot Business includes 1,900 per user per month, and Copilot Enterprise includes 3,900 per user per month. For Business and Enterprise, those credits are pooled at the billing entity level, which means lighter users can offset heavier users. Existing Business and Enterprise customers also receive promotional higher credit amounts from June 1 through September 1, 2026.
Not everything consumes credits. Code completions and Next Edit Suggestions remain included in paid plans and do not consume AI Credits. But Copilot Chat, Copilot CLI, Copilot cloud agent, Copilot Spaces, Spark, and third-party coding agents do consume credits. Copilot code review will also consume GitHub Actions minutes in addition to AI Credits.
There's another important change: fallback experiences are going away. Previously, when users exhausted premium requests, they could fall back to lower-cost models in some cases. Under the new model, usage is controlled by available credits and admin budgets. If credits or budgets are exhausted, usage can stop.
GitHub’s argument is not hard to understand. A single request is no longer a consistent unit of work.
A quick question like “explain this function” might use a small amount of model compute. A coding agent that scans a repository, edits multiple files, runs tests, reviews failures, and iterates for an hour is a totally different workload. Treating both as roughly equivalent breaks the economics of the product.
GitHub said as much when it explained that agentic workflows have changed Copilot’s compute demands. The company noted that long-running and parallelized sessions can consume far more resources than the original plan structure was designed to support, and that some requests can incur costs that exceed the monthly plan price.
That's the core issue. The old Copilot model made sense when Copilot was mostly autocomplete plus lightweight chat. It makes much less sense when Copilot is operating more like an autonomous software agent.
In that context, usage-based billing is not surprising. It aligns Copilot more closely with the economics of model APIs, cloud services, and other metered infrastructure. The more compute a workflow consumes, the more it costs.
The frustration is also rational.
For many developers, Copilot’s value was not just the AI assistance. It was the simplicity: pay a monthly fee, use the tool, don't think too much about the meter running in the background.
Usage-based billing changes that psychology. Now developers have to consider which model they're using, how much context they're sending, how many files the agent is touching, how many iterations it takes, and how much output is generated. In other words: the cost of a task becomes dynamic.
The GitHub Community discussion around the announcement quickly filled with questions about token costs, model access, annual-plan refunds, whether Pro+ still makes sense, and what happens when usage is high but results are poor. One developer asked whether Pro+ still has a meaningful advantage over Pro if users can simply buy more credits. Another asked how to calculate cost per token. Another asked for a refund on the remainder of an annual plan after deciding to stop using Copilot.
That reaction is not just “people hate price changes.” Developers are reacting to uncertainty. A request-based system was imperfect, but it was understandable. A token-based system may be more technically fair, but it is harder to reason about before the bill arrives.
Visual Studio Magazine summarized the concern well: users are worried about reduced included value, less predictable usage, model access, rollover questions, and whether Copilot remains competitive with direct model APIs or rival coding tools.
For developers who mostly use Copilot for inline completions and lightweight coding help, the impact may be limited. Code completions and Next Edit Suggestions remain included in paid plans, so the classic Copilot experience is not suddenly metered in the same way.
The bigger impact is on developers who use Copilot as an agentic coding environment. If you rely on Copilot Chat, cloud agents, CLI workflows, code review, Spark, or third-party coding agents, your usage now becomes a budgeted resource.
That doesn't automatically mean Copilot becomes expensive for everyone. It does mean developers need to get more intentional. A lightweight model may be fine for routine explanations, small refactors, or test generation. A frontier model may be worth it for architecture work, complex debugging, or multi-file changes. But using the most expensive model for every task will burn through credits faster. GitHub’s own docs explicitly say that model choice and token volume drive cost.
Annual subscribers are in a particularly awkward position. GitHub says annual Pro and Pro+ subscribers will stay on request-based pricing until their plan expires, but annual plans will not auto-renew, and model multipliers are changing on June 1. Users can cancel and receive a prorated refund or move to the new monthly usage-based model.
For companies, this is less about one developer’s subscription and more about governance.
Copilot Business and Enterprise customers get pooled credits, which is good news because AI usage is rarely evenly distributed. A few developers, platform engineers, or modernization teams may use agents heavily, while others use Copilot lightly. Pooling makes that workable. But it also means AI usage now needs the same kind of operational visibility companies already apply to cloud spend.
GitHub is adding budget controls at the enterprise, organization, cost center, and user levels. Admins can allow additional usage, cap spending, or set user-level budgets. If a user-level budget is exhausted, that user’s Copilot access is halted even if the broader organization still has pooled credits available. G
That creates a new management question: which work deserves agentic AI spend?
A developer using Copilot to generate boilerplate may not need the same budget as a team using agents to accelerate a major modernization, reduce technical debt, or improve test coverage. The best organizations won't treat AI coding usage as a generic per-seat perk. They'll tie usage to business value.
The bigger implication: AI coding tools are becoming metered infrastructure
This is the most important takeaway.
The first era of AI developer tools was sold like SaaS: one seat, one monthly price, broad access. That helped adoption. It also hid the cost structure.
The next era looks more like cloud infrastructure: usage matters, workload shape matters, and optimization matters. Developers and engineering leaders will need to understand the cost profile of AI-assisted work just as they understand CI/CD minutes, cloud storage, API calls, and database compute.
This isn't a bad thing. Metered pricing can be fairer when usage varies wildly. It can also force better discipline around when to use lightweight models, when to use premium models, and when an agentic workflow is actually worth the cost.
But there is a customer experience problem GitHub still needs to solve. Developers need clear, real-time visibility into what a session is costing, what consumed the most credits, and how to estimate future work. GitHub says billing previews and downloadable usage reports are coming in early May, including estimated AI Credit quantity and gross cost based on April 2026 usage. That will help, but the real test will be whether developers can understand cost before and during a workflow, not only after it happened.
First, review actual Copilot usage as soon as the billing preview becomes available. GitHub says the preview will compare current billing with estimated usage-based billing and provide CSV reports with AI Credit quantities and estimated gross spend.
Second, segment usage patterns. Completion-heavy developers may see little change. Agent-heavy users may need bigger budgets, different models, or clearer internal guidance.
Third, create model-selection guidance. “Use the biggest model for everything” is going to become the new “leave every cloud instance running over the weekend.” Fun until finance finds the dashboard.
Fourth, decide where agentic coding creates enough value to justify the spend. Modernization, test generation, large-scale refactoring, documentation, code review, and migration work may justify heavier usage. Routine coding assistance may not.
Finally, communicate the change clearly to developers. The worst rollout would be letting people discover the new model only when they hit a budget wall in the middle of their work.
GitHub Copilot’s move to usage-based billing is a sign that AI coding tools are growing up (awkwardly and expensively) and with some developer feelings along the way.
GitHub has a real cost problem. Developers have a real predictability problem. Both things can be true.
For light users, Copilot will still feel mostly the same. For agent-heavy users and engineering teams pushing AI deeper into software delivery, the question changes from “Do we have Copilot?” to “How much AI work are we buying, what is it being used for, and is it worth it?”
That's the right question. It's also a way harder one to answer.