GitHub Copilot Adds Per-Model Token Reports: A FinOps Reconciliation Guide

GitHub Copilot's AI usage report now breaks each model's AI credits into input tokens, output tokens, cache reads, and cache writes. That turns a previously opaque charge into a workload profile. Teams can finally ask whether spend comes from large contexts, verbose answers, cache misses, or premium model selection.

The report is not a raw provider invoice. Copilot applies plan rules, credit accounting, and product-specific routing. Still, token categories create a common language for engineering, finance, and platform teams. The right objective is not to reproduce every provider calculation; it is to explain changes and find controllable waste.

What GitHub Added

According to GitHub's August 11 changelog, downloaded reports now show input, output, cache-read, and cache-write tokens next to consumed AI credits for each model. The breakdown is available to Copilot Business and Enterprise administrators and individual Copilot users.

Those four counters describe different levers. Input grows with repository context and conversation history. Output grows with reasoning, explanations, and generated code. Cache writes show new reusable prefixes being stored; cache reads show reuse. Credits summarize how product billing values those activities.

Build a Reconciliation Table

Store each export with its reporting window and create one row per team and model. Include token categories, AI credits, active users, accepted pull requests, and successful agent sessions. Calculate credits per million effective tokens and credits per accepted result. The first ratio explains accounting; the second explains business value.

Do not combine cached and uncached input blindly. A team with high input volume and high cache reuse may be efficient, while another with fewer tokens but constant cache writes may be rebuilding context unnecessarily. Track cache read-to-write ratio and the share of total input served from cache.

Diagnose the Shape of Waste

• High input, low output: oversized repository context, long chats, or broad tool results.
• Low input, high output: verbose responses, repeated code generation, or unconstrained reasoning.
• High cache writes: unstable prefixes, fragmented sessions, or frequent instruction changes.
• High credits per result: premium routing, retries, or work that is generated but not accepted.

Investigate outliers with task telemetry. Token reports alone cannot tell whether a large context was necessary or an output prevented hours of debugging. Sample expensive sessions, classify the task, and compare them with successful cheaper sessions of the same type.

Set Model-Specific Guardrails

A single organization-wide token threshold punishes models with different economics and roles. Establish expected bands by model and task. A premium reasoning model may consume fewer total tokens but more credits; a fast budget model may use more tokens across retries. Alert on deviations from each workload's baseline.

Use rolling medians rather than fixed averages so one unusual migration does not distort the baseline. Require a minimum sample size before changing routing. If a model looks cheaper for a week, confirm that acceptance rate, review time, defect escape, and developer satisfaction did not deteriorate.

Allocate Without Creating Perverse Incentives

Chargeback can make teams avoid valuable tools or hide experiments. Start with showback: give cost centers a transparent statement of users, credits, token shape, and outcomes. Discuss anomalies before imposing limits. Move to budgets only when the measurement is trusted and teams have practical ways to reduce spend.

Do not rank individual developers by raw tokens. Hard tasks, mentoring, and platform responsibilities create legitimate variation. Aggregate at a team or workload level and use individual data for troubleshooting with appropriate privacy controls. Optimize systems and routing, not surveillance.

Run a Monthly Optimization Loop

At month end, compare token mix and credits with the previous period. Select the two largest controllable changes, such as a cache-write spike or premium-model migration. Test one intervention per cohort, then measure accepted outcomes. Keep the report schema versioned because GitHub can add columns or alter accounting semantics.

Validate Export Quality

Before using the export for budgets, reconcile reporting dates, timezones, organization scope, and late-arriving usage. Confirm that the same user or cost center is not counted twice across rollups. Preserve the original file and a checksum so transformations remain auditable.

Create automated tests for required columns, numeric types, nonnegative counters, model-name normalization, and totals. Flag schema changes instead of silently loading them. Compare aggregate AI credits with the billing view for the same window. Small timing differences can be documented; unexplained large differences should block chargeback decisions.

Bottom Line

Per-model token categories convert Copilot credits from a mystery number into an operational signal. Reconcile by model and workload, separate cache behavior, and join usage to accepted results. The goal is a cheaper successful engineering outcome, not the smallest token total on a dashboard.