GitHub Copilot's Billing Overhaul: What Every Credit Actually Costs You

GitHub's flat-rate Copilot pricing has always been a polite fiction. A quick autocomplete question and a multi-hour autonomous coding session cost the same subscription dollar, which meant GitHub was quietly absorbing the difference as agentic usage scaled. On April 27, 2026, GitHub CPO Mario Rodriguez announced that the fiction ends on June 1, 2026, when all Copilot plans move to token-based, usage-metered billing.

This is a structural change to how AI developer tools get priced, and it will ripple across individual developers, engineering teams, and the broader market of AI coding assistants.

The Short Version

Think of the old model as a taxi with a flat airport rate. You paid $10 and could take as many trips as the driver would tolerate. The new model is a meter: the cab starts running the moment you open a session, and it charges by distance, weight, and which vehicle you chose. A quick chat question on a lightweight model might cost a fraction of a credit. A frontier-model agent session iterating across a large codebase will cost significantly more, because it is doing significantly more work.

The unit is the GitHub AI Credit. One credit equals $0.01 USD. Your plan's monthly subscription price now directly maps to your included credit allotment.

What Actually Changed

Premium request units (PRUs) are gone. In their place, every Copilot interaction that touches an AI model now consumes credits based on token consumption: input tokens, output tokens, and cached tokens, each priced according to the model used.

The plan prices themselves are not changing. Copilot Pro stays at $10/month, Pro+ at $39/month, Business at $19/user/month, and Enterprise at $39/user/month. What changes is what you get for that money: a credit allotment rather than a request bucket.

For individuals, Copilot Pro includes 1,000 AI credits per month and Pro+ includes 3,900. For organizations, Copilot Business includes 1,900 credits per user per month and Copilot Enterprise includes 3,900. Those credits are pooled at the billing entity level for teams, which matters and is covered below.

Code completions and Next Edit suggestions remain unlimited on all paid plans and do not consume credits. The meter only runs on chat, agent mode, Copilot CLI, Copilot Spaces, Spark, and third-party coding agents.

Why GitHub Had to Do This

Rodriguez's announcement is direct about the reason: agentic usage is becoming the default, and it brings "significantly higher compute and inference demands." A multi-hour autonomous coding session running a frontier model across an entire repository costs orders of magnitude more to serve than a single chat question, but under PRU pricing both interactions drew from the same bucket.

GitHub absorbed that cost gap for long enough to grow adoption. The announcement acknowledges the current model is "no longer sustainable." Usage-based billing is the mechanism that makes the economics work as agents become the primary interaction mode rather than the exception.

This is not a surprise to anyone watching inference costs. The flat-rate model made sense when Copilot was primarily an autocomplete tool. It does not make sense when the product is an autonomous agent that can run for hours.

Do the Math on Your $10

Copilot Pro's 1,000 included credits represent $10 in compute at the published rate. That sounds like a clean match to the subscription price, and it is, by design.

The question is how fast those credits drain in practice. GitHub's own documentation offers the relevant framing: a quick chat question on a lightweight model might cost a fraction of a credit, while a long agentic session on a frontier model across multiple files will cost significantly more.

There is no published per-session average in the source material, so precise estimates are not possible here. What is clear is that a developer who primarily uses chat for quick questions will likely stay well within 1,000 credits. A developer running daily agent sessions on GPT-class frontier models will need to watch the meter. The math on Pro+ (3,900 credits for $39) is proportionally identical, so the question is purely about usage intensity and model selection.

Model choice is the most direct lever available. Switching to a less expensive model is explicitly listed in GitHub's documentation as a way to extend your monthly allowance. That is a real tradeoff that did not exist under flat-rate pricing.

The Fallback Got Quietly Removed

Under the old PRU model, developers who exhausted their premium requests could fall back to a lower-cost model and keep working. That fallback is gone.

GitHub's announcement is explicit: "Fallback experiences will no longer be available." When credits run out, usage stops until the next billing cycle resets the allotment, unless the user or admin has configured an additional usage budget. There is no automatic graceful degradation to a cheaper model.

For individual developers, this means a hard stop rather than a slower experience. For teams, it means admins need to make a deliberate policy choice: allow overage at published rates, or accept that users hit a wall. The documentation confirms that if a user-level budget is exhausted, that user's access halts regardless of whether the organization's pool still has capacity.

The Annual Subscriber Trap

Monthly subscribers migrate automatically on June 1 with no action required. Annual subscribers face a more complicated situation.

Annual Copilot Pro and Pro+ plans will not auto-renew. GitHub says it will communicate options before each subscriber's renewal date. The choices are to cancel with a prorated refund, wait to be downgraded to Copilot Free at renewal, or convert to a monthly plan early and receive prorated credits for the remaining annual plan value.

There is an additional wrinkle: starting June 1, 2026, model multipliers will increase for annual plan subscribers only. The documentation points to a separate table for the specifics. Annual subscribers who do nothing will find themselves on a plan with higher effective model costs before their plan expires and they transition off it. This is the scenario most likely to generate surprise charges or degraded experience for users who are not paying close attention.

Agents, Model Choice, and Code Review's Double Cost

Three details in the announcement deserve more attention than they have received.

First, agentic sessions are structurally more expensive under this model because they involve multiple model calls within a single task. The documentation notes that "a complex agentic session working across a large codebase will consume significantly more usage than a quick question in chat." Teams that have been encouraging developers to use agent mode liberally should expect their credit consumption to look very different from teams that have been using Copilot primarily for chat and completions.

Second, model selection is now a cost management decision, not just a quality preference. Frontier models cost more per token. Lighter models cost less. Under flat-rate pricing, this was irrelevant to the user's bill. Under usage-based billing, it directly affects how long your monthly allotment lasts.

Third, Copilot code review will now consume both GitHub AI Credits and GitHub Actions minutes, billed at the same per-minute rates as other Actions workflows. This is a double billing structure that does not apply to other Copilot features. Teams using automated code review at scale should account for both cost dimensions when estimating their June 1 exposure.

Pooled Credits: The One Real Win for Teams

The most practically useful change for engineering organizations is credit pooling. Under the new model, an enterprise's included credits are aggregated into a single shared pool rather than isolated per-user buckets.

GitHub's documentation gives a concrete example: an enterprise with 100 Copilot Business users gets a shared pool of 190,000 AI credits rather than 100 individual allotments of 1,900. Power users can draw more when they need it, and lighter users offset that consumption. Unused credits from low-usage team members are no longer stranded.

Adding licenses mid-cycle increases the pool immediately. Removing licenses mid-cycle does not shrink the pool until the next billing cycle begins. For teams with variable headcount or seasonal usage patterns, this is a meaningful operational improvement over the old model.

Existing Copilot Business and Enterprise customers also receive a promotional credit increase for the first three months of usage-based billing (June through August 2026): 3,000 credits per user per month for Business and 7,000 for Enterprise, compared to the standard 1,900 and 3,900 respectively. This gives teams a runway to measure actual consumption before the standard rates apply.

The Industry Is Moving Here

GitHub is not alone in this direction. The broader pattern across AI developer tools is a shift from flat-rate subscription pricing toward consumption-based models as agentic workloads become standard. The economics of serving autonomous agents at flat rates do not work at scale, and every major provider building in this space faces the same constraint.

GitHub's move is notable because of its scale and because it makes the token-cost layer visible to individual developers in a way that API pricing never did for most users. Developers who previously thought of Copilot as a fixed monthly expense now have a metered relationship with inference costs, whether they wanted one or not.

What to Do This Week

The June 1 deadline is close enough that teams should act now rather than wait.

For individual developers on monthly plans: no action is required for migration, but review your usage patterns before June 1. If you run frequent agent sessions on frontier models, estimate whether 1,000 or 3,900 credits will cover your typical month. Decide whether to set an overage budget or accept a hard stop.

For individual developers on annual plans: read the communication GitHub sends before your renewal date carefully. Understand the model multiplier changes taking effect June 1 for annual subscribers. Evaluate whether converting to a monthly plan before expiration makes financial sense given the prorated credit offer.

For engineering team admins: configure budget controls before June 1. Decide at the enterprise, organization, cost-center, and user levels whether to allow additional usage at published rates or enforce hard caps. Identify which teams or individuals are likely to be heavy agent users and set their budgets accordingly. Account for the code review double-billing structure if your team uses automated review at scale.

GitHub says a preview bill experience will be available in early May via the Billing Overview page on github.com. Use it. The preview period is the only opportunity to see projected costs before the meter starts running for real.

References

View tool: Claude Design

Promoted

Sponsored

Claude Design

Claude Design turns conversation into polished prototypes, slide decks, and one-pagers. Describe what you need, Claude builds a first version, and you refine through inline comments, edits, or sliders — kept on-brand via…

View tool