Visual Studio Update Aligns Copilot Tracking with GitHub's New Billing Model

Visual Studio just got honest about Copilot costs — here's how to use the new window

The June 2026 update to Visual Studio did something developers have been asking for since GitHub Copilot launched: it stopped hiding what you're actually paying for. The new Copilot Usage window tracks every token, in real time, against a usage-based billing model that Microsoft flipped on June 1, 2026. For the first time, you can see the cost of a chat turn as it lands, not after the invoice arrives.

That's a real shift. Token-based accounting is what every other AI tool already does — OpenAI's dashboard, Cursor's usage panel, Claude Code's /cost command. Aligning Visual Studio's UI to it removes the mystery layer that used to sit between "I sent a prompt" and "my bill went up." And the same update added trust validation for Model Context Protocol (MCP) servers — the kind of boring-but-load-bearing feature that makes the rest of the agent ecosystem safe to actually use.

If you spend any part of your day in Visual Studio with Copilot on, here's how to use the new system well.

What changed: from request counts to token counts

Before this update, Visual Studio's Copilot reporting tracked requests. Prompts, completions, agent turns — one row each. That told you how often you asked, not how much you asked for. A one-line completion and a 4,000-token agentic refactor looked identical in the dashboard, even though one costs roughly a hundred times more to serve.

The June 2026 update retires that view. Per the announcement on June 30, Copilot usage now follows GitHub's usage-based billing model and is calculated based on token consumption rather than by request. Behind the scenes that matches the same primitive every other major AI surface already exposes. It's not a new metric — it's the metric everyone else has been using for years, finally surfaced inside the IDE.

The honest version of "how much did this turn cost me" was always tokens. The update just stops fudging it.

How to actually open the new usage window

The window is one click deep. Open it before you start a long session so you have a baseline number.

# In Visual Studio (June 2026 update or later):
# 1. Locate the Copilot badge in the status bar (bottom-right)
# 2. Click the badge  ->  "Copilot Usage"
# 3. Pin the tab — it updates in real time as you work

Once it's open you get a live panel: cumulative tokens for the current billing period, a per-session breakdown, and the same numbers GitHub's web dashboard shows. The "real-time updates as the developer works" piece is the part that actually matters — you can now watch a heavy agent session ramp up its token use the way you'd watch a download bar, instead of finding out on the 1st of the month.

Worth doing once today: open the window, run one representative session (a refactor, a test-writing pass, whatever your normal Copilot workload looks like), and write down the tokens-per-hour number. That's your new budget baseline.

Why token-based tracking is the only honest version

There are three reasons this matters beyond the billing accuracy.

It makes prompts comparable. A 200-token prompt and an 8,000-token prompt are now visibly different costs. You start to notice when you're pasting in whole files instead of diffs, when an agent's context window fills with tool output, when a system prompt is doing more work than your question.

It exposes the real cost of agent loops. Every MCP call, every retry, every tool response re-injected into context — they all show up now. Agents aren't free; they were just priced opaquely. The new panel makes the price visible.

It lets you decide, per action, whether it was worth it. Before, the question was "did Copilot do anything useful this hour?" Now it's "did this turn earn its tokens?" That is a much better question for engineers who care about their tooling bill.

This also explains why GitHub flipped the underlying billing model on June 1: tokens are the unit that lines up with how the model is actually served. Visual Studio's window is the user-facing mirror of that.

MCP trust validation: the quiet security win

Halfway down the release notes sits the second feature: trust validation for MCP servers. MCP — Model Context Protocol — is the standard Copilot uses to talk to external tools (databases, file systems, browsers, internal APIs). Until now, any MCP server Copilot could reach was reachable without a per-server consent prompt.

The June 2026 update adds a trust gate. The first time a given MCP server is invoked, Visual Studio asks you to confirm it. After that it stays trusted for the workspace. It's the same pattern as installing a Visual Studio extension — first-run consent, then whitelisted.

The reason this is a real win and not checkbox compliance: MCP servers are remote code execution by another name. A prompt-injection attack that convinces Copilot to call an unvetted MCP endpoint was a credible threat, and trust validation is exactly the gate that closes it. Microsoft added it because they had to. The fact that they're shipping it at the IDE layer, not behind a separate admin policy, means it lands by default on every developer who updates.

If you're running Copilot against internal MCP servers at work, the right move today is to update Visual Studio, then spend ten minutes going through the trust prompts the first session asks you to confirm.

What this gets us

Three concrete things change for a working developer after this update:

The first row is the productivity win. The second row is the security win. Both show up the moment you update.

The harder win — and the one most people will miss — is what this implies for how you build with Copilot going forward. Token-aware tooling will start to matter: code actions that batch edits instead of looping one at a time, prompts that diff instead of pasting whole files, agents that summarise tool output before passing it back to the model. Those aren't new ideas; they're the same patterns high-token-efficiency teams have been using since 2024. Visual Studio's new window just makes the payoff visible enough that the rest of us can't ignore it.

The durable layer under the churn

The thing worth holding onto is that the surface keeps moving — request counts, token counts, MCP trust prompts, billing-model flips every 18 months — and most of it doesn't change anything about how the actual product works underneath. Visual Studio, Copilot, the MCP tools, and the model behind them can swap out beneath you, and you should still be writing the same components with the same APIs against the same targets.

That's the part worth investing in: the layer that doesn't change when the layer above it does. The way your UI components are structured, how they share APIs across the runtimes and IDEs you ship to, the auth and data primitives that survive the next billing-model pivot — those compound. The token counter in your status bar will look different in eighteen months. The component that renders it won't have to.

Update Visual Studio. Open Copilot Usage from the badge. Watch one session run. The meter is honest now — use it.