Copilot Analytics shows you what AI costs.
Git AI shows you what AI delivered.

What Copilot's native dashboard tracks

GitHub doesn't ship a Copilot analytics UI inside the org admin — they expose the Copilot Metrics API and ask you to build your own dashboard. The API returns daily aggregates of active and engaged users, code-completion stats by IDE / editor / language / model, chat counts, and "PR summaries created."

GitHub is upfront about the data's shape - they share usage data, but can't track AI-attribution or measure % AI at the PR level. The API has a 100-day retention window, does not support individual-level queries, and requires telemetry to be enabled in each developer's IDE. Spend is tracked separately from output, in monthly buckets, on the Billing & Licensing page — broken down by SKU and model, with no per-PR, per-team, or per-repo cost slicing.

The bigger problem is what the data can't answer. There's no PR-level attribution at all — Copilot reports counts, not provenance. You can't tie token spend on a Copilot session to a specific PR or to the value it delivered. You can't see how AI code holds up over time, how much of it gets rewritten, or how much rework it generates downstream. The cost is precise. The outcomes are not.

Track AI code through the entire SDLC

How much of what Copilot generates gets thrown away before it's even committed? How many of its edits get rejected during code review? How much AI code actually makes it through merge? Once it ships, does it cause incidents? Get rewritten weeks later? Pile up rework that never gets accounted for?

The only way to answer those questions is to track AI code through the entire SDLC. Git AI extends Git's native git blame with line-level AI attribution, so every line of AI-code can be followed from the moment it enters your codebase to the moment it churns out.

Because attribution is recorded by Copilot itself — via agent hooks — every line keeps its provenance through rebases, squashes, cherry-picks, and merges. No 5-user minimum. No 100-day retention window. No "build your own dashboard."

Token spend that maps to outcomes

GitHub's Billing page shows monthly Copilot spend by SKU and premium-request model. That's enough to spot users running over allowance, but not enough to see what the spend bought you.

Git AI breaks Copilot spend down by commit, PR, repository, team, and individual — so you can see which work cost what, which repos are token sinks, and where the inefficient sessions are concentrated.

Measure agent autonomy

Copilot's accept rate tells you that a suggestion was inserted. It can't tell you how much steering it took to get there. Two sessions can both ship 100% Copilot-authored code — and one of them is a straight line from intent to production while the other is a loop of corrections, abandoned branches, and rewrites.

Both sessions might post a 95% accept rate. Only one of them is actually autonomous. Git AI measures the gap so you can find the prompts, skills, and codebase context that close it.

Measure token efficiency, keep costs in check

Copilot's pricing is moving steadily toward premium-request usage billing. It's not enough to know how many premium requests you're burning. You need to know what those requests are buying you, and whether the outcomes justify the costs.

For every 100 lines Copilot generates, how many reach production? In well-prepared codebases — strong tests, clear AGENTS.md, good architectural docs — we see ratios near 4:1. In sparse codebases, the same agent can run 50:1 or worse, with most of what it generates getting regenerated, abandoned, or rewritten before it reaches a commit. Git AI helps you identify where the agents get stuck, and make your codebases AI-ready — saving you token costs.

Code durability and incidents traced back to the prompt

The Copilot Metrics API doesn't follow code past suggestion-time. Git AI does. We measure how much AI code is rewritten, reverted, or refactored in the 30 / 60 / 90 days after it ships — the durability of agent output. Across our fleet we see 30-day durability range from ~30% to ~85% depending on the team.

When a production incident fires, every line involved can be walked back to the exact Copilot session, model version, and prompt that produced it. The session transcript lives in the Prompt + Context Store, so post-mortems can answer not just "who wrote this" but "what was the agent told, and what context did it have when it wrote it."

One dashboard for every agent

Most teams don't only run Copilot. Cursor, Claude Code, Codex, Gemini — each ships its own dashboard, with its own assumptions and its own attribution heuristics. Git AI is built on an open standard that unifies them all.

Cursor, Claude Code, OpenAI Codex, GitHub Copilot, Gemini CLI, OpenCode, Continue, Droid, Junie, Rovo Dev, Amp, Windsurf

Getting the data into one place is the easy part. Once every line of AI code is attributed and tracked through the SDLC, you can:

• Accelerate adoption. Spot the teams, repos, and prompting patterns that get the most leverage from agents — and roll what's working out everywhere else.
• Make AI work for your codebase. Find where agents get stuck, where context is thin, where tests and skills need to be tightened. The data tells you exactly where to invest.
• Justify the spend. Tie tokens to merged PRs, durable production code, and incidents avoided. Show finance and leadership exactly what the AI budget delivered.