Copilot Studio Credits: Estimate, Cap and Avoid Surprises
How Copilot Studio credits are billed in October 2026: the rate table, a tested calculator, the enforcement rules, and the controls that stop a prototype from becoming a bill.
By Ajith Joseph · · Updated · 14 min read · intermediate
#copilot-studio #cost-optimization #governance #copilot-credits
Copilot Studio billing used to be about published agents answering messages. In 2026 it also covers the work of building them, and the difference catches teams out.
For agents on the standard harness, credits are consumed when the agent runs. For agents on the GitHub Copilot harness, Microsoft's documentation says billing "starts when you start building": previewing, testing and generating evaluations all consume credits, before anything is published. An environment used only for exploration can run up usage without a single user.
This post sets out how credits are billed as of 1 October 2026, builds a calculator and checks it against Microsoft's own worked examples, and covers the enforcement rules and the controls that keep spend inside a boundary. Everything is from Microsoft Learn pages updated in August and September 2026, and each is listed with its date at the end.
One deliberate omission: I am not quoting a price per credit. I could not retrieve Microsoft's current price sheet, and prices are exactly the kind of number that is wrong in a blog post six weeks later. Convert credits to money with the price in your agreement or Microsoft's licensing guide.
The Currency
Copilot Credits are the common unit across Copilot Studio. Since 1 September 2025 they replaced messages as the currency for agents, with no change to the quantity in a prepaid pack or to the pay-as-you-go rate. You can get them three ways:
- Pay-as-you-go, billed monthly to an Azure subscription through a billing policy linked to an environment
- Prepaid capacity packs, a tenant-wide pool
- A one-year prepurchase plan, a pool of Copilot Credit Commit Units usable across eligible Microsoft products
Prepaid capacity is enforced monthly, and unused credits do not carry over to the next month.
The Rate Table (Standard Harness)
These are the billing rates for agents on the standard harness. They apply to Microsoft's language models and exclude bring-your-own-model setups such as Azure Foundry models, which are billed separately.
| Agent feature | Rate |
|---|---|
| Classic answer | 1 credit |
| Generative answer | 2 credits |
| Agent action | 5 credits |
| Tenant graph grounding for messages | 10 credits |
| Agent flow actions | 13 credits per 100 actions |
| Text and generative AI tools, basic | 1 credit per 10 responses (0.1 per 1K tokens) |
| Text and generative AI tools, standard | 15 credits per 10 responses (1.5 per 1K tokens) |
| Text and generative AI tools, premium | 100 credits per 10 responses (10 per 1K tokens) |
| Content processing | 8 credits per page |
| Voice, classic | 10 credits per minute |
| Voice, GenAI | 35 credits per minute |
| Voice, premium GenAI | 75 credits per minute |
An interaction can use several of these at once. Microsoft's example: an agent grounded in the tenant graph could use 12 credits to answer one complex prompt, 10 for grounding and 2 for the generative answer.
Reasoning Models Cost Two Meters
When an agent uses a reasoning-capable model, Copilot Studio bills the normal feature rate plus the "text and generative AI tools (premium)" meter, at 10 credits per 1,000 tokens. A generative answer that uses a reasoning model is therefore 2 credits plus 10 per thousand tokens, not just 2. A 3,000-token reasoning answer is 32 credits. This is the single easiest place to underestimate.
Who Pays: Microsoft 365 Copilot Licences
For employee-facing use, a Microsoft 365 Copilot licensed user using an agent inside Microsoft 365 (Copilot Chat, Teams, SharePoint) is "no charge" for the rows in the table, subject to fair usage limits. The exceptions are the ones that surprise people:
- Computer-using agent actions are not included
- Agent flows are free only when started by the "When an agent calls the flow" trigger; other triggers consume credits at the normal rate
- Agents on the GitHub Copilot harness are not covered by a user's Microsoft 365 Copilot licence, according to the governance guidance
A Calculator You Can Check
Microsoft publishes three worked billing examples, which makes the rate table testable. Here is a small calculator built from the rates, followed by the test that reproduces all three of Microsoft's answers.
// Copilot Credit estimator for agents on the STANDARD harness.
// Rates are from Microsoft Learn, "Billing rates and management" (page updated 2026-09-14).
// They do not cover bring-your-own-model (for example Azure Foundry) usage or the GitHub Copilot
// harness, which has its own usage-based billing. Treat the output as a planning estimate.
export const RATES = {
classicAnswer: 1,
generativeAnswer: 2,
agentAction: 5, // also the rate for computer-using agent actions
tenantGraphGrounding: 10,
flowActionPer100: 13,
aiToolResponse: { basic: 1 / 10, standard: 15 / 10, premium: 100 / 10 }, // per response (docs list per 10)
contentProcessingPage: 8,
voicePerMinute: { classic: 10, genAI: 35, premiumGenAI: 75 }, // core agent activity is included
reasoningPer1KTokens: 10, // "text and generative AI tools (premium)", added on top of the feature rate
};
const ZERO = {
classic: 0, generative: 0, graphGrounded: 0, agentActions: 0, computerUseActions: 0,
flowActions: 0, flowActionsOtherTrigger: 0, content: 0, reasoningTokens: 0,
tools: { basic: 0, standard: 0, premium: 0 }, voiceMinutes: { classic: 0, genAI: 0, premiumGenAI: 0 },
};
/**
* Credits for one interaction (or any batch of usage).
*
* `licensed` = the user holds a Microsoft 365 Copilot license and the agent runs as that user inside
* Microsoft 365 (Copilot Chat, Teams, SharePoint). Those rows are "No charge" in the docs, subject to fair
* usage. Not included: computer-using agent actions, voice, and agent flows that were not started by the
* "When an agent calls the flow" trigger.
*/
export function creditsFor(partial, { licensed = false } = {}) {
const u = { ...ZERO, ...partial, tools: { ...ZERO.tools, ...partial.tools }, voiceMinutes: { ...ZERO.voiceMinutes, ...partial.voiceMinutes } };
const free = licensed ? 0 : 1;
const lines = {
classic: u.classic * RATES.classicAnswer * free,
generative: u.generative * RATES.generativeAnswer * free,
graphGrounded: u.graphGrounded * RATES.tenantGraphGrounding * free,
agentActions: u.agentActions * RATES.agentAction * free,
computerUse: u.computerUseActions * RATES.agentAction, // never zero-rated
flows: u.flowActions * (RATES.flowActionPer100 / 100) * free + u.flowActionsOtherTrigger * (RATES.flowActionPer100 / 100),
tools: (u.tools.basic * RATES.aiToolResponse.basic + u.tools.standard * RATES.aiToolResponse.standard + u.tools.premium * RATES.aiToolResponse.premium) * free,
content: u.content * RATES.contentProcessingPage * free,
reasoning: (u.reasoningTokens / 1000) * RATES.reasoningPer1KTokens * free,
voice: u.voiceMinutes.classic * RATES.voicePerMinute.classic + u.voiceMinutes.genAI * RATES.voicePerMinute.genAI + u.voiceMinutes.premiumGenAI * RATES.voicePerMinute.premiumGenAI,
};
const total = Object.values(lines).reduce((a, b) => a + b, 0);
return { total, lines };
}
/** Credits for a day, month or any period: per-interaction usage times how many users of each kind. */
export function periodCredits(perInteraction, { unlicensedUsers = 0, licensedUsers = 0, interactionsPerUser = 1 }) {
const unlicensed = creditsFor(perInteraction).total * unlicensedUsers * interactionsPerUser;
const licensed = creditsFor(perInteraction, { licensed: true }).total * licensedUsers * interactionsPerUser;
return unlicensed + licensed;
}
/** Add the buffer Microsoft recommends (10 to 20 percent) to an estimate. */
export const withBuffer = (credits, percent = 20) => Math.ceil(credits * (1 + percent / 100));
/**
* Standard-harness overage enforcement starts at 125 percent of prepaid capacity.
* Returns the credits at which agents would be disabled, and how far current use is from it.
*/
export function enforcementHeadroom(prepaidCredits, usedCredits) {
const limit = prepaidCredits * 1.25;
return { limit, remaining: Math.max(0, limit - usedCredits), enforced: usedCredits >= limit };
}
The check runs Microsoft's examples exactly:
- Customer support agent. Four classic and two generative answers per customer, 900 customers a day:
[(4x1)+(2x2)] x 900 = 7,200credits. The calculator returns 7,200. - Sales performance agent. Four generative answers and four tenant-graph messages per run, with 50 licensed and 100 unlicensed users. Licensed use is free, so only the 100 are billed:
[(4x2)+(4x10)] x 100 = 4,800. The calculator returns 4,800. - Order processing agent. Four agent actions:
4x5 = 20. The calculator returns 20.
It also checks the 12-credit prompt, the reasoning surcharge (32 credits for a 3,000-token answer), agent flows at 13 per 100 actions, each AI tool tier, content processing, voice, the Microsoft 365 exceptions above, and the buffer and enforcement helpers.
import assert from 'node:assert/strict';
import { creditsFor, enforcementHeadroom, periodCredits, withBuffer } from './credits.mjs';
const close = (a, b) => assert.ok(Math.abs(a - b) < 1e-9, `${a} !== ${b}`);
// Microsoft's three worked billing examples (Learn: "Billing rates and management").
// Customer support agent: 4 classic + 2 generative answers per customer, 900 customers a day = 7,200.
assert.equal(periodCredits({ classic: 4, generative: 2 }, { unlicensedUsers: 900 }), 7200);
// Sales performance agent: 4 generative answers + 4 tenant-graph messages, 50 Microsoft 365 Copilot licensed
// users and 100 unlicensed users. Licensed use is "No charge", so only the 100 are billed = 4,800.
assert.equal(periodCredits({ generative: 4, graphGrounded: 4 }, { licensedUsers: 50, unlicensedUsers: 100 }), 4800);
// Order processing agent: 4 agent actions = 20.
assert.equal(creditsFor({ agentActions: 4 }).total, 20);
// "12 credits for a single complex prompt": 10 tenant graph grounding + 2 generative answer.
assert.equal(creditsFor({ graphGrounded: 1, generative: 1 }).total, 12);
// Reasoning model: feature rate plus 10 credits per 1,000 tokens. A generative answer using 3,000 tokens = 2 + 30.
close(creditsFor({ generative: 1, reasoningTokens: 3000 }).total, 32);
// Agent flows are 13 credits per 100 actions; 250 actions = 32.5.
close(creditsFor({ flowActions: 250 }).total, 32.5);
// AI tool tiers: 25 standard responses at 15 credits per 10 = 37.5; premium 10 responses = 100; basic 10 = 1.
close(creditsFor({ tools: { standard: 25 } }).total, 37.5);
close(creditsFor({ tools: { premium: 10 } }).total, 100);
close(creditsFor({ tools: { basic: 10 } }).total, 1);
// Content processing is 8 credits a page; voice is per minute on top of core activity.
assert.equal(creditsFor({ content: 12 }).total, 96);
assert.equal(creditsFor({ voiceMinutes: { genAI: 3 } }).total, 105);
// What a Microsoft 365 Copilot license does NOT cover: computer-using agent actions and agent flows
// that were not started by the "When an agent calls the flow" trigger.
assert.equal(creditsFor({ generative: 3, agentActions: 2, computerUseActions: 4 }, { licensed: true }).total, 20);
close(creditsFor({ flowActionsOtherTrigger: 100 }, { licensed: true }).total, 13);
assert.equal(creditsFor({ flowActions: 100 }, { licensed: true }).total, 0);
// Buffer and enforcement.
assert.equal(withBuffer(10000, 20), 12000);
assert.equal(withBuffer(10000, 10), 11000);
assert.deepEqual(enforcementHeadroom(10000, 12000), { limit: 12500, remaining: 500, enforced: false });
assert.equal(enforcementHeadroom(10000, 12500).enforced, true);
console.log('credits: all checks passed (including Microsoft\'s three worked examples)');
// A worked scenario used in the article.
const perConversation = { classic: 3, generative: 2, agentActions: 1, flowActions: 20 };
const perConv = creditsFor(perConversation).total;
const month = periodCredits(perConversation, { unlicensedUsers: 4000, interactionsPerUser: 1 });
console.log(`scenario: ${perConv} credits per conversation, ${month} credits for 4,000 conversations, ${withBuffer(month, 20)} with a 20% buffer`);
An Illustrative Scenario
Assume an agent where a typical conversation has three classic answers, two generative answers, one agent action and a 20-action agent flow. These numbers are invented to show the method, not measured:
- Per conversation: 3 + 4 + 5 + 2.6 = 14.6 credits
- 4,000 conversations a month: 58,400 credits
- With a 20% buffer (the top of Microsoft's recommended 10 to 20% range): 70,080 credits
The agent usage estimator Microsoft provides for Copilot Studio and Dynamics 365 agents does this with more configuration options, produces a PDF for procurement, and is the better tool for the official number. Its own guidance is to base volumes on the last three to six months of real data, test low, medium and high scenarios, add a 10 to 20% buffer, and never treat the output as a quote. The reason to understand the arithmetic yourself is that when the estimate and the bill disagree, you can tell which assumption was wrong.
What Happens When Capacity Runs Out
Enforcement is where a cost question becomes an availability question.
Standard harness, prepaid capacity. Enforcement starts at 125% of prepaid capacity. Custom agents are then disabled. A disabled agent does not interrupt a conversation already in progress, but later attempts to use it are rejected until capacity is increased or reset. Users see messages such as "There is a billing issue" or "This agent is currently unavailable. It has reached its usage limit." The tenant administrator gets an email and a notice in the Power Platform admin center.
Agent flows are treated separately. When prepaid capacity is exhausted, new agent flow runs are blocked rather than the agent being disabled. Runs already in progress finish, and the agent still answers non-flow questions. Test runs in the designer are not blocked.
GitHub Copilot harness. When an environment has no allocated credits, or has used all of them, anything needing credits stops. End users get no responses, and makers cannot author in natural language, preview and test, or generate evaluations. Microsoft allows some overage, described as similar to a grace period. The difference worth noticing is scope: the stop applies to building, previewing and evaluating as well as to end users.
Pay-as-you-go changes the picture. With an environment linked to an Azure billing plan, overage is billed rather than blocked, so enforcement does not apply. That is continuity, not control: Microsoft's guidance is explicit that Azure budgets and alerts "notify administrators but don't stop Copilot Studio consumption."
The Control Layers
Microsoft's governance guidance for GitHub Copilot harness agents describes four layers, and they apply equally well to a mixed estate:
| Layer | What it controls |
|---|---|
| Tenant | Purchased and available capacity, and who may allocate it |
| Environment | Prepaid allocation, whether it draws from unallocated tenant capacity, pay-as-you-go |
| Agent | A monthly limit, a notification threshold and a hard stop |
| Process | A cost owner, alert triage and exception approval |
Four practical points from that guidance are worth acting on:
Govern the environment, not just the agent. Consumption starts at design time. Developer and trial environments moved to usage-based billing on 1 September 2026, so an old sandbox full of GitHub Copilot harness experiments can now consume credits. Review them.
To contain prepaid spend, allocate a fixed amount and turn off "Draw from the available capacity in my tenant". Otherwise an environment can keep drawing on the shared pool.
Agent-level limits do not cap an environment. A monthly limit protects one use case. It does not bound the environment's total, so use it alongside the allocation, not instead of it. You set these under Licensing > Copilot Studio > Manage Agents in the Power Platform admin center.
There is no tenant-wide default agent limit. If your organisation wants every new agent to start with a development limit, you need a recurring process to apply it, using the Power Platform inventory and allocation APIs.
One setting deserves a warning of its own. The tenant's add-on capacity assignment setting controls who can allocate credits, and allowing environment administrators to manage allocations gives them control across every environment in the tenant, not only the ones they administer. Keep it restricted to tenant administrators unless that reach is intentional.
Finding Your GitHub Copilot Harness Estate
You cannot govern what you cannot list. The Power Platform inventory exposes a properties.harness field on Copilot Studio agents, and Microsoft's guidance is to filter on the value GitHub Copilot and project the agent name, display name, environment ID, owner ID and harness. Follow the skip token on every response, because one page may not contain every match. Microsoft also provides a sample query that counts agents by harness for a quick overview.
A Checklist
- Classify every environment as exploration, test and validation, or funded production, and give each an owner
- For exploration environments, allocate a fixed amount and turn off tenant draw
- Set an agent-level monthly limit on every exploration and prototype agent
- Decide per environment whether pay-as-you-go continuity is worth losing the hard stop
- Restrict the add-on capacity assignment setting to tenant administrators
- Estimate with the usage estimator, add a 10 to 20% buffer, then compare against real consumption monthly
- Account for reasoning models and the premium meter before you pick one
- Remember that computer use, non-agent-triggered agent flows and GitHub Copilot harness agents are not covered by a Microsoft 365 Copilot licence
- Alert on approaching limits, not on the stop
Sources
- Billing rates and management, Microsoft Learn, updated 14 September 2026
- Standard harness licensing, Microsoft Learn, updated 3 August 2026
- Agent usage estimator, Microsoft Learn, updated 14 September 2026
- Overview of usage-based billing (GitHub Copilot harness), Microsoft Learn, updated 28 September 2026
- Enforcement policy for agents consuming Copilot Credits, Microsoft Learn
- Govern Copilot Credit consumption for GitHub Copilot harness agents, Microsoft Learn, updated 18 September 2026