Two months ago, GitHub switched Copilot from a flat subscription to usage-based billing measured in AI Credits. The backlash was immediate and it has not gone away. Developers are still watching credits evaporate on trivial interactions, still comparing Copilot credit costs to competing coding agents, and still finding that the math does not work for heavy agentic workflows. With promotional credit allowances expiring September 1, the window to understand and budget for Copilot credit costs is closing fast.
The core problem: every message carries the full context window, and credits meter every token in it.
On June 1, 2026, GitHub activated usage-based billing for all Copilot plans, replacing the old premium-request counter with GitHub AI Credits. The unit of consumption is token-based: input, output, and cached tokens all count, priced at each model's listed API rate. A developer who previously paid $10 or $39 a month for effectively unlimited autocomplete now operates inside a metered budget where a single agentic session can consume hundreds of credits.
The complaints have a consistent shape. One Visual Studio Magazine reader reported burning through 1,227 of 1,500 free monthly credits on day one, projecting a $180 bill for June at that pace. Another user turned off all MCP servers and found that Copilot still consumed approximately 29,000 tokens, roughly 29 AI Credits, every time they sent a message, even one as simple as "lol." At that rate, 7,000 monthly credits buy roughly 240 messages, or about 8 per day, before any actual coding work happens.
What did GitHub change, and what stayed the same?
GitHub's billing overhaul replaced a simple per-request counter with a token-metered system. Under the old model, most Copilot interactions counted as one request, with a small monthly cap on premium requests that used more expensive models. The new model prices every interaction at the token level, which means the cost of a single message depends on the model selected, the size of the conversation context, and how many tokens the response generates.
The plan structure for individual subscribers looks like this:
| Plan | Monthly Price | Base Credits | Flex Credits | Total Included Value |
|---|---|---|---|---|
| Copilot Pro | $10 | $10 | $5 | $15 |
| Copilot Pro+ | $39 | $39 | $31 | $70 |
| Copilot Max | $100 | $100 | $100 | $200 |
Flex credits are included automatically without raising subscription prices, but GitHub describes them as a variable benefit that may change as model prices and AI economics evolve. Only the base allowance is fixed. For organizations, Copilot Business seats receive 1,900 credits per user and Enterprise seats receive 3,900, pooled across the organization rather than isolated per employee.
During the promotional period running through August, Business seats get 3,000 credits and Enterprise seats get 7,000. That cushion expires September 1, after which the permanent, smaller pools take effect. GitHub advises organizations to use the promotional months to establish a consumption baseline and resize budgets. Companies that do not could face a second cost shock when credits drop by roughly 37 percent for Business and 44 percent for Enterprise. The chart below shows the gap.
Why are credits disappearing so fast?
The credit drain is driven by context. Every message in a Copilot chat session sends the full conversation history, attached files, and any active MCP server context to the model. That means the token count grows with every turn, and the credit charge grows with it. A developer who has a 50-message conversation is paying for the accumulated context of all 50 messages on every single turn.
The user who reported 29 credits per trivial message identified the structural issue: even with all MCP servers disabled, Copilot was still loading roughly 29,000 tokens of context per message. That is the cost of the conversation itself, before any work gets done. For agentic workflows, where Copilot may run multiple subagents, compact conversations, and make background calls, the credit consumption multiplies. The Visual Studio Magazine reader who projected a $1,000 monthly bill, up from $80, was running formatting agents and agentic workflows that stacked token costs rapidly.
This is the same pattern we identified when we covered the agent cost problem arriving at Copilot's door. Agentic workloads are inherently token-heavy because they require multiple model calls, context management, and iterative reasoning. A billing model that charges per token exposes the true cost of those workloads in a way that flat subscriptions hid.
What controls has GitHub added, and do they help?
GitHub has shipped a steady stream of metering and budgeting tools since the billing switch. The list is long.
- A session-level AI Credit limit for Copilot CLI and the Copilot SDK, added July 1, lets developers cap agent runs that could otherwise continue unattended. Developers can use the
/limitscommand interactively or pass--max-ai-creditsto scripted sessions. The calculation includes primary model calls, subagents, and background work such as conversation compaction. - A refreshed Copilot Usage window in Visual Studio shows real-time monthly consumption with approaching-limit, limit-reached, and paid-overage alerts, introduced in the June stable update and refined through July.
- A donut chart in the Visual Studio 2026 Insiders release shows how much of the current conversation's context window has been consumed, separate from the monthly credit meter. Developers click it to open their full plan-usage details.
- A July 10 REST API update returns every covered user's progress against universal and cost-center budgets, letting administrators filter for users above a selected consumption percentage, sort by usage, and identify individual overrides before limits are reached.
- A 10 percent discount on model costs when the Auto model selection is used in Copilot Chat, CLI, the Copilot app, or the Copilot cloud agent. Auto routes simpler work to cheaper models while reserving expensive reasoning models for harder tasks.
GitHub also recommends a universal user-level budget as the "single most important control" in its enterprise budget guidance. User-level budgets are always hard stops. Organization and cost-center spending limits, however, can function as notification thresholds only unless an administrator explicitly enables "Stop usage when budget limit is reached." That distinction matters: a budget that only alerts will let a runaway agent keep burning credits until a human intervenes.
The controls are real and useful, but they are reactive. They tell you that credits are burning and they can stop the bleeding. A session cap prevents runaway agent costs, but it also prevents the agent from finishing the task. A budget alert tells you that you are over limit, but it does not make the work cheaper. The chart below puts the problem in concrete terms: even on the promotional Enterprise plan with 7,000 credits, a developer sending trivial messages gets roughly 241 exchanges before exhaustion.
How does Copilot's cost compare to alternatives?
Developers in the Visual Studio Magazine comment threads are actively comparing Copilot's credit-based pricing to competing tools, and the comparison is not flattering. The original article quotes a user saying Copilot went from "an empowering tool to a money siphon" where "you can easily spend 20k bucks a month there." Another commenter wrote that going from $80 per month to a projected $1,000 per month is "ridiculous."
Coding agents like Claude Code, Cursor, and open-source alternatives operate on different economic models, some with their own token-based pricing but others with more predictable per-seat or per-task structures. The open-source agent we covered in our piece about halving Claude Code costs on large repos demonstrates that the cost of agentic coding varies enormously depending on architecture and orchestration. Copilot's token-metered model is on the expensive end for agentic work because it charges for every token in every context window on every turn, with no batching or caching discount that meaningfully offsets the compounding cost.
A developer paying $39 per month for Copilot Pro+ gets $70 in included credit value. If a typical agentic session consumes 200 to 400 credits, that is 175 to 350 sessions before overage. For a developer running multiple agentic workflows per day, the included value lasts a week or less. Overage kicks in at API rates, which for frontier models can run $3 to $15 per million input tokens. A heavy agentic month could easily cost $300 to $1,000 in overage on top of the subscription.
What should you do before September 1?
The promotional credit cushion expires in weeks. Here is what to do now.
- Establish your baseline. Pull July and August consumption data from the Copilot Usage window or the REST API. Calculate your average daily credit burn per developer. Compare it to the permanent allowance, not the promotional one. If your team burns 3,000 promotional Enterprise credits per seat in August, the permanent 3,900 allowance gives you barely a week of headroom.
- Set universal user-level budgets. GitHub calls this the single most important control. Make sure every licensed developer has a hard cap that includes both the shared pool and paid overage. This prevents a runaway agent from generating a surprise bill.
- Enable hard stops on org-level budgets. If you only set notification thresholds, developers will keep consuming after the alert fires. Enable "Stop usage when budget limit is reached" on every cost-center budget you manage.
- Turn on Auto model selection. The 10 percent discount on model costs is the only direct price reduction GitHub offers. Auto routes simpler work to cheaper models, which matters when context tokens dominate the bill.
- Audit your MCP servers. Every active MCP server adds tokens to every message. The user who found 29,000 tokens per trivial message had already disabled all MCP servers and was still paying for context. Servers you do not need for the current task are pure overhead.
- Cap agent sessions. Use
--max-ai-creditson scripted Copilot CLI and SDK sessions. An unattended agent that loops will consume credits until the budget stops it, and the cap is soft: a response already in progress is allowed to finish, meaning the final total can slightly exceed the selected limit. - Evaluate alternatives for heavy agentic work. If your developers run multiple agent sessions per day, Copilot's per-token economics may not be the right fit. Compare total monthly cost against per-seat or per-task alternatives, and factor in the cost of the context tokens that Copilot charges for but that some competitors absorb.
The real cost of agent-friendly billing
GitHub's credit system is an honest billing model for a workload that turned out to be more expensive than anyone wanted to admit. It accurately charges for what agentic coding costs in compute terms: every token, every context window, every subagent call. The friction comes from the gap between what agentic work actually costs and what developers expected to pay under the flat-rate model that subsidized those costs for years. The promotional credits are a bridge, and that bridge ends September 1. The teams that have measured their burn, set hard budgets, and decided whether Copilot's economics work for their workload will cross it cleanly. The teams that have not will get the bill that makes the June backlash look like a preview.
Sources
- Visual Studio Magazine - Copilot Credit Complaints Keep Coming: 'Too Expensive to Use'
- Visual Studio Magazine - Copilot AI Billing Shock Met with Meters, Caps and Token-Saving Tools
- Visual Studio Magazine - Copilot Billing Shock Hits Developers
- Visual Studio Magazine - Visual Studio Insiders Further Refines Copilot Usage Tracking
- Visual Studio Magazine - Copilot Usage-Based Billing Gets a Token Dashboard
