Five weeks. That is how long enterprise admins, finance leaders, and developer experience teams have to prepare for the largest pricing change in GitHub Copilot’s history. On June 1, 2026, Copilot transitions from per-user premium request units (PRUs) to usage-based GitHub AI Credits, billed against per-model token rates. The same week brought GPT-5.5 to general availability, BYOK in VS Code chat, a Visual Studio Debugger Agent that loops from issue to fix, and a candid GitHub availability update describing two production incidents and a plan to scale for 30× today’s load. Here is what changed between April 21 and 28, and what to do about it before June kicks the new model into gear.

GitHub Copilot Moves to Usage-Based Billing on June 1, 2026

Announced April 27, GitHub will replace premium request units with GitHub AI Credits across every Copilot plan starting June 1, 2026. The headline numbers:

  • Base seat prices are unchanged. Pro stays at $10/month, Business at $19/user/month, and Enterprise at $39/user/month.
  • Code completions and Next Edit Suggestions remain unlimited and do not consume AI Credits. Only agentic features, chat, and code review draw from the credit pool.
  • AI Credits are priced by per-model token rates — input, output, and cached tokens — at published API rates for each model.
  • Free models are being removed as part of the shift to usage-based pricing.
  • Annual plans are being retired. Existing annual subscribers can finish their term, with prorated credits offered for early conversion.
  • Unused monthly AI Credits do not roll over.

For Copilot Business and Enterprise customers, credits are pooled across the organization rather than stranded per user — power users and lighter users effectively share the same monthly bucket. Admins also gain new budget controls at the enterprise, cost-center, and user level, with the option to allow overage at published rates or hard-cap spending. Full details for admins are in the usage-based billing documentation.

GitHub is offering promotional credits for the June through August transition window: $30/user/month for existing Business customers and $70/user/month for Enterprise, layered on top of the seat price entitlement. A preview bill experience is rolling out in early May so admins can see how their actual usage would translate into the new model before it goes live.

Why it matters for enterprise teams: For most autocomplete-heavy users, the day-one bill probably looks similar — the unlimited completions tier covers the bulk of seat-time usage. The exposure sits with teams running heavy agentic workflows: long-running cloud agent sessions, repeated code reviews, parallelized /fleet-style runs in Copilot CLI, and chat-driven refactors. Those workloads will draw down the credit pool quickly, which is exactly why GitHub is restructuring the model. Treat the next five weeks as a metering exercise — measure now, set budgets second, write policy third.

Copilot Code Review Will Consume GitHub Actions Minutes

A related April 27 changelog confirmed that Copilot code review on private repositories will start consuming GitHub Actions minutes on June 1, 2026. Reviews will draw from existing Actions plan entitlements, with overage billed at standard Actions rates. Public repository reviews remain free. The change applies to Pro, Pro+, Business, and Enterprise plans, including reviews triggered from non-licensed users billed via direct organization billing.

This builds on the March 5 architecture change that moved code review onto an agentic foundation — the reviewer now uses tool calls to gather repository context (relevant code, directory structure, references) before producing feedback. The cost of that agentic context-gathering is now visible in two places: the AI Credit ledger and the Actions minutes ledger.

Why it matters for enterprise teams: Teams that have leaned into Copilot code review as a standing PR gate need to revisit two budgets, not one. Expect the second-order effect of higher Actions minute consumption on private repos, and consider whether self-hosted runners belong in the picture for high-volume review traffic.

GPT-5.5 Generally Available on Copilot, with a 7.5× Premium Multiplier

OpenAI’s GPT-5.5 reached general availability on Copilot on April 24, rolling out gradually across Pro+, Business, and Enterprise tiers. GitHub reports the model’s strongest performance shows up on complex, multi-step agentic coding tasks and real-world challenges — the same workload class that is driving the broader billing change. GPT-5.5 ships with a 7.5× premium request multiplier as promotional pricing, available across VS Code, Visual Studio, Copilot CLI, cloud agent, github.com, GitHub Mobile, JetBrains, Xcode, and Eclipse.

Enterprise and Business administrators must enable GPT-5.5 explicitly via Copilot policy settings — it is not on by default.

Why it matters for enterprise teams: A 7.5× multiplier is large. Until usage-based billing kicks in on June 1, that multiplier is consumed against your existing PRU allowance; after June 1, it translates directly into AI Credit burn. Decide deliberately which teams need GPT-5.5 access today versus letting auto model selection route them to the most cost-effective option.

Claude Opus 4.7 General Availability

Announced April 16 and now broadly available, Claude Opus 4.7 rolled into Copilot for Pro+, Business, and Enterprise users with stronger multi-step task performance and more reliable agentic execution. The model is selectable across VS Code, Visual Studio, Copilot CLI, cloud agent, JetBrains, Xcode, Eclipse, github.com, and GitHub Mobile. Promotional pricing keeps the Opus 4.7 multiplier at 7.5× through April 30, 2026, after which standard rates apply. Opus 4.5 and 4.6 are being phased out of the model picker in favor of 4.7.

Why it matters for enterprise teams: Opus 4.7 is the right tool for sophisticated, multi-file refactors and tool-dependent agent workflows where reliability matters more than speed. Pair it with task-scoped policies — not blanket access — to keep multiplier-driven spend predictable.

BYOK Lands in VS Code Chat for Business and Enterprise

The April 22 release of VS Code 1.117 delivered Bring Your Own Key support for Copilot Business and Enterprise. Customers can now connect their own API keys for Anthropic, OpenAI, Google Gemini, OpenRouter, Azure, and locally-running providers like Ollama and Foundry Local directly in VS Code chat, the built-in plan agent, and custom agents. BYOK usage is billed by the provider, does not count against Copilot quotas, and is governed by the new Bring Your Own Language Model Key admin policy on github.com.

Why it matters for enterprise teams: BYOK gives organizations a clean lever for cost arbitrage, regional sovereignty, and on-device inference. Pair it with the upcoming usage-based billing model and you have two distinct economic paths: pooled AI Credits for shared workloads and direct provider billing for specialty teams (regulated workloads, on-prem inference, model evaluation). Both can coexist under one Copilot policy.

VS Code 1.117 Highlights Beyond BYOK

The same April 22 release brought several smaller wins worth knowing about:

  • Incremental rendering of chat responses (experimental, on by default). Long responses now stream content block-by-block with optional fade, rise, blur, and slide animations. Configurable via chat.experimental.incrementalRendering.
  • Sort agent sessions by recent activity in the Agent Sessions view, making it easier to resume long-running work.
  • System notifications for background terminal commands — when an agent runs a long shell command, status now surfaces as a system notification rather than forcing a context switch to the terminal.
  • Copilot CLI terminal profile launches from any shell (fish, Git Bash, PowerShell) without errors.
  • Agent CLI shell-type detection. The terminal now recognizes Copilot CLI, Claude Code, and Gemini CLI as distinct shell types, surfacing proper titles instead of generic “node” labels.

The companion Visual Studio Code Agents Insiders app also added sub-sessions (spawn a child session for parallel research or review), inline change rendering for diff scanning, and a smoother cross-OS update flow.

Visual Studio 18.5 Adds Debugger Agent, Cloud Agent, and Skill Auto-Discovery

Visual Studio 2026 version 18.5.0, released April 14 with an 18.5.1 patch on April 21, is one of the largest Copilot updates the IDE has shipped. Key additions:

  • Debugger Agent. A new agentic loop that validates bugs against real runtime behavior instead of static analysis: understand the issue → instrument the app → isolate root cause → validate the fix via live execution. Supports starting from a GitHub or Azure DevOps issue, or a natural-language bug description.
  • Cloud Agent integration. Start cloud agent sessions directly from Visual Studio. The agent requests permission to open a GitHub issue, then creates a PR to address it while the developer keeps working.
  • Custom agents via .agent.md. Files stored in .github/agents/ (repo) or %USERPROFILE%/.github/agents/ (user) appear in the agent picker with workspace awareness, code understanding, tool selection, model preference, and MCP connections.
  • Agent skills auto-discovery. Reusable instruction sets stored in .github/skills/, .claude/skills/, .agents/skills/, or ~/.copilot/skills/ are discovered automatically following the agentskills.io specification.
  • C++ code editing tools for agent mode are now generally available.
  • IntelliSense priority over Copilot. When IntelliSense is active, Copilot completions are suppressed; they resume after the IntelliSense selection is dismissed or committed.
  • New chat history panel replaces the dropdown with titles, message previews, and last-updated timestamps.
  • Copilot model thinking process UI added in 18.5.1 (April 21) shows the agent’s reasoning during operation.
  • Customizable Copilot keyboard shortcuts for accepting full suggestions, next word, and next line.

Why it matters for enterprise teams: Visual Studio remains the primary IDE for many regulated, enterprise .NET, and C++ shops. The Debugger Agent in particular is a meaningful upgrade — runtime-validated fixes versus static suggestions is the kind of pattern that earns trust on production code.

Copilot Cloud Agent: 20% Faster Starts, Visible from Issues and Projects

Two cloud agent improvements landed this week:

Faster startup (April 27). Cloud agent starts are now over 20% faster thanks to optimized runner environments built from GitHub Actions custom images. This builds on the 50% improvement shipped in March, shortening the feedback loop for tasks assigned from issues, the Agents tab, or @copilot mentions in PRs.

Native visibility in issues and projects (April 23). Cloud agent sessions are now visible directly from GitHub issues and project boards, including a session pill on issues, a side panel for session details and steering, agent sessions enabled by default in project views, and inline session management from project boards.

Why it matters for enterprise teams: Project managers and engineering leads gain visibility into agent activity without navigating to a separate surface. That makes the cloud agent meaningfully easier to govern at the team level — review queues and project boards become the single source of truth for both human and agent work.

Copilot Chat Gets Smarter About PRs and Stack Traces

Two web-based Copilot Chat improvements rolled out April 23:

  • PR-aware chat. Copilot Chat on github.com now understands PR context (comments, file changes, commits, reviews) and can produce structured PR reviews and concise summaries. Three new abilities: PR understanding, PR review, and PR summary. Works in both on-page chat and immersive chat at github.com/copilot.
  • Stack-trace root cause analysis. Pasting a stack trace into Copilot Chat on github.com triggers a structured response covering what failed and where, why it failed, the most likely root cause, evidence from code references, confidence level, and suggested fix.

Why it matters for enterprise teams: Both features push Copilot deeper into the day-to-day review and debugging loop on the web. The stack-trace analysis is especially useful for support escalations and incident triage — paste the error, get a structured starting point.

JetBrains: Inline Agent Mode in Public Preview

The April 24 GitHub Copilot plugin update for JetBrains IDEs introduced inline agent mode in public preview, bringing agent capabilities directly into the inline chat panel without switching contexts. Access via Shift+Ctrl+I (Windows/Linux) or Shift+Cmd+I (macOS). The release also delivered Next Edit Suggestions enhancements (inline edit previews, far-away edit indicators with one-click navigation) and global auto-approve for all tool calls with granular controls for terminal commands and file edits. Enterprise and Business administrators must enable the Editor preview features policy to expose inline agent mode to their teams.

Copilot CLI: Plan Mode, Auto-Compaction, MCP, and Skills

Copilot CLI continued to expand its enterprise-friendly surface area:

  • Plan mode (toggle with Shift+Tab) builds a structured implementation plan and asks clarifying questions before writing any code — explicitly recommended in GitHub’s April 20 guidance as a way to reduce token consumption and avoid usage limits.
  • Auto-compaction kicks in when conversations approach 95% of the token limit, compressing context in the background without interrupting workflow. Manual controls include /compact (compress immediately) and /context (detailed token breakdown).
  • MCP server support for connecting external data sources and tools.
  • Custom agents, hooks, skills, and Copilot Memory — persistent repository understanding that deduces and stores coding conventions, patterns, and preferences across sessions.
  • Usage limit visibility now displays inline in the CLI when approaching session or weekly token caps.
  • C++ code intelligence (public preview, April 22) via the Microsoft C++ Language Server as an npm package, delivering symbol definitions, references, call hierarchies, and type info to the command line. Requires compile_commands.json; CMake setup skill included; MSBuild support planned.

GitHub Availability: Two Incidents and a 30× Capacity Plan

GitHub’s April 28 availability update is unusually candid. Two incidents are acknowledged:

  1. April 23 — Merge Queue regression. A regression in squash merge via merge queue produced incorrect merge commits when groups contained more than one PR. Affected 230 repositories and 2,092 PRs. No data loss, but default branches required manual repair. Process changes are in flight to prevent recurrence.
  2. April 27 — Search-related outage. An Elasticsearch subsystem outage (likely caused by a botnet attack) disrupted search-backed experiences across PRs, issues, and projects. Git operations and APIs were unaffected; UI components showed no results.

The post also reveals scale numbers worth absorbing: 90M+ PRs merged per month, 1.4B+ commits per month, 20M+ new repositories per month, and a stated commitment that “agentic development workflows have accelerated sharply since December 2025.” GitHub is engineering for 30× current capacity, investing in multi-cloud migration, isolating critical services (git, Actions) from other workloads, and porting performance-sensitive code from Ruby to Go.

The status page itself got three transparency upgrades on April 17: a new Degraded Performance incident tier, per-service uptime percentages for the last 90 days, and a dedicated Copilot AI Model Providers component so model provider outages are tracked separately from the broader Copilot service.

Why it matters for enterprise teams: Two takeaways. First, the merge queue incident is the kind of silent-correctness bug that bypasses normal observability — if your repo was in the affected window, audit your default branches now. Second, the 30× capacity statement reframes how to plan for 2026 and 2027: agentic workloads are real, persistent, and growing, and the platforms underneath them are being rebuilt accordingly.

Other Platform Changes Worth Knowing

  • GitHub App installation token format is changing. A new stateless format (~520 characters, variable length, ghs_APPID_JWT structure) is rolling out in stages starting April 27 — Actions GITHUB_TOKEN and first-party integrations through mid-May, all GitHub App tokens through late June. Apps that validate token length or use regex patterns on tokens need updating now.
  • Notification retention reduced to three months (down from five) for web notifications. Watches on repositories archived for more than six months will be removed for non-collaborators. Email notifications are unaffected.
  • Pausing new self-serve Copilot Business signups as of April 22, signaling a shift toward account-managed and enterprise-directed sales motions.
  • Copilot for Jira added per-ticket custom agents, Atlassian custom field reading (acceptance criteria), custom branch naming rules, space-level custom instructions, and review request notifications back to Jira.
  • Copilot usage metrics API added a used_copilot_cloud_agent boolean field and aggregated code review user counts. Legacy “coding agent” field preserved for backward compatibility until August 1, 2026.

What to Do Before June 1

The next five weeks are best spent making three things true: you know your usage, you have budget guardrails in code, and your team knows what is changing.

  1. Run a usage baseline this week. Pull current Copilot usage metrics for the last 30 and 90 days. Identify the top 10% of users by request volume and the workload patterns that drive them — they will set the shape of your AI Credit consumption curve. Compare those numbers to GitHub’s preview bill experience when it lands in early May.
  2. Decide your budget posture before May 15. Pick one of three stances per cost center: hard-cap with no overage, soft-cap with approved overage at published rates, or open spend with weekly review. Codify the choice in budget controls at the enterprise and cost-center level. Pooled credits across the org mean small misconfigurations scale fast.
  3. Audit Actions minute consumption if your teams use Copilot code review at volume. Reviews on private repos start drawing from your Actions plan on June 1. Self-hosted runners may make sense for high-volume review traffic.
  4. Standardize on plan mode in Copilot CLI for non-trivial work. The April 20 guidance is explicit: planning before coding is the cheapest way to reduce token burn and avoid limits.
  5. Enable GPT-5.5 deliberately, not by default. A 7.5× multiplier on broad rollout will eat AI Credits faster than most leaders expect. Scope access to teams that need agentic strength and let auto model selection handle the rest.
  6. Patch any GitHub App that validates token length or matches token strings against regex. The new stateless format is variable length. Brittle assumptions will break during the rollout window.
  7. Brief finance and engineering leadership together. This is the rare AI tooling change that needs both audiences in the same room — finance to set guardrails, engineering to communicate which workloads moved where. The post-June 1 Copilot bill is a shared artifact.

If your team needs a hand reading the new model against your actual usage, Big Hat Group runs short, fixed-scope Copilot economics reviews for enterprise customers — bring your usage report, leave with a budget plan and a policy.

What to Watch

  • Preview bill experience (early May). First chance to see what June actually looks like for your org. Treat it as a fire drill.
  • Opus 4.7 promotional multiplier expires April 30. Standard pricing applies after that date — re-check your model policy.
  • Continued cloud agent visibility expansion. Expect cloud agent sessions to surface in more places (review queues, dashboards, third-party trackers) over the coming weeks.
  • Token format brownout. A brownout period is planned ahead of the late-June final rollout. If your integrations break during brownout, that is the signal to fix before full cutover.
  • More Agent HQ partners. Google, Cognition, and xAI are working on agents that will join Claude and Codex on Agent HQ. Pro+ and Enterprise customers will see the picker grow.

The week between April 21 and 28 doubled as a preview of how Copilot’s economics, ecosystem, and platform will look for the rest of 2026. Usage-based billing is the headline, but the deeper signal is GitHub publicly committing to 30× capacity for agentic workloads. The teams that come out ahead of June 1 will be the ones that turn metering into policy in the next five weeks.

Check back next week for more developments across the Copilot ecosystem.