Microsoft Copilot Credits: The Real Economics of Consumption Billing

For three years the unit of Microsoft Copilot was the seat. You bought a per-user licence, deployed it, and the cost was knowable on day one. That world is closing. The fastest-growing part of the Copilot estate — custom agents, autonomous workflows, and the consumptive features inside Microsoft 365 Copilot Chat — is now metered, and the meter has its own currency. It is called the Copilot Credit, and the difference between a well-run credit budget and a runaway one is the difference between a few hundred dollars a month and a five-figure surprise on the Azure invoice.

This guide is for the people who sign the agreement and own the budget: procurement leads, FinOps practitioners, IT finance, and the CIO who has to explain the AI line item. It explains what a Copilot Credit is, how the rate card actually burns, the four commercial paths to buy credits, how that spend touches your Azure commitment, and the terms to lock down before agents go into production. Every figure here is drawn from Microsoft’s published rate card and pricing pages as they stood in mid-2026; treat them as a planning baseline, not a quote, because Microsoft reprices these meters more often than it reprices seats.

The meter changed: messages became credits

On 1 September 2025, Microsoft retired the per-message billing model that had governed Copilot Studio and replaced it with a single metered currency: the Copilot Credit. The change looks cosmetic and is not. Under the old model, a “message” was a roughly comparable unit no matter what the agent did. Under credits, a single interaction can consume anywhere from one credit to well over a hundred, depending entirely on how the agent is built. The currency is the same; the exchange rate now floats with architecture.

That single design decision is why “how much does a Copilot agent cost?” no longer has an answer that fits on a slide. The same platform that runs a scripted FAQ bot for a fraction of a cent per conversation runs a reasoning-heavy analyst agent for two dollars a conversation. The price did not move. The agent design did. For a buyer, this means the cost conversation has migrated out of procurement and into engineering, because the people who design the agents now set the run-rate.

Microsoft layered a second change on top: consumptive billing is spreading from Copilot Studio into the wider Copilot surface. Copilot Cowork, generally available in 2026, runs on usage-based billing through Copilot Credits and expects the meter switched on across tenants through the year. The strategic direction is unambiguous. Seats remain for the assistant in Word and Outlook; everything agentic is moving to consumption.

What a Copilot Credit actually buys

A Copilot Credit is the atomic unit Microsoft debits whenever an agent does work — answers a question, grounds on your data, calls a tool, or runs a step in a flow. The headline rate is simple: one credit costs one cent at pay-as-you-go list, or eight tenths of a cent inside a prepaid pack. The complexity is not in the price of a credit. It is in how many credits each action consumes. This is the single most important table in Copilot economics, and most budgets are built without ever seeing it.

The numbers that should stop you are the top and the bottom of that table. A scripted answer is one credit. A premium reasoning response is a hundred credits per ten calls — a hundred-fold spread inside the same product. An organisation can deploy two agents that look identical to an end user, route the same volume of questions through them, and see one bill arrive at fifty times the other purely because one was built to reason on every turn and the other was not.

Crucially, these costs stack within a single interaction. Microsoft’s own worked example is a tenant-graph-grounded agent that costs twelve credits per response: ten for the grounding and two for the generative answer. Add two tool calls and you are at twenty-two. Route that same turn through a reasoning model and you are north of a hundred and ten credits for one answer. The agent that grounds, reasons, and acts on every turn is not twice the cost of a simple bot. It is an order of magnitude more, and nothing in the builder interface warns you as you assemble it.

The four ways you pay for credits

Microsoft sells the same credit four different ways, and the path you choose changes both the unit price and the failure mode. Getting this decision wrong is the most common avoidable cost in an early Copilot rollout.

Read the economics carefully. Pay-as-you-go is the most expensive credit and the most flexible: no commitment, billed in arrears through your Azure subscription, ideal while you are still learning what an agent actually burns. The prepaid capacity pack drops the unit price by roughly a quarter — two hundred dollars buys twenty-five thousand credits at eight tenths of a cent — in exchange for a use-it-or-lose-it monthly bucket that does not carry forward. The pre-purchase plan, bought as commit units through Azure, takes another bite off the rate for an annual commitment, and it has one feature the packs lack: automatic pay-as-you-go overflow, so you do not hit a wall when you exhaust the commitment.

The right structure for most enterprises is layered, not singular. Cover your demonstrable base load with packs or a pre-purchase commitment at the lower rate, and leave pay-as-you-go enabled underneath as the overflow valve. The mistake is to buy a large commitment against a forecast you cannot yet defend — or, at the other extreme, to run everything on pay-as-you-go and pay the flexibility premium on volume you could have committed.

Who should use which path

The four purchase paths are not ranked from worst to best; each fits a different stage of maturity and a different risk appetite. The error is treating the decision as permanent. Most estates should expect to move through these paths as their usage data matures, not pick one and stay.

The throughline is sequencing. Start on pay-as-you-go and the inclusion path, gather two to three months of real consumption from the credits report, then commit only the base load you can defend — packs first, a pre-purchase commitment once the pattern is stable. The organisations that overspend are the ones that invert this: they commit hard against a forecast on day one and discover the agents burn nothing like the deck predicted.

Cost per task: from rate card to monthly bill

The rate card tells you what a unit costs. It does not tell you what an agent costs, because that depends on the credits-per-conversation each agent design implies. Translating one into the other is the work that turns a forecast from a guess into a number you can defend. The table below models five common agent archetypes at prepaid pack pricing.

Two lessons sit in that table. First, scripted volume is cheap and reasoning volume is not: the sales-assist agent handles a tenth of the customer-service agent’s conversations and costs most of what it does, because reasoning at fifty credits a turn dwarfs scripted answering at three. Second, the enterprise line is where finance teams lose control — five agents across HR, IT, service, sales, and operations land between roughly two and a half and five thousand dollars a month in credits alone, before the licensing and Azure layers beneath them. The unit to manage is not the user and not even the agent. It is the credits-per-task of each agent design, multiplied by the volume it actually serves.

Worked example: pricing one agent end to end

Abstractions hide the money. Walk a single agent through the meter and the economics become concrete. Take an external customer-service agent for a mid-market retailer — the kind of deployment that sails through a budget approval as “a chatbot” and arrives as a four-figure monthly line.

The agent answers 20,000 customer conversations a month on a public website, so none of it qualifies for M365 Copilot inclusion. A typical turn grounds on the tenant Graph to find the customer’s order, generates a natural-language answer, and calls one tool to check delivery status. On the rate card that is 10 credits for grounding, 2 for the generative answer, and 5 for the tool call — 17 credits for a single, fairly ordinary turn. If each conversation averages 1.5 turns, that is roughly 25 credits per conversation, not the “~8” a simpler design would imply.

Same agent, same traffic, same end-user experience — and a span from $320 to $28,000 a month driven entirely by four design decisions. The reasoning row is not a strawman; it is what happens when a builder enables a premium reasoning model “to improve answer quality” without anyone pricing the change. This is why a credit budget that is not tied to a documented agent design is not a budget at all. It is a hope.

The discipline the example argues for is a costed design specification per agent: the expected credits-per-turn, the volume assumption, the purchase path, and the inclusion status, signed off before the agent reaches production and re-checked whenever its design changes. That one artefact converts the hundred-fold rate spread from a lurking risk into a managed parameter.

The inclusion path most buyers miss

The single largest saving in Copilot Credits is the one Microsoft buries in the documentation: internal, employee-facing agent interactions by users who already hold a Microsoft 365 Copilot licence do not consume credits. Classic answers, generative answers, grounding, and agent actions are all included for those licensed users in business-to-employee scenarios, subject to fair-use limits. If your workforce already carries Copilot seats, an internal IT helpdesk bot, an HR policy assistant, or an onboarding agent built for them can run at zero marginal credit cost.

This is not a loophole. It is how the licensing was designed, and it inverts the usual build order. The instinct is to stand up the flashy external agent first. The economically literate move is the opposite: build every internal, staff-facing agent you can on the inclusion path, and reserve metered credits for the agents that genuinely must face customers, websites, or channels like WhatsApp, where consumption applies regardless of who is on the other end. Many organisations pay for capacity packs to serve internal use cases that were free all along.

The cost stack beneath the credits

If you budget Copilot Credits as a standalone line, you will under-forecast, because credits sit on top of a stack of other charges that arrive on different invoices. The credit figure is the visible tip. Underneath it:

• Microsoft 365 Copilot seats. The inclusion path still requires the seats: $18/user/month for the Business promotion (≤300 users, normally $21, promotional through 30 June 2026) or $30/user/month for Enterprise, billed annually — on top of the underlying M365 base plan, which itself ranges from roughly $12.50 to $57 per user per month from Business Standard up to E5. The credit conversation for a hundred-user E3-plus-Copilot estate starts near $6,600 a month, before a single credit is spent.
• Azure compute. Pay-as-you-go credits run through Azure. Agents that invoke Azure Functions, Logic Apps, or Cognitive Services generate separate Azure line items nobody budgeted when the pack was approved.
• Azure OpenAI and Foundry tokens. Custom agents calling models directly incur per-token charges on top of the credits. This is the layer most teams discover three months in, when the Azure bill arrives higher than the credit report suggested it would.
• SharePoint and content services. Document-grounding agents can pull in premium content-processing entitlements — another line that surfaces only when something stops working.

The practical consequence is that credit consumption lives in the Power Platform admin centre, while the costs beneath it live in Azure Cost Management and your M365 billing — three systems, three formats, three owners. A FinOps view that cannot stitch them together will always report the agent as cheaper than it is. When the FinOps Foundation surveyed practitioners for its 2026 State of FinOps, visibility into AI costs was the number-one reported challenge; this fragmented stack is exactly why.

Estimate your monthly credit bill

Use the estimator below to pressure-test a number before a Microsoft conversation. Enter the conversations an agent serves, the average credits each conversation burns (use the rate card above — a simple bot is two to three, a grounded generative agent ten to fifteen, a reasoning agent fifty-plus), the purchase path, and the share of traffic that falls under M365 Copilot inclusion. The point is not precision; it is to see how violently the total swings with agent design.

Run it twice — once for a scripted design and once with reasoning on every turn — and the hundred-fold spread from the rate card becomes a line in your own budget. That sensitivity is the case for designing agents deliberately and governing them centrally, which the rest of this guide turns to.

Copilot Cowork and the spreading meter

Copilot Credits began in Copilot Studio, but the meter is not staying there. Copilot Cowork — Microsoft’s agentic, multi-step task surface — reached general availability in 2026 on usage-based billing, drawing on Copilot Credits and requiring a Microsoft 365 Copilot licence, with the meter expected to switch on across tenants through the year. The direction of travel matters more than any single feature: Microsoft is establishing credits as the common consumption currency for everything agentic, while seats remain only for the in-app assistant.

For a buyer, that has two implications. First, a credit commitment sized only around today’s Copilot Studio agents will understate next year’s consumption as Cowork and other surfaces start drawing on the same pool. Second, the governance you stand up for Studio agents — caps, alerts, design review, a single cross-stack view — is the same governance Cowork will need, so building it once now pays off as the meter spreads. The worst position is to treat each new consumptive surface as a fresh, separately-managed surprise; the credits report and the admin-centre caps are tenant-wide instruments precisely so you do not have to.

The practical step is to ask your account team, in writing, which current and roadmap Copilot surfaces draw on Copilot Credits, and to size any commitment with that full surface in view rather than the one product in front of you today.

How credits decrement your Azure MACC

For enterprises carrying a Microsoft Azure Consumption Commitment, credits are not just a cost — they are a way to retire an obligation you already hold. Pay-as-you-go Copilot Credits are billed through your Azure subscription and count toward your MACC. The pre-purchase commit-unit plan likewise counts toward the commitment. In both cases, credit consumption burns down your Azure commitment the way native Azure spend does.

That cuts two ways. If you are underconsuming a MACC — and many enterprises are, having committed to an ambitious number — routing agent spend through Copilot Credits converts a promise you have already made into capability the business actually wants, at no incremental commitment. If, on the other hand, your account team is sizing a new or renewed commitment, an AI roadmap is the perfect lever to inflate it: speculative agent forecasts harden into a fixed multi-year obligation. The discipline is the same in both directions — know your committed, consumed, and remaining MACC position before any AI conversation, and commit only to consumption you can demonstrate.

When buying models direct beats credits

A Copilot Credit is, underneath, an abstraction over model tokens plus Microsoft’s orchestration and margin. That abstraction buys you real things — one invoice, Entra identity, governance, and an agent-building platform — but it is not always the cheapest way to consume a frontier model. For high-volume, well-understood workloads, calling the model API directly can be materially cheaper than routing the same work through credits.

The comparison is now easier to make on one cloud. Following Microsoft Build 2026, Anthropic’s Claude is a first-party model in Azure AI Foundry alongside OpenAI’s GPT family, billed through your Azure agreement with no separate Anthropic contract. On Foundry, a model like Claude Sonnet lists around $3 per million input tokens and $15 per million output, while a small GPT-class model can run a fraction of that — the same models are also available on AWS Bedrock, Google Vertex, and direct from the providers. Where an agent’s work is predictable and high-volume, pricing it at raw token rates and comparing against the credit equivalent often reveals that the credit path carries a convenience premium you would not pay if you modelled it.

The decision is rarely all-or-nothing. The pattern that wins is to keep low-volume, governance-sensitive, and staff-facing work on credits and the Copilot platform, while moving high-volume, latency-tolerant, cost-sensitive workloads to a direct model call where the rate transparency pays for the extra integration. Our credits versus buying direct guide works the rate comparison in detail.

The 125% cliff and other consumption shocks

Consumption billing introduces failure modes that seat licensing never had. The sharpest is the capacity-pack enforcement cliff. A prepaid pack is a fixed monthly bucket of credits pooled across every agent in the tenant. Cross 125% of that bucket and Microsoft disables agents until you top up or enable pay-as-you-go. Because the pool is shared, one department’s experimental reasoning agent can exhaust the credits that another department’s production chatbot depends on, and the failure lands on the wrong team with no warning.

The second shock is variance. Gartner forecasts that by 2027, 40% of enterprises using consumption-priced AI tooling will see unplanned costs exceeding twice their budget. That is not a story about bad luck; it is the predictable result of a hundred-fold rate spread meeting agent sprawl without a control layer. A single change — a builder switching an agent from generative to reasoning, or adding grounding to every turn — can multiply a run-rate overnight, and the bill arrives a month later.

The third is the invisible-layer shock: credits track fine in the Power Platform admin centre while Azure OpenAI token costs spike in a system nobody is watching. The defence against all three is the same: caps, alerts, and a single view across the stack, which is a governance problem more than a procurement one.

Governing credits before the first agent ships

Credit governance is not optional tooling you add after the first overrun. It is the precondition for letting agents into production. Microsoft gives you the primitives; using them is on you.

• The Copilot Credits report. Surfaces total credits used, cumulative and daily, broken down per user, per agent, per billing policy, and per agent-user pair, with alerts when a user crosses 2,000 credits. This is your meter; read it weekly, not at quarter-end.
• Per-agent caps. The Power Platform admin centre supports monthly consumption limits per agent. Set them. One team’s experiment should never be able to disable another team’s production agent by draining the shared pool — the Copilot equivalent of resource quotas.
• Design review as cost control. Because architecture is the budget, the cheapest governance is an agent-design review: route known-answer questions to scripted topics at one credit, reserve reasoning for tasks that genuinely warrant a hundred, and build internal agents on the inclusion path first.
• One cross-stack view. Credits, Azure compute, model tokens, and licences arrive separately. Whether through native cost management or a third-party FinOps tool, attribute the full stack to the owning team or business outcome, or the agent will always look cheaper than it is.

Our dedicated Copilot Credits governance guide turns these into a control framework you can stand up before go-live.

The negotiation levers that matter

Consumption pricing does not mean there is nothing to negotiate. It means the levers move from rate cards to terms. Before you route material AI spend through Microsoft, secure these in the agreement rather than on a call:

• Rate protection. Microsoft reprices meters more freely than seats. Lock the credit rate and the rate-card consumption values for your term, so a mid-term reprice cannot quietly raise your effective cost.
• Commitment sizing. Account teams will use your AI roadmap to grow your MACC and your pre-purchase commitment. Commit to demonstrable consumption, keep speculative volume in flexible tranches, and refuse to harden an unproven forecast into a multi-year obligation.
• Overflow and enforcement terms. Confirm in writing how the 125% enforcement behaves for your packs, and that pay-as-you-go overflow is enabled so production agents do not go dark on a shared-pool exhaustion.
• Discount on the pre-purchase. The commit-unit plan advertises up to ~20% off; treat that as a ceiling to negotiate against on your volume, not a fixed gift.
• Renewal protection. Lock how this term’s consumption affects your next commitment, so a strong first year does not become the baseline Microsoft prices up against.

Red flags in Copilot consumption terms

From buyer-side engagements, the language that most often costs money later:

• Forecast-driven commitments. A pre-purchase or MACC sized on a roadmap deck rather than consumption history. The forecast is the seller’s tool, not yours.
• Silent reprice rights. Terms that let Microsoft adjust credit rates or rate-card values mid-term without a corresponding cap or notice period.
• Bundled credits. Credit commitments folded into a broader EA or Azure renewal so the AI line cannot be priced or walked away from on its own. Insist on modular, separately-stated terms.
• No per-agent governance. A commitment with no contractual acknowledgement of caps, alerts, or overflow — leaving you exposed to the shared-pool failure mode.
• Auto-renewing commitments. Consumption commitments that roll over unless you give notice, with this year’s peak as next year’s floor.

A 90-day plan to control credit spend

The gap between a controlled credit budget and a runaway one is rarely a single decision. It is the absence of a sequence. The following ninety-day plan is the one we run with buyers who are about to let agents into production, and it is deliberately ordered so that the cheap, high-impact moves come first.

Days 1–30: instrument and inventory. Before changing anything, make the spend visible. Turn on the Copilot Credits report and read it weekly. Inventory every agent in the tenant and, for each, record who is on the other end (internal licensed user, internal unlicensed, or external), the design (scripted, generative, grounded, reasoning, tool-calling), and the monthly volume. This inventory is the single artefact that converts “our AI spend” from a mystery into a list of line items you can manage. Most organisations discover during this step that a handful of agents drive the overwhelming majority of the burn, and that some metered agents could have been built on the inclusion path.

Days 31–60: re-architect the expensive few. Apply the rate card to the inventory and rank agents by monthly credit cost. For the top consumers, ask the cheaper-design questions: can known-answer queries route to scripted topics at one credit instead of a generative answer at two? Is grounding firing on every turn when it is only needed on some? Is a premium reasoning model running where a standard generative answer would do? Each of these is a configuration change, not a procurement negotiation, and on a heavy agent they routinely cut the run-rate by a third or more. In parallel, rebuild any internal, staff-facing agent that is currently metered onto the inclusion path so it stops consuming credits for licensed users.

Days 61–90: cap, commit, and codify. With a clean inventory and right-sized agents, set per-agent monthly caps in the Power Platform admin centre so no single agent can drain the shared pool, and configure alerts well below the 125% enforcement threshold. Only now, with two months of real consumption data, size any prepaid commitment — cover the demonstrable base load with packs or a pre-purchase plan at the lower rate, and leave pay-as-you-go enabled as overflow. Finally, codify the rule that no new agent reaches production without a costed design specification. That governance gate is what stops the cycle repeating with the next wave of agents.

Frequently asked questions

Are Copilot Credits the same as Microsoft 365 Copilot seats?

No. A Microsoft 365 Copilot seat is a per-user licence ($18–$30/user/month) for the assistant inside Word, Excel, Teams, and Outlook. Copilot Credits are a separate, consumption-based currency for agent work in Copilot Studio, Cowork, and other agentic surfaces. The seat can zero-rate internal agent use for the licensed user, but the credit and the seat are different products with different billing.

How much does one Copilot Credit cost?

A credit is $0.01 at pay-as-you-go list, $0.008 inside a prepaid capacity pack ($200 for 25,000 credits), or roughly $0.0064 on a pre-purchase commitment advertised at up to 20% off. The cost of an interaction is the credits it consumes multiplied by that rate — and interactions range from 1 credit to well over 100.

Do Copilot Credits roll over month to month?

Prepaid capacity-pack credits do not roll over — unused credits in a monthly bucket are forfeited. Pay-as-you-go has no bucket to roll over; you pay for what you consume. The pre-purchase commit-unit plan is an annual construct with automatic pay-as-you-go overflow rather than a monthly reset.

Do Copilot Credits count toward an Azure commitment?

Yes. Pay-as-you-go Copilot Credits are billed through Azure and count toward a Microsoft Azure Consumption Commitment, and the pre-purchase plan counts as well. For organisations underconsuming a MACC, agent spend can retire commitment they have already made.

What is the 125% rule?

Prepaid capacity packs enforce at 125% of their credit bucket. Cross that threshold and Microsoft disables agents until you add capacity or enable pay-as-you-go. Because the pool is shared tenant-wide, one team’s overconsumption can take another team’s agents offline — the reason per-agent caps and a PAYG overflow safety net matter.

How do we forecast a Copilot Credits budget?

Forecast bottom-up, per agent: estimate credits-per-turn from the rate card based on the agent’s design (grounding, generation, tools, reasoning), multiply by expected volume, subtract any inclusion-eligible internal traffic, and apply your purchase-path rate. Validate against two to three months of the Copilot Credits report before committing to any pre-purchase. Forecasting top-down from a vendor deck is how budgets are doubled.