This week Microsoft published its Copilot Credits Guide, and with it the clearest statement yet of how the new agentic experiences will be paid for. If you have an active proof of concept built on the new agentic build experience in Copilot Studio - the GitHub Copilot Harness - you have probably already hit the practical problem: the billing model is live, but the tooling that shows you what a run actually consumes is still rolling out tenant by tenant. We're seeing this with our own clients right now. Pilots are running, credits are being metered, and nobody can see the meter.
The short version: The new build experience consumes Copilot Credits both when you build an agent and when it runs. Consumption visibility is still arriving in many tenants, so for the next few weeks you may be flying without instruments. Don't stop the pilot. Set a cost ceiling before you can measure, estimate from Microsoft's published rates with a contingency multiplier, and re-measure the moment the Monitor tab lands in your tenant.
Current as at 4 August 2026, and our best interpretation of a billing model that is still rolling out - see the full disclaimer at the end.
What changed
Microsoft's position, stated plainly in the Credits Guide, is that agent workloads vary too much for flat licensing: "the amount of work required to complete a task can vary significantly. This variability is best served by a usage-based model that aligns cost to the work performed." Copilot Credits are the common currency for that model, pooled at tenant level and consumed across Copilot Studio, Copilot Cowork, Work IQ APIs and Business Applications.
Two parts matter for anyone mid-pilot:
- You now pay to build, not just to run. Agents built with the GitHub Copilot Harness "consume Copilot Credits during creation and runtime execution" - natural-language authoring, preview and evaluation all meter credits. Manual configuration in the Build and Monitor tabs does not. (Copilot Credits Guide)
- Runtime cost scales with complexity, driven by four factors: the models chosen, the managed runtime, the context drawn in, and the tools invoked. Microsoft's own planning ranges for harness-built agents run from roughly 100 credits for a light task to more than 500 for a heavy one - at the pay-as-you-go rate of US$0.01 per credit, or about A$0.012 at Australian prepaid pack pricing, that's roughly A$1 to A$6 and up per run.
In the tenants we work in, we're also seeing a grace period showing through to September, and the consumption reporting is landing progressively. The system will settle. The question is what you do with an active pilot in the meantime.
The assumption that just broke
Most of the pilots we see were scoped on a reasonable assumption: the organisation holds Microsoft 365 Copilot licences, and employee-facing agent usage by licensed users is largely included - the billing rates table marks classic answers, generative answers and agent actions as no charge for those users. That assumption still holds for what it covered. What it never covered is the new harness: those agents meter credits during creation and at runtime, and autonomous and external-facing scenarios meter at the standard rates regardless of who holds a licence.
So the uncomfortable question lands mid-build: we assumed this was included, we now know it's metered, and we can't yet see the meter. Should we keep building?
Flip the question from cost to value
We've argued before that "what will it cost?" is the wrong first question for AI at board level. The same logic now applies one level down, at the individual agent run. The credits model exists precisely because agent work varies - which means the useful question isn't "what does a run cost?" but "what is a run worth?" If the process you're automating returns $50 of analyst time per run, a $5 run is a rounding error and a $40 run still clears. That comparison - cost per run against value per run - is the Value pillar of GIVE applied at its smallest unit, and learning to make it is a skill your organisation will use for the next decade.
For the next few weeks, though, you need practical moves. There are three.
1. Pause deliberately, not indefinitely
The simplest option: halt the proof of concept for a short, defined window. This isn't retreat - it's waiting for instruments. The grace period we're seeing runs to September, tenant rollouts are progressing weekly, and once the Monitor tab shows consumption in your tenant you can run the agent, read the actual credits, and calculate cost per run from measurement rather than guesswork. Give it a week or two; a month at the outside. If you pause, put the re-test date in the diary before you stop.
2. Set your ceiling before you can measure
Don't wait for the measurement to have the value conversation - have it now, in reverse. Ask the business: what would we happily pay per run for this process? If the answer is $10 and the eventual measurement says $8, the pilot is a success the day the meter appears. If the ceiling is $15 and the measurement says $22, you have a clear, unemotional signal to optimise or stop. Agreeing the ceiling while the meter is dark takes the anxiety out of the reveal - the number that comes back is just data against a threshold you already own.
3. Estimate from the published rates - then double it
You don't have to wait blind. Microsoft publishes the Copilot Credits billing rates. (Microsoft also has an official agent usage estimator, but it covers the standard builder rather than the new agentic build experience, so it won't help here.) Map what your agent actually does against the meters, produce a best-endeavours estimate, then double or triple it as a contingency buffer, and take that number to the business against the ceiling from step two. If the business won't name a ceiling, lead with the estimate: "here's our best-endeavours cost per run, grounded in Microsoft's published rates - is that acceptable?"
Here's what that looks like on an agent we're building right now. It reads a large set of documents of very different sizes, extracts information from each, synthesises and links the extracted data, and delivers the result to humans as an Excel workbook. Runs vary enormously - which is exactly why it felt unestimatable until we mapped it to the meters. One distinction matters before you start: the per-page content processing meter applies only where a document processing or text recognition model handles scanned or image documents - Microsoft's AI Builder licensing page is explicit that this is the document-processing path. Digital text doesn't pay it; the model simply reads the text, and you pay the token rate for what flows through the prompt. Our corpus is digital text, so for this agent one input drives nearly all the cost - word count - and you can measure it before a run starts:
| Stage of the run | Meter | Rate | Illustrative run |
|---|---|---|---|
| Read, synthesise, consolidate, link the text | Text and generative AI tools (premium reasoning) | 10 credits per 1,000 tokens | ~150,000 words ≈ 200,000 tokens → 2,000 credits |
| Orchestration steps and the Excel output | Agent actions | 5 credits each | ~15 actions → 75 credits |
| Raw estimate | ~2,100 credits ≈ A$25 per run | ||
| With 2x contingency | ~4,200 credits ≈ A$50 per run |
Dollar figures at the Australian prepaid pack rate of about A$300 for 25,000 credits. If some of your documents are scans, add 8 credits per scanned page for the document processing model that OCRs them. Either way, the figures are illustrative and the harness bills through its cost factors rather than these meters line by line - which is what the contingency multiplier is for. But A$50 per run is a number you can take into a meeting, and it converts a vague fear ("this could cost anything") into a concrete question ("is one run of this worth $50 to us?"). For a process that replaces most of a day of skilled reading and cross-referencing, that question tends to answer itself - in either direction, which is the point.
One trap worth knowing: when an agent uses a reasoning model, Microsoft bills the feature rate plus the premium token rate for the reasoning. That double meter is the line item most estimates miss, and the main reason deep-reasoning agents surprise people.
Buying credits while you learn
Credits come in two main constructs, per the Credits Guide: pay-as-you-go at US$0.01 per credit, billed in arrears with no commitment, and a one-year Pre-Purchase Plan with tiered discounts from 5% at 300,000 credits to 20% at 300 million. In Australia, a prepaid pack of 25,000 credits currently lists at about $300 a month. Our recommendation for organisations at the pilot stage: buy one pack, treat it as your experimentation budget, and monitor consumption as you go. It's the cheapest instrument panel you can buy - and as we've said before, money spent buying certainty is not money wasted.
The discipline this teaches
The agents most organisations have built so far were optimised for one thing: getting a result. Nobody tuned them for credit efficiency, because until now nothing was metered. That changes. Credit consumption is driven by models, runtime, context and tools - all of which are design decisions - and the gap between a wasteful agent and an efficient one doing the same job will be wide. Cost-per-run optimisation is about to become a real engineering discipline in this ecosystem, and the organisations that learn it early will run more agents for the same spend.
That's the longer game. For now: don't let a dark meter stop a good pilot. Set the ceiling, build the estimate, buy a pack, and re-measure the moment your tenant lets you.
Disclaimer: everything above is current as at 4 August 2026 and represents our best interpretation of the facts as published in the Microsoft Copilot Credits Guide (August 2026) and on Microsoft Learn at the linked pages. The billing model, rates, meters, grace periods and tenant rollout described here are all subject to change - always, and in this period especially. This is not licensing or pricing advice; confirm current terms with your Microsoft account team or a Microsoft Certified Partner before making commercial decisions.