GitHub Copilot’s AI Credit Cuts Are Coming: What Teams Need to Do Before September 1

If your team adopted GitHub Copilot Business or Enterprise before June 2026, you’ve been riding a generous wave of AI credits. That ends on September 1, 2026, when the included monthly allowance drops—by 37% for Copilot Business seats and by 44% for Copilot Enterprise seats. Organizations that don’t adjust could face surprise overages or blocked AI access.

What actually changed

On June 1, 2026, GitHub replaced its old premium-request billing with a usage-based model built around AI Credits. Each credit costs $0.01, and every Copilot interaction—from a quick chat to an hours-long agent session—now consumes credits based on the model and token count. Code completions and next-edit suggestions remain unlimited.

But the number that matters most right now isn’t the per-credit rate. It’s the included monthly allowance that comes with each assigned seat. For existing customers, GitHub is temporarily providing a much higher allocation: 3,000 credits per Business seat and 7,000 per Enterprise seat through August 31. This was designed as a three-month transition buffer while teams adjust to the new system.

Starting September 1, those numbers will fall to 1,900 credits for Copilot Business ($19/month) and 3,900 for Copilot Enterprise ($39/month). In dollar terms, each Business seat then contributes $19 worth of pooled credits, and each Enterprise seat contributes $39—exactly matching the per-seat subscription price. It sounds like a tidy one-to-one equivalence, but because credits are pooled across the entire billing entity, the practical effect is more complex.

The pooling puzzle

GitHub pools all included credits at the organization or enterprise level, not per user. A billing entity with 100 Business seats gets a monthly pool of 190,000 credits, not 100 individual buckets of 1,900. That means a handful of power users running agent-based workflows can consume far more than their “share,” while lighter users offset the drain. It’s a design that rewards varied usage patterns, but it also creates a critical budgeting blind spot: when the pool runs dry, either everyone pays or everyone stops.

Unused credits do not roll over; the pool resets to its full amount at midnight UTC on the first of each calendar month. Adding seats immediately increases the pool, but removing seats doesn’t shrink it until the next billing cycle.

What it means for you

For individual developers

If your organization hasn’t set personal caps, you likely won’t notice September 1 directly—unless the shared pool depletes and you suddenly lose Copilot access. The tools you use every day (Copilot Chat, Copilot CLI, Spaces, Spark, third-party agents) all draw from that same pool. Agent sessions with large file contexts consume significantly more credits than a quick inline chat. If you work on large codebases or lean heavily on agent features, your consumption may be dozens of times higher than a colleague’s. Your IT team will be watching those patterns.

For IT administrators

The September 1 cut demands immediate action. Your first task: calculate how much capacity you’ll actually have. Take your current seat counts, multiply Business seats by 1,900 and Enterprise seats by 3,900, and compare that to recent monthly usage—not to the inflated August numbers, but to what you’ll have in September. If your usage already exceeds the standard allowance, you have a problem.

Next, decide on overage policy. GitHub gives you two options when the pool is exhausted: allow additional usage at $0.01 per credit (charged to the organization/enterprise) or block all usage until the next reset. Neither is universally right. A platform engineering team might consider overage cheaper than interruption; a school or a department with a fixed budget might prefer a hard stop. The choice must be made and configured before September.

GitHub provides budget controls at multiple levels:

• User-level budgets cap an individual’s total consumption (from both the shared pool and any metered usage). A $0 budget blocks the user immediately.
• Cost-center budgets limit metered charges for a defined group after the pool depletes.
• Organization-level budgets cap metered charges for seats billed to a specific organization.
• Enterprise spending limits cap total metered charges across the entire enterprise.

These can interact in non-obvious ways. A user-level limit can halt a developer even if the shared pool still has credits. An enterprise spending limit can cut off everyone before individual caps are reached. There’s no automatic fallback to cheaper models—when a budget is exhausted, Copilot simply stops or costs extra.

For enterprise decision-makers

The shift from a flat per-seat cost to a consumption-based model changes how you think about license counts. Retaining a big pool of lightly used seats can inadvertently subsidize your heaviest AI consumers. Stripping away “unused” seats might slash the shared cushion that those heavy users depend on. You need to see your seat mix as a capacity-planning lever, not just a headcount exercise. A Business seat contributes $19 in credits, an Enterprise seat $39—but the real value depends on how consumption is distributed.

How we got here

GitHub Copilot launched in 2021 with a simple model: pay per user per month for code completions. In 2024, GitHub added Copilot Chat and later introduced agents, turning the tool into a much deeper AI assistant. The old “premium request” billing tracked expensive interactions separately, but that system was clunky and didn’t scale as Copilot’s feature set grew.

Microsoft, GitHub’s parent, has been pushing usage-based AI billing across its product line. Visual Studio, Microsoft 365, and Azure all now meter AI consumption in various ways. GitHub’s move aligns Copilot with that broader strategy: 1 credit = $0.01, a straightforward rate that makes costs predictable at any scale—if you manage the pool.

Existing Copilot Business and Enterprise customers were grandfathered into the higher promotional allowances to avoid a sudden shock. Annual Copilot Pro and Pro+ subscribers retain legacy premium-request billing for now. But for everyone else, September 1 marks the end of the cushion.

What to do now

1. Audit your actual credit consumption
Don’t guess. Use GitHub’s billing dashboard to pull a month of real usage data. Break it down by user, feature, and model type. Note how much came from agents vs. chat vs. CLI. If your organization is still in the promotional period, remember that those inflated numbers are not your future reality.

2. Model your September pool
Multiply your Business seats by 1,900 and Enterprise seats by 3,900. That’s your new monthly credit budget. Compare it to the consumption numbers from step 1. If you’re already over, you have four weeks to fix it.

3. Set budgets that match your risk tolerance
For users whose work stops if Copilot stops, set individual budgets that allow some overage—or ensure the shared pool is large enough to absorb them. For others, apply a hard cap (even $0) to prevent drain. Test the interaction: a $0 user-level budget blocks that user immediately, regardless of the shared pool. An enterprise spending limit can override individual budgets if it runs out first.

4. Reassess your seat assignments
A developer who uses Copilot twice a month doesn’t need an Enterprise seat—and may not need a license at all if your pool is tight. But be careful: removing too many “low-usage” seats can inadvertently crash the pool that supports your high-usage team. Run scenarios before making changes.

5. Update your tools
Older IDE and extension versions may display incorrect pricing or fail to show usage alerts. GitHub requires at least these versions for accurate billing:

If you can’t update immediately, you’ll still be able to use Copilot, but your billing data may be unreliable. Don’t wait until September to discover a discrepancy.

6. Treat the promotional period as a stress test
If your team is burning through credits at a rate that only works because you’re getting 3,000 or 7,000 per seat, that’s your September problem already visible. Use July and August to experiment with budgets, communicate with heavy users, and refine your policy. The goal: by September 1, you should know exactly whether your standard pool fits normal usage and what happens when it doesn’t.

Outlook

Usage-based billing is now the permanent reality for GitHub Copilot. The promotional credits were a onetime bridge, not a trial. Expect further refinement: GitHub may tweak model pricing, adjust included allowances, or introduce new plan tiers as AI usage patterns become clearer. For organizations that invest in monitoring and controls now, the shift can be a net positive—greater visibility into how AI tools are used, and the ability to align costs with actual value. For those that don’t, September’s credit cut will be an expensive wake‑up call.