Copilot Studio vs Azure AI Foundry vs Build: What One Document Costs

A firm asked me what it would cost to generate a long technical report with AI, end to end, on Microsoft’s stack. Their documents run to a couple of hundred pages, written to a method the firm has refined over years, and that method is what clients pay for. So I spent a day pricing it properly, per document, in every place Microsoft will let you build such a thing.

One document came to $725 on Copilot Studio and about $4 calling Azure’s own model API. Both numbers are Microsoft’s, on the same tokens, on the same day. The gap is not a markup. It is the price of a bundle, and on this particular job you pay for all of the bundle and can use almost none of it.

From no code to your own code

Microsoft sells this as a spectrum, and describes it that way itself: no-code, low-code and pro-code tiers for building agents. The further down you go the more you write and the less you pay. Here is one ~200-page expert report, the same 7.2 million tokens, priced along it:

Two rungs of that spectrum are a factor of 180 apart on identical tokens. The rest of this explains why, and where the line falls — which turns out to be higher up than most people expect. A firm writing thirty or more of these a year is better off building from scratch.

The top rung fails for a reason worth knowing, because it is the one most firms try first. Agent Builder costs nothing beyond the Microsoft 365 Copilot licence you already pay for, and Microsoft’s own comparison lists its limitation plainly: it “doesn’t support complex workflows and integrations”. The harder ceiling is that a declarative agent’s instructions cap at 8,000 characters, about 1,200 words. The firm’s method — which chapters, in what order, arguing what, against which precedents — is the product, and it does not fit. Microsoft also closes the obvious workaround: you “shouldn’t store or offload declarative agent instructions in SharePoint documents (or any other knowledge source) to work around this character limit”, because knowledge-source content goes through the cross-prompt-injection classifiers.

Copilot Studio’s cheaper model tiers are absent from the table for a different reason: they run non-reasoning models, and this job needs reasoning at every step. So is its bring-your-own-model route, which Microsoft blocks for GPT-5 and later.

Two hundred pages, written to a recipe

Take an environmental statement, the document a planning consultancy produces at the end of an Environmental Impact Assessment. I counted a real one instead of guessing. The A19 Downhill Lane Junction Improvement environmental statement, submitted by Highways England in January 2019, runs to 236 pages, 15 chapters and 179,143 words in its main volume.

Ten of those chapters are the assessment itself, and they vary from 10 pages to 39, median 16:

• Air Quality, 10 · Geology and Soils, 10 · Cultural Heritage, 11
• Materials, 16 · Noise and Vibration, 16 · Road Drainage and Water, 20
• Landscape and Visual, 21 · Ecology and Nature Conservation, 25
• Cumulative Effects, 31 · People and Communities, 39

Each opens with its own executive summary, and each applies the same house method to a different discipline.

That is on the small side. The US Council on Environmental Quality measured every environmental impact statement filed from 2013 to 2018: median 447 pages, average 661, and only 7% at 150 pages or fewer. The regulations say the text “shall normally be less than 150 pages”. Almost nothing is.

The regulations fix the shape. The client buys the firm’s judgement about which impacts matter and how to argue them. That is the recipe, and the recipe is the product. Bid responses, actuarial reviews and expert witness reports sit the same way: long, regulated outside, proprietary inside, written again and again.

Now the assumptions. Anthropic publishes a conversion of roughly four characters or 0.75 words to a token, which puts 179,143 measured words near 250,000 tokens of finished document. Say each of the 15 chapters gets three passes, a draft and a critique and a revision, for 45 model calls. And say each call carries 150,000 input tokens: the house method, the chapter template, the precedent extracts and the survey data for that discipline.

That last number is the one to argue with. Input volume depends on the client and the task: how much precedent goes in front of the model, how much raw survey data a discipline generates, whether the running document is resent each time. It could be a third of what I assumed or three times it, and every figure moves with it. The shape holds either way, because the same token count is priced differently on every rung.

On those numbers: 6.75 million input tokens, half a million output, about 7.2 million tokens for one document. I am costing generation only. Fact-checking, citation verification and hallucination detection are a separate bill and a harder problem, and leaving them out flatters every option below by the same amount.

A hundred dollars a million tokens

Start at the top, because a firm already inside Microsoft 365 gets pointed there first. Copilot Studio does not bill tokens. It bills Copilot Credits, a cent each, in packs of twenty-five thousand for $200 a month.

A credit buys an interaction, and the rates look harmless until the last three rows:

The first four are small and they are not where the money goes. The money goes into the prompt tools you build a document generator out of, and those bill per thousand tokens.

Only the premium rate matters here, because every step of this job needs a reasoning model. Deciding which impacts are significant, weighing survey data against precedent, arguing a conclusion a planning inspector will read: none of that survives on a chat model. The cheaper tiers exist, and choosing one means shipping a document nobody will sign.

Ten credits per thousand tokens is ten cents per thousand tokens. That is $100 per million tokens, flat, with no distinction between the tokens you send and the tokens you get back. Nor can you dodge the tier by picking a better model, because picking a better model is what puts you in it: Microsoft bills a reasoning-capable model on two meters at once, “feature rate for the operation + text and generative AI tools (premium) for the reasoning model’s token usage”.

So 7.2 million tokens costs 72,500 credits. That is $725 a document at the pay-as-you-go rate, plus a couple of hundred credits of feature rates. Buy capacity instead, at $200 for 25,000 credits, and it is $580 a document, close to three whole packs.

Two details sharpen that. Prepaid credits pool across the tenant and do not roll over, so unused capacity dies monthly. And overage enforcement triggers at 125% of capacity, at which point “custom agents are disabled”. A run that overruns its budget does not produce a bigger invoice. It stops.

The same tokens through Azure’s own model APIs cost roughly $4 per million on input and $20 on output, which lands the document near $37. Copilot Studio charges input at five times the output rate of the model underneath it, and this workload is 94% input.

The hundred-second ceiling

Needing a reasoning model puts you at odds with the product in a second way. Microsoft’s performance guidance says to “always start with the Basic model for your scenario, then consider the Standard model, and reserve the Premium model only for tasks that truly require it”, because more advanced models take longer to respond. On the same page: “Prompt execution is limited to 100 seconds,” and long documents “might cause timeouts or exceed token limits,” with the advice to process them incrementally, page by page.

A reasoning model is the slow one, this job feeds it the largest input, and you have a hundred seconds. So you fragment the work to fit under the cap, and every extra step is another billed interaction on top of the per-token meter. The cheapest way to use Copilot Studio cannot do this job, and the way that can spends its time fighting a timeout.

What the credit buys

A hundred dollars a million is not a con. It is a bundle price, and the bundle holds things that cost real money to build.

The SharePoint knowledge source answers on behalf of the signed-in user. It surfaces only content that user can already open, retrieves at query time instead of copying documents into a vector store, and respects sensitivity labels. For a consultancy whose precedent library is client-confidential and unevenly permissioned, that is the hard part of the system. A bespoke build owes per-user security trimming from scratch, and getting it wrong means a junior reading a chapter grounded in a deal they are walled off from.

Underneath sits Power Platform governance: data loss prevention on by default, connectors sorted into business, non-business and blocked, and an admin centre IT already knows. Above it sits the thing that sells the product: a domain expert edits the method in a designer, without a developer, on the afternoon they decide the noise chapter needs reordering.

The free tier is not a pipeline

Microsoft’s rate table has a second column headed “Used by Microsoft 365 Copilot licensed user”, and every rate in it reads No charge — premium AI tools included. The conditions are specific: the scenario is employee-facing, the person holds a Microsoft 365 Copilot licence, the agent runs under their identity, and usage stays inside fair use limits.

So an author who opens the agent and asks it for the ecology chapter pays no credits. That is genuinely useful, and it is not what we are costing. Fifteen chapters at three passes is 45 slow reasoning calls: a person triggering those by hand is a writing assistant with an operator, not a pipeline. Put it on a schedule or behind a request page and every call bills in full, because autonomous triggers consume credits and agent flows are exempt only when fired by the “When an agent calls the flow” trigger from a licensed user.

That is credit-free, not cost-free. Microsoft 365 Copilot Business is £16.10 a user a month on an annual commitment, or £19.32 month to month, and it is an add-on: each user also needs a qualifying Microsoft 365 plan underneath. Bought together that runs £18.10 a user a month for Business Standard with Copilot, £24.60 for Business Premium. Anyone who wants to talk to the agent needs a licence, so ten authors is £1,932 a year before a document exists.

Credits scale with documents and licences scale with people, so the two costs answer different questions. A pipeline pays credits. A room full of people asking an agent questions pays licences. Build a pipeline and you pay credits whatever your licence count, because the automation is exactly what the exemption excludes.

Which tells you what Microsoft built. The pricing rewards a human in the loop and charges for the automation, and a repeatable document pipeline is automation by definition.

What you cannot buy at any price

There looks to be a way out. Copilot Studio’s rates “exclude bring-your-own-model configurations, including Azure Foundry models, which are billed separately”, and wiring in your own model makes the platform “consider it an agent action”, five credits, with “no extra Copilot Credits charged for the processing”. Point a prompt at a model in your own subscription and you pay a nickel a call plus token rates, a fiftieth of the managed price.

It does not work for any model you would want. The documentation carries a heading reading “GPT-5 and later models aren’t supported”, and under it: “The GPT-5 family and later models (such as GPT-5, GPT-5 mini, GPT-5 nano, and the GPT-5.x versions) aren’t currently supported for bring your own model in prompts.” You can connect GPT-4.5, Llama, DeepSeek and the older, open-weight end of the catalogue. Today’s frontier models are available everywhere in Azure except inside Copilot Studio.

The managed list is older than the catalogue too. Prompt tools run on their own model list: the default is GPT-4.1 mini, trained to June 2024, at the basic rate, and the premium reasoning tier tops out at GPT-5.2 reasoning, trained to October 2024. As of 27 September 2026, Azure sells GPT-5.4, 5.5 and 5.6 directly. A prompt tool cannot have them.

The agent’s own orchestration model is newer and does not reason. GPT-5.5 Chat is the default in every region, while GPT-5.5 Reasoning, GPT-5.4 Reasoning and GPT-5.3 Chat exist only as experimental models in United States early-access environments.

For a UK firm handling client material the table tightens again. GPT-5 Reasoning is preview and marked cross-geo in the United Kingdom, meaning it may process data outside the region, and so is every Claude model on the list. The models generally available in the UK without crossing a border are GPT-4.1, GPT-5 Chat and GPT-5.5 Chat, and none of them reasons. A regulated buyer who picks Copilot Studio is choosing between reasoning and data residency, and owes their DPO that conversation before the pilot.

Foundry Agent Service, where you own the loop

Down a rung. Foundry Agent Service charges no agent fee: the cost model is “per-call inference + tool usage” for a prompt agent, and the same plus container compute for a hosted one. No per-thread charge, no per-run charge, no markup on tokens. Our document lands near $37.

You still get a lot per agent: its own Microsoft Entra identity, RBAC, virtual-network isolation, content filters against cross-prompt injection, tracing into Application Insights, version snapshots you can roll back, and publishing into Teams and the Entra Agent Registry.

You lose the workflow. Nobody hands you a designer, the domain expert goes back to filing tickets, and you bring your own Azure AI Search, Cosmos DB and Application Insights, each with a monthly bill that runs whether you write a document or not.

Those floors are why a per-document figure misleads at low volume. Ten documents a month divides the floor by ten. A thousand divides it by a thousand.

The model API, where you are already building it

Down again, and there is not much platform left. Calling Foundry’s model endpoints gives you hosting, quota, data residency, content filtering and Entra authentication. Everything else is yours: orchestration, state, retrieval, identity passthrough, the review interface. The cheapest Azure option is building it yourself, with Microsoft as the model vendor.

It is also where the cost levers finally exist. Global batch runs asynchronous jobs “at 50% less cost than global standard” with a twenty-four-hour target, and overnight document generation is exactly that workload. Prompt caching drops repeated input to a fraction of base price, but only if you assemble the prompt so the first 120,000 tokens are byte-identical every time, which you can do here and cannot do inside a managed prompt agent.

Engineer both and the document lands near $4 or $5, against $37 for the same calls made naively. Most of it comes from the cache: hold 120,000 of the 150,000 input tokens still and the input bill falls by roughly three quarters before batching halves what is left.

One caveat before you pick a model vendor on this rung. Azure OpenAI has global batch. Claude on Foundry has no Message Batches API, so that 50% is unavailable on the Anthropic models, on the same platform.

Running the card yourself

The bottom rung is owning the GPU, and it is the one rung where renting wins. We measured it: one H100 at $3.49 an hour serving Qwen3.8-27B, SGLang at fifty concurrent requests, works out at $0.56 per million output tokens if the card holds that load all day and $2.81 if it is busy a fifth of the day. The cheapest API host for the same model charged $1.80 per million in September 2026 (Winder.AI). The card has to stay busy about a third of the day before owning beats renting.

A firm writing ten long documents a month will not come close, so it should rent. The same arithmetic that says build the application says rent the inference.

The bundle, and how much of it you use

Building inside the platform is not free labour either, though it is far less of it. A Copilot Studio agent for work like this is a week or so of building, plus a monthly retainer for support and small changes. Against a bespoke prototype it is roughly a quarter of the engineering, and that is the platform’s strongest argument.

Every step down that table is cheaper because it does less, and none of the rows is mispriced. The trap is that each row sells its capabilities at a single price. Copilot Studio bundles six things this job could use:

1. Security-trimmed retrieval over SharePoint
2. Data loss prevention through the Power Platform admin centre
3. A designer a non-engineer can edit
4. Distribution into Teams and Microsoft 365
5. A managed runtime
6. The model itself

Need the first three and the bundle is worth having, at whatever the credit rate comes to. Need one of them and you are buying the other five anyway.

Where the line falls

Here is the arithmetic with our own numbers on both sides. Each figure is the build plus three years of support and maintenance, at our standard rates, rounded:

Around all three sits the same consulting, and it is the larger part of the calendar: the workshop, writing the firm’s method down, the demos, the data-feed licensing. On a Copilot Studio engagement that wrapper stretches a week or so of building across about two months. It is the same work whichever rung you pick, so it cancels out of the comparison and I have left it out of the table.

The distance between those two is the real variable, and it has nothing to do with rates. It is how finished the thing has to be before anyone outside the team touches it.

Now the thresholds, reckoning £1 to $1.27 and comparing three-year totals:

Under thirty documents a year is a low bar. Two partners running diligence clear it, and so does a planning consultancy with a handful of live schemes. That is what needing reasoning on every step does: the combination Copilot Studio prices hardest is the only one that does the work. Push the build up to a production service and the bar rises to about 115 a year, which is where most firms are genuinely better off buying.

Three years flatters the build, and I should say so. Model prices have fallen over every window so far, and that helps a platform build exactly as much. The cost of maintaining software you own has never fallen.

One thing no rung saves you. Somebody has to encode the recipe — which chapters, in what order, arguing what, with which precedents in front of the model — and that work is identical in a designer and in a repository. The platform saves you the runtime, not the expertise, which is the real answer to “we would have to hire engineers”.

Where I stand: we build both, bespoke AI applications for firms whose workload does not fit an off-the-shelf tool, and Helix, our own agent platform. I sell at both ends of this ladder.

So the answer I gave that firm was a count, not a price. Write down what the platform gives you and strike out the lines you would have built anyway. Then count the documents you expect to write next year. Somewhere under thirty, the spectrum stops paying you to stay at the managed end — and that is a smaller number than almost anyone expects.