GitHub Copilot Turns to Token-Based Limits: Opus Cut and Plan Changes

Microsoft’s latest Copilot move is less a surprise than a culmination. GitHub has now confirmed that usage limits are token-based and that individual Copilot plans are being tightened, with new signups paused for Pro, Pro+, and Student plans while Opus models are removed from Pro and kept in Pro+ instead. That makes the earlier reporting about token-based billing feel like the first visible crack in a broader shift: Microsoft is no longer treating Copilot as a heavily subsidized growth product, but as an infrastructure business that has to price against real compute demand. (github.blog)
The timing matters. In the span of just ten days, GitHub has rolled out new rate-limit enforcement, retired a faster Opus variant from Pro+, and then narrowed individual-plan access even further. Taken together, those changes suggest a deliberate reset of Copilot’s economics, not a one-off tweak to smooth out traffic spikes. For developers, especially power users, the message is blunt: agentic AI is expensive, and the bill is now being pushed closer to the people generating the load. (github.blog)

Background​

GitHub Copilot began as a relatively simple pitch: pay a monthly fee, get AI help in the editor, and let Microsoft absorb the complexity underneath. That model worked well when the product was mostly about code completions and light chat. Once Copilot expanded into agent mode, long-running tasks, tool use, and parallel workflows, the underlying cost profile changed dramatically. Microsoft has now openly acknowledged that those newer patterns can exceed the plan price and strain shared infrastructure. (github.blog)
That’s the real context for today’s billing shift. What used to look like a flat-fee productivity subscription has gradually become a metered AI platform with different model classes, usage caps, and premium request entitlements. GitHub already moved to monthly premium request allowances in 2025, then added pay-per-request controls, and now says usage limits are token-based guardrails rather than request counts. In other words, the company has been inching from a simple subscription toward a consumption-aware system for some time. (github.blog)
The new announcement also fits a broader industry pattern. AI vendors are finding that the most capable models are also the most expensive, and that agentic workloads are far more compute-intensive than traditional autocomplete products. Once users start chaining prompts, calling tools, and asking for multi-step work, the economics stop resembling software licensing and start looking like cloud metering. Microsoft’s challenge is not unique, but Copilot is one of the highest-profile examples of that transition. (github.blog)
There is also a market-positioning angle. GitHub Copilot is no longer just a developer helper; it is becoming a platform for model selection, policy enforcement, and usage governance across IDEs, CLI tools, and web surfaces. That makes pricing and limits more than a finance issue. They become product controls that shape which models people use, how they work, and which customer segments remain willing to pay. (github.blog)

Why this matters now​

The recent changes are arriving while GitHub is still broadening Copilot’s model catalog and agent features. At the same time, GitHub is reducing access to some of the most expensive models and tightening availability on consumer plans. That combination is not accidental; it is a classic scale first, constrain later move, except the constraint is now arriving sooner because the cost curve moved faster than the flat-price plan model could handle. (github.blog)

From premium requests to token limits​

Premium requests already gave GitHub a partial consumption model, but they still behaved like a request-metered abstraction. Token-based guardrails go deeper, because they reflect the actual size of the conversation, the model’s output, and the amount of reasoning or tool use involved. That means the same “request” can become dramatically more expensive depending on prompt length, response length, and model choice. (github.blog)

• Request-based billing is simpler to understand.
• Token-based billing is more aligned with compute cost.
• Agentic workflows tend to consume more tokens than classic chat.
• High-output models make the pricing gap more obvious.
• Users with heavy automation will feel the changes first. (github.blog)

---

What Microsoft Changed​

The most important shift is not just that Copilot is being capped more tightly, but that the company is explicitly tying usage to token consumption. GitHub’s own wording makes clear that usage limits are now based on tokens consumed in a given window, while premium requests still govern model access and request counts. That distinction is crucial because it separates what you are allowed to use from how much of the underlying system you consume. (github.blog)
Microsoft is also narrowing model availability. On individual plans, Opus models are no longer available in Pro, and Opus 4.7 remains on Pro+ while older Opus models are being removed from the higher tier as well. That is a strong signal that Microsoft is reserving the most expensive frontier-class models for customers who can justify the economics, rather than making them broadly accessible by default. (github.blog)
The company is adding guardrails in the user experience too. GitHub says VS Code and Copilot CLI now show warnings as users approach limits, and usage progress tracking is coming. That is a subtle but important change: instead of shocking people after the fact, the product is being redesigned to teach customers how to self-ration before they hit the wall. (github.blog)

What counts as a token-based limit?​

GitHub’s explanation is direct: premium requests are not the same as usage limits. A user can still have premium requests left and yet hit a token-based cap if the session is heavy enough. That means long prompts, long answers, and model-heavy workloads can exhaust capacity even when the nominal request allowance looks healthy. (github.blog)

Why the old model became strained​

The problem with request-based billing is that it obscures the shape of the work. A single request may be cheap or wildly expensive depending on which model handles it and how much output it generates. As agentic workflows became more common, the fixed subscription and request abstraction stopped reflecting actual server cost, which is why GitHub now says some requests can cost more than the plan price itself. (github.blog)

• Token limits better match real cloud cost.
• Heavy users are no longer hidden inside a flat-fee average.
• Short, simple prompts should be less affected.
• Long agent sessions will trip limits sooner.
• Businesses will need better usage forecasting. (github.blog)

---

Why Copilot Economics Are Changing​

The economics of AI coding assistants have gotten more complicated because the product itself has gotten more capable. GitHub says the rapid rise of agents and subagents has changed usage patterns, and the company has seen intense concurrency and long-running sessions that stress shared infrastructure. That is a very different business from classic autocomplete, which was cheap to serve at scale. (github.blog)
In practical terms, the more Copilot starts behaving like a software worker rather than a suggestion engine, the more it resembles a cloud workload. Agents can browse, reason, call tools, re-ask questions, and loop over tasks. All of that drives token burn, which in turn raises the cost of keeping those features flat-priced for everyone. (github.blog)
Microsoft’s response suggests the company is trying to keep the platform viable without simply turning every feature into a premium upsell. The tradeoff is predictable: users get clearer guardrails, but they also get less freedom and more segmentation. That is good for cost control and bad for the fantasy that AI coding tools will stay cheap forever. (github.blog)

Compute intensity and agent mode​

Agent mode is where the economics changed fastest. A single task can involve multiple prompt/response cycles, tool calls, retries, and parallel branches, all of which multiply token use. GitHub’s own guidance now explicitly tells users to reduce parallel workflows and to use plan mode or smaller models if they are nearing limits. (github.blog)

The end of blanket subsidization​

The broader strategic implication is that Microsoft appears less willing to broadly subsidize frontier-model usage across consumer tiers. That does not mean the company is abandoning Copilot; it means it is choosing where to absorb cost and where to pass it through. The likely result is a more tiered product with sharper feature fences. (github.blog)

• Frontier models are expensive to run.
• Parallel agents multiply cost very quickly.
• Flat subscriptions hide those costs until they do not.
• Tiered access helps preserve margins.
• More precise billing usually means less generosity for power users. (github.blog)

---

What Changes for Individual Users​

For individual subscribers, the immediate implication is simple: Copilot is becoming less like an all-you-can-eat perk and more like a metered service with sharp boundaries. GitHub has paused new signups for Pro, Pro+, and Student plans, tightened limits, and removed Opus from Pro entirely. That combination is likely to frustrate users who adopted Copilot expecting a predictable monthly price and stable model access. (github.blog)
The biggest pain point will probably be power users who rely on premium or frontier models for difficult coding, refactoring, or architectural work. Those users are exactly the ones most likely to hit weekly token caps, and the company is openly saying that some of them should either switch to smaller models or upgrade. In a consumer context, that will feel less like product refinement and more like a bill increase by another name. (github.blog)
At the same time, casual users may barely notice the change. Simple prompts and light usage patterns are less likely to trip token limits, especially if they stick to lower-multiplier or auto-selected models. That means Microsoft can keep the bottom of the funnel relatively intact while extracting more revenue from the heaviest users. (github.blog)

Who gets hit first​

The first group to feel the squeeze will likely be developers who use Copilot for long troubleshooting sessions, large-context refactors, or agentic workflows in the CLI. Those patterns are exactly the kind GitHub says are now driving higher token consumption and higher infrastructure strain. The second group will be users who picked Pro specifically because it seemed enough for occasional premium model use, only to discover that model access is being fenced off more aggressively. (github.blog)

The psychology of a metered assistant​

There is also a usability problem here. When a tool feels like an assistant, users expect it to be available when needed, not rationed like cloud storage. Token limits create a subtle but real psychological barrier, because people start thinking about cost every time they ask for a longer answer or a more ambitious task. (github.blog)

• Casual users may be insulated from the harshest changes.
• Power users will notice limits fastest.
• Model downgrades can reduce perceived quality.
• Upgrade pressure will rise for Pro users.
• Consumer trust may weaken if changes feel abrupt. (github.blog)

---

What Changes for Business and Enterprise Customers​

For companies, the story is more nuanced. Business and Enterprise plans already live closer to policy control than consumer subscription logic, so token-based guardrails are less shocking in principle. Still, any tightening of rate limits or model availability can affect productivity, especially in teams that have embedded Copilot into daily development workflows. (github.blog)
The upside for enterprises is that token-based accounting is easier to govern than request counts. It can better reflect the actual load generated by large teams, and it aligns more naturally with reporting, budgeting, and policy enforcement. GitHub has also been expanding usage metrics and organization-level visibility, including reporting that now shows token totals and average tokens per request. (github.blog)
But the downside is equally clear: heavier teams will be more exposed to cost spikes, especially if they rely on agent workflows or high-multiplier models. That means IT and platform engineering teams will need to start managing Copilot the way they manage cloud compute, with budgets, thresholds, and internal guidance. The days of “just give everyone Copilot and see what happens” are fading. (github.blog)

Governance becomes part of the product​

Microsoft is effectively turning Copilot into an administrable capacity system. That is useful for CIOs, but it also means the admin console matters more than the marketing page. Organizations will need to decide who gets premium models, which workflows justify higher spend, and when to steer users toward auto mode or smaller models. (github.blog)

Enterprises will need policy, not just licenses​

The important strategic shift is that licensing alone is no longer enough. Enterprises will need policies that account for token burn, model multipliers, and session behavior. In that sense, Copilot is starting to resemble a governed AI platform rather than a universal developer entitlement. (github.blog)

• Better reporting helps finance teams.
• Token-based controls can prevent runaway usage.
• High-concurrency teams will need internal guardrails.
• Admins may need to educate developers about model selection.
• Procurement will care more about variable cost exposure. (github.blog)

---

Competitive Implications​

This move will ripple beyond GitHub. Competing AI coding products are all being judged on two axes now: model quality and economic predictability. If GitHub raises prices or constrains access too aggressively, rivals will market themselves as simpler or more generous. If GitHub holds the line too loosely, it risks turning Copilot into a loss-leader in an increasingly expensive category. (github.blog)
There is also a model-access angle. GitHub has been curating which models appear in which tiers, and Opus availability is now being used as a premium differentiator. That mirrors the broader industry trend where frontier models are used as a fence, not just a feature. In competitive terms, model access is becoming part of price discrimination. (github.blog)
The broader market effect may be even more important. If Microsoft can normalize token-based billing inside Copilot, other vendors may follow more aggressively, because it gives them a cleaner story for margins and capacity planning. The result could be a market where AI development tools look less like SaaS subscriptions and more like cloud services with metered usage and layered entitlements. (github.blog)

Why rivals should pay attention​

GitHub is setting a precedent by explaining limits in terms of tokens, multipliers, and session load. That language will likely become standard across developer AI products because it gives vendors a way to justify throttling in engineering terms rather than purely commercial ones. Competitors that cannot match that transparency may have trouble defending their own usage caps later. (github.blog)

The race to sustainable AI pricing​

This is where the AI market’s next phase comes into focus. The first wave was about user acquisition and feature breadth. The second wave is about sustainable pricing and whether vendors can keep advanced agents available without destroying margins. GitHub’s latest changes are a clear sign that the second wave has arrived. (github.blog)

• Model access is now a pricing lever.
• Token accounting is becoming an industry norm.
• Capability and cost are being separated more sharply.
• Competitors may need similar guardrails.
• The market is moving from hype to economics. (github.blog)

---

User Experience and Product Design​

One interesting side effect of token billing is that it changes how the product should be designed. If every prompt has a cost footprint, the product must help users avoid waste. GitHub is already doing this by surfacing usage warnings in VS Code and Copilot CLI and by recommending smaller models or plan mode for simpler jobs. That is a smart design choice, but it also makes the invisible economics visible. (github.blog)
The long-term design challenge is that users do not want to budget tokens mid-flow. They want the assistant to feel natural, fluid, and frictionless. When the system starts interjecting warnings, thresholds, and alternative model suggestions, the experience can begin to feel like enterprise software rather than magic. That tension is now central to Copilot’s evolution. (github.blog)
At the same time, the product can become smarter about work allocation. Auto model selection, for example, is a way to preserve convenience while steering users toward cheaper paths when possible. If GitHub can make those decisions feel helpful rather than punitive, the transition to token-aware usage may be less painful than the headline suggests. (github.blog)

The role of auto mode​

Auto mode is quietly becoming one of the most important features in the Copilot ecosystem. By choosing efficient models dynamically, it can reduce token burn and keep users within limits without forcing them to make every model decision manually. In effect, it is the product’s internal cost optimizer. (github.blog)

Transparency as damage control​

GitHub’s decision to display usage progress is as much about trust as it is about convenience. When customers can see how close they are to a limit, they are less likely to feel blindsided. That does not eliminate frustration, but it does reduce the sense that the product is hiding the meter until the last second. (github.blog)

• Surface limits early.
• Nudge users toward efficient models.
• Reserve expensive models for specialized work.
• Make billing behavior understandable.
• Reduce surprise before it becomes churn. (github.blog)

---

The Bigger Microsoft Pattern​

What’s happening in Copilot is not isolated. Microsoft has been steadily expanding consumption-based AI billing across its ecosystem, from Copilot-related services to SharePoint agents and other Microsoft 365 experiences. That suggests the company is normalizing a broader principle: AI should be monetized by usage intensity, not just by seat count.
That strategy makes sense for Microsoft because it aligns pricing with workload. But it also creates friction for customers who bought into the simplicity of subscriptions. Once an organization has multiple AI products, each with its own quota, policy, and overage logic, the administrative overhead rises quickly. In other words, consumption pricing solves one business problem and creates another. (github.blog)
For GitHub specifically, the stakes are higher because developer trust is unusually sensitive to product consistency. Developers notice when tools slow down, change behavior, or become unpredictably expensive. If Microsoft pushes too hard, it could invite backlash from exactly the audience Copilot is meant to win over. That is the balancing act. (github.blog)

Microsoft’s AI monetization stack​

Microsoft is now building a layered monetization stack across its AI portfolio. Some services remain subscription-based, some mix entitlements with overage policies, and others are moving toward usage-based guardrails. That flexibility is commercially powerful, but it also means customers need to understand each product on its own terms. (github.blog)

Why Copilot is the test case​

Copilot matters because it sits at the intersection of consumer appeal and enterprise adoption. If Microsoft can successfully convert Copilot into a sustainable, token-aware platform, it strengthens the case for consumption pricing everywhere else. If it mishandles the transition, it could harden skepticism about AI subscriptions across the entire Microsoft stack. (github.blog)

• Copilot is a bellwether product.
• Token pricing aligns with AI workload reality.
• Subscription simplicity is giving way to metered complexity.
• Microsoft is testing how much friction users will tolerate.
• Success here will influence future AI product pricing. (github.blog)

---

Strengths and Opportunities​

The clearest strength in Microsoft’s approach is that it is finally matching pricing to the reality of modern AI workloads. That may be unpopular with some users, but it is commercially coherent, especially as agentic usage becomes more expensive and more common. It also creates room for clearer governance, better capacity planning, and more defensible service reliability. (github.blog)

• Better alignment between cost and usage.
• More predictable infrastructure management.
• Stronger enterprise governance and reporting.
• Incentives to use smaller, cheaper models when appropriate.
• A cleaner path to sustainable AI margins.
• More transparent limit warnings in the product.
• A chance to improve reliability for existing customers. (github.blog)

---

Risks and Concerns​

The biggest risk is backlash from users who feel Copilot is becoming more expensive and less generous without enough warning. Pausing new signups, cutting model access, and tightening limits all at once can look like a bait-and-switch if users were expecting a stable subscription experience. That perception risk is especially high among individual developers who are more price-sensitive than enterprise buyers. (github.blog)

• Perceived price hikes may hurt trust.
• Heavy users could churn to competitors.
• Model restrictions may feel arbitrary.
• Token billing is harder for casual users to understand.
• Support load may rise as limits become visible.
• Developers may change behavior to avoid running up costs.
• Enterprises may face budget uncertainty from variable AI usage. (github.blog)

---

Looking Ahead​

The next few weeks will determine whether this is seen as a manageable reset or the beginning of a broader Copilot contraction. GitHub has already said new signups are paused and that the changes are designed to preserve service reliability for existing customers, but that explanation will only go so far if users keep hitting limits in ordinary workflows. The company will need to show that the product still feels powerful, not merely rationed. (github.blog)
The bigger question is whether Microsoft can make token-based billing feel fair. If the product is transparent, the limits are well-calibrated, and the most expensive models remain reserved for genuinely advanced work, users may accept the tradeoff. If not, Copilot risks being remembered less as a breakthrough coding assistant and more as the moment AI subscriptions began behaving like utility meters. (github.blog)

Key things to watch​

• Whether Microsoft restores or reshapes individual plan availability.
• How aggressively token-based limits affect day-to-day coding sessions.
• Whether Pro+ remains compelling enough to absorb frustrated Pro users.
• How enterprises react to higher visibility into token consumption.
• Whether rival coding tools copy the same metered model.
• Whether Microsoft expands or trims model access further. (github.blog)

Copilot is entering a new phase, and it is one that prioritizes sustainability over simplicity. That may be the right business decision, especially if AI coding truly is becoming a compute-heavy workload rather than a cheap assistant feature. But for the developers paying attention, the symbolism is hard to miss: the era of vaguely subsidized AI tooling is ending, and the era of explicit AI economics has begun.

---

Source: Thurrott.com Microsoft Brings Token-Based Billing to GitHub Copilot (Updated)