Token Management Workflow

Step 1 of 7

Two billing models, measured two different ways

AI-assisted development is billed in two different ways. The design measures each one on its own terms before bringing both into a shared view.

Path A: Copilot premium request credits. These are included in the licence. Inline completions are unlimited and use no credits.
Path B: Custom Agent tokens. External LLM calls made with the organisation’s own keys (BYOK), charged directly in USD.
Not interchangeable. Credits and tokens are never converted into each other or added into a single number.

Path A

Native Copilot premium requests

Metric: ai_credits_used
Unit: Credits
Collected: Daily, from the vendor billing report
Budget: Pooled allowance of 3,900 credits per seat per month

Path B

Custom Agents under BYOK

Metric: token_usage
Unit: Input and output tokens
Collected: In-path at request time, at the managed gateway
Budget: Variable USD, priced per million tokens

Broader consumption view, keyed on user_login

CreditsTracked against the pooled allowance

Tokens → USDPriced by input and output

Shown side by side, never summed.

Step 2 of 7 · Path A

Copilot credits are collected once a day

A scheduled job reads consumption straight from the vendor, maps it to each user, stores a snapshot and publishes one dashboard. Select a stage, or run the daily job to follow it end to end.

Documented endpoint

GET /enterprises/{enterprise}/copilot/metrics/reports/users-1-day

The endpoint is shown for reference only. This page does not call it.

Daily collection pipeline

Read Copilot usage from the Enterprise Metrics API

The design reads the per-user daily usage report for the enterprise. This report is the vendor’s own record of premium request consumption.

GET /enterprises/{enterprise}/copilot/metrics/reports/users-1-day

Read the credits used by each user

For every user in the report, the job reads the premium request credits consumed. Inline completions are unlimited and do not appear as credit consumption.

user["ai_credits_used"]

Map credits to the user’s login

Each value is attached to the assignee’s login. This login becomes user_login, the key that later joins credits to token usage and delivery data.

user["ai_credits_used"] → user["assignee"]["login"]

Append a daily snapshot

Each run appends a snapshot rather than overwriting a single live number, so month-to-month trends stay visible.

Illustrative snapshot rows from the reference presentation
user_login	Last active	ai_credits_used
ahmed-dev	Yesterday	1,450
mahmoud-frontend	Today	320

Illustrative examples from the reference presentation, not live account data.

Step 3 of 7 · Path B

Custom Agent tokens are metered at the gateway

External LLM traffic is routed through one managed gateway: Azure API Management with a token-emission policy. The gateway is the measurement point, and agent definitions do not change.

Request sentThe agent sends its request through the managed gateway.
Tokens recordedThe token-emission policy records input and output tokens in-path.
Forwarded to the modelThe request continues to the Azure OpenAI or Anthropic endpoint, using the organisation’s own keys.
Usage attributedThe measured usage is associated with the requesting user_login.

This assumes external LLM traffic is routed through the gateway. Requests that bypass it are not measured. No connection to Azure or Anthropic is made, and no keys are requested.

Request path · Stage 1 of 4

Source Custom Agent security.md .md definition committed by a team

Measurement point Control point Azure API Management

Token-emission policy

Input tokens18,240 Output tokens2,960

Destination AI model endpoints Azure OpenAIAnthropic On the organisation’s own keys

Usage record

user_login: ahmed-dev
agent: security.md
input_tokens: 18,240
output_tokens: 2,960
measured: At request time

Request sent: The agent sends its request through the managed gateway.

Illustrative request. Token counts, user and agent names are demonstration values.

Step 4 of 7 · Path B

Tokens become cost per user

Token counts measure consumption. Prices turn that consumption into money. Input and output tokens are priced separately, per million tokens.

Documented formula

Copilot credits from Path A are not part of this formula. They are tracked against the pooled allowance.

Illustrative values — not live provider pricing.

Input cost 2,400,000 × $1.50 ÷ 1,000,000 $3.60

Output cost 400,000 × $6.00 ÷ 1,000,000 $2.40

Total cost (USD) $6.00

The default token counts match the example usage for ahmed-dev in Steps 5 and 6. Those steps use the prices you set here.

Step 5 of 7

`user_login` joins everything together

Both collectors land on the same identity. Copilot credits arrive from the daily snapshot, and token usage arrives from the gateway at request time. With one join key, spend can roll up per developer, team and repository.

Daily aggregation for Copilot credits.
Request-time measurement for Custom Agent tokens.
Credits and USD stay separate in every rollup.

Attribution depends on the identity and event data being available and consistent across sources. This demonstration is not connected to an identity provider or repository.

Copilot credits · daily 1,450 credits

Agent tokens · request time 2.4M in · 400K out · $6.00

user_login = ahmed-dev

Team Platform

Repositories payments-api · shared-libs

Roll up by

Illustrative consumption rolled up by developer
Developer	Copilot credits	Input tokens	Output tokens	Token cost

Illustrative data. Token cost uses the prices from Step 4. Credits and USD are shown side by side and never added together.

Step 6 of 7

Consumption meets delivery

The design combines three datasets on user_login: what was delivered, which agent was involved, and what it consumed. Dashboards can then show AI spend next to delivery.

Delivery is tracked. Organisation webhooks capture push and pull_request events in real time, with no extra work for developers.
Agents are attributed. Commit messages name the agent used, for example [Agent: security.md].
Efficiency is guided. Instead of rigid quotas, dashboards reveal high-performing agents and guide teams towards cost-effective prompting.

Three datasets, one join

Delivery

Organisation webhooks
push and pull_request events
Delivery metrics: PR throughput, accepted lines

Agent attribution

Commit message identifying the agent
fix: validate payment payloads [Agent: security.md]
Agent-to-change association

Consumption

Copilot credits, aggregated daily
External token costs, measured at request time
Consumption per user_login

Select “Join the datasets” to combine them for analysis.

Step 7 of 7

The model at a glance

Two billing models, measured separately, joined on one identity and reported alongside delivery.

Book an Appointment Back to the landing page

Copilot credits are collected by a scheduled daily process. The process reads ai_credits_used from the Enterprise Metrics API report and stores snapshots.
External LLM tokens are measured in-path at the managed gateway. The token-emission policy in Azure API Management records input and output tokens at request time.
Usage is associated with user identity. user_login joins both collectors and enables rollups per developer, team and repository.
Consumption can be combined with delivery information. Webhook events and agent-tagged commits connect spend to PR throughput and accepted lines.
Dashboards support cost visibility and informed optimisation. They guide prompting and licence decisions rather than relying on rigid quotas.

About this walkthrough. This is a local, interactive demonstration of the supplied architecture, using illustrative values. It does not access billing, identity or repository data. The design review also refers to gateway enforcement and to quotas where the cost is paid directly. Enforcement is not demonstrated here.

How the Token Management design measures AI consumption and cost.