Who Decided Your Intern Gets the Michelin Grade Model?
Every enterprise running embedded AI already has a model-allocation policy. The vendor wrote it.
No interns were harmed in this writing.
Every corporate travel policy answers one question: who flies business class.
Directors up front, everyone else in row 34, and a whole apparatus of grade levels and trip-length exceptions to keep the peace in the Enterprise.
Companies fight about this policy precisely because it’s visible. Everyone can read it, everyone knows which seat they got, and the CFO can pull a report showing exactly what the premium cabin cost last quarter.
Enterprise AI is now re-running that exact fight, with one difference. A big difference.
The airline writes the policy, and the ticket doesn’t show the fare class.
AI models come in tiers the way seats do — there’s a McDonald’s tier and a Michelin tier, and the price gap between them runs 10x to 40x per token depending on the vendor.
Somebody at every company decides which workflows get frontier reasoning and which get the cheap, fast model.
If the AI arrived embedded inside Microsoft, Salesforce, or Workday, that somebody isn’t the CIO.
We are going to label them as “Embedder“ in this article. It’s the people who set the vendor’s prices.
And no embedder will tell the buyer which capability tier a given workflow got.
ELI5: What’s a token?
A token is the metering unit of AI — roughly three-quarters of a word. Every AI model reads and writes tokens, and the labs price them like electricity: so many dollars per million consumed. Cheap models and frontier models burn the same units at wildly different rates. Tokens are CPU cycles that acquired a marketing department.
The policy you’re already operating under
Walk through what the big embedders sell, using their own published numbers.
Microsoft Copilot Studio sells Copilot Credits: $200 per tenant per month buys 25,000 of them, or pay-as-you-go at $0.01 per credit.
ELI5: What’s a “credit”?
A credit is a currency the vendor invented. You buy a pile up front, and every action your AI takes spends some — a few here, ten there. The vendor decides how many credits each task costs, and only the vendor knows how many real tokens a credit actually buys. Think of an arcade: you change dollars for tokens at the door, the machines only take tokens, and nobody posts the exchange rate.
Actions have rates — a classic answer costs 1 credit, a generative answer 2, an agent action 5, grounding a response in the tenant’s own data 10.
Reasonable enough.
The interesting rates are the ones underneath. When an AI tool runs, basic model responses cost 0.1 credits per 1,000 tokens, standard costs 1.5, and premium reasoning costs 10 — billed on top of the action rate.
That’s a 100x internal spread between the cheapest and priciest tier, and nowhere in the billing does Microsoft map those tiers to named models or tell the buyer which one handled a given request.
Meanwhile M365 Copilot sits next to all this at a flat $30 per user per month — a completely different pricing universe inside the same product family.
Salesforce Agentforce runs on i: $500 per 100,000, where one standard agent action burns 20 credits — 10 cents an action, 15 if it’s voice.
The earlier $2.00-per-conversation model was retired.
Unused credits don’t roll over, overages bill in arrears, and the credit model and the old conversation model can’t coexist in one org.
Workday’s Illuminate agents also run on credits — also called “Flex Credits,” which is a different currency from Salesforce’s Flex Credits with a different undisclosed exchange rate, a naming collision I’d find funny if procurement teams didn’t have to untangle it.
Workday grants complimentary credits scaled to organization size but publishes no per-credit dollar figure at all.
I find the absence very interesting.
3 vendors, 3 private currencies.
Each one minted by the vendor, spendable only in the vendor’s store, with an exchange rate to the underlying token that only the vendor can see.
When Salesforce says the credit gives buyers “one unit of measurement across use cases” and Workday markets its credits as transparent with no hidden fees, both are telling the truth about the arithmetic and staying silent on the thing that matters: a currency you can count is not a cost you can see.
The credit’s whole job is to sit between the buyer and the model so that routing — which tier serves which request — belongs to the vendor.
Routing is the margin lever.
If Microsoft serves a request with the 0.1-credit basic tier and the buyer’s workload would have been billed the same either way, the difference is Microsoft’s to keep.
I’m not claiming they do this systematically — I have no evidence either way, which is precisely the problem.
The buyer can’t audit what they can’t see.
The receipt, side by side
One company breaks the pattern.
Oracle lets the buyer explicitly pick the model tier per use case. By Oracle’s published rate card and partner analyses, basic and open-weight model actions cost zero AI Units; premium models run about 5 units per query — roughly a nickel a query — with 20,000 free units a month and expansion packs at $1,000 per 100,000.
I’m less interested in Oracle’s exact prices than in the mechanism: a major application vendor decided the tier choice belongs to the customer and built the billing around that.
That doesn’t prove the others are hiding out of malice — Oracle may expose the tier to score a competitive point.
But it proves tier disclosure is technically possible in this product class, which shifts the burden to any vendor claiming it can’t be done.
What the labs sell instead
The model labs sit at the other pole.
Anthropic, OpenAI, and Google publish per-token rate cards down to the penny, and the buyer routes every request.
The tier spread is right there in the open: Haiku to Fable runs about 10x at Anthropic, nano to GPT-5.5 about 25x at OpenAI, and cheapest input token to priciest across all vendors runs roughly 40x.
The labs also expose the cost levers the embedders keep for themselves.
Prompt caching cuts the price of repeated context by up to about 90% on cache reads. Batch processing takes roughly half off anything that can wait a few hours.
An enterprise running its own routing gets to pull those levers.
An enterprise buying credits has to trust the vendor pulls them.
The labs hand you the dials. The embedders keep them behind the counter and bill you for the result.
The sharpest contrast, though, is in what happens when spend goes wrong.
In June, OpenAI shipped hard spend caps for enterprise workspaces — set the overage allowance to zero and the org literally cannot exceed budget — along with a Cost API for programmatic tracking.
That’s a budget the buyer manages.
Microsoft’s mechanism is different in kind: when a tenant hits 125% of prepaid credit capacity, custom agents get disabled. In-progress conversations finish; new ones are rejected until someone buys more capacity.
That’s a breaker that trips.
One vendor treats the enterprise as the account owner; the other treats it as a tenant.
A CFO who thinks of a credit pool as a SaaS subscription finds out the difference mid-quarter, when a customer-facing agent goes dark with a usage-limit message.
Nothing says “trusted enterprise partner” like a bot that hits its allowance and clocks out mid-conversation.
ELI5: What’s “routing”?
Routing is the decision, made per request, of which model answers it. Send the password-reset question to the cheap model, send the contract-analysis question to the frontier model. Whoever controls routing controls both the quality of the answer and the cost of producing it — which is why vendors are quietly reluctant to give it up.
The case for buying the credit anyway
Now let’s look at the flip side and where buying credits make sense.
A traveler wants to see their seat, but a CIO often doesn’t want to see the model — genuinely doesn’t, and that’s fair.
Which is why the fix I’ll get to is disclosure on demand — something an auditor can pull when it matters, not a fare class stamped on every request.
For most enterprises — anyone below the top tier of AI maturity — the opaque credit is arguably the correct purchase.
Buying raw tokens doesn’t just buy transparency; it hands the Enterprise a second job.
Somebody has to build and run a model router.
Somebody has to maintain evals so the router’s choices can be defended when quality complaints roll in.
Somebody has to handle fallbacks when a model is degraded, attribute spend back to business units for chargeback, and re-tune all of it every time a lab ships a new model at a new price point — roughly quarterly.
That’s a small permanent engineering team most organizations can’t staff and shouldn’t want to. Except for teams that are already building custom applications and have the needed skillsets to do so.
Companies rent cloud instead of running data centers for the same reason, and nobody calls that a scandal.
The vendors have an even stronger version of that defense, and I’d call it out plainly: nobody makes AWS name the physical CPU under a Lambda function.
You buy an abstraction — GB-seconds — and trust the SLA.
But an AWS unit never changes. A GB-second is always a GB-second, and Amazon promises that exact unit will show up.
A credit works differently. The model behind it can quietly switch to a cheaper tier from one request to the next. And the only thing the vendor guarantees is that you’ll get an answer — not how good the model that wrote it was.
So the fair ask isn’t “name the model.” It’s “disclose the tier, or hold capability-per-credit fixed. Pick one.”
So the real enemy isn’t opacity. Paying a markup to make the token someone else’s problem is a rational trade.
The real enemy is the silent downgrade: a premium action routed to a cheap model while the premium rate bills.
Picture ordering the Wagyu, being served ground chuck, and paying the Wagyu price — on a bill written so you can’t tell the difference.
And to be precise about what I’m claiming — the point isn’t that vendors do this. It’s that nothing structurally stops them.
The buyer sees credits consumed.
The buyer does not see the fare class on the ticket.
The potential fix is a contract clause. 2 provisions:
No silent tier substitution. If a workflow was sold, demoed, or priced against a given capability tier, the vendor can’t route it to a lower tier without notice.
Tier disclosure per billable unit. The invoice, or an export behind it, shows which capability tier served each billable action — not the model’s internal name if the vendor insists, just the tier.
Neither clause asks the vendor to give up routing. They can keep the abstraction, keep the operational relief, keep a reasonable markup for it.
The clauses just make the abstraction auditable — the difference between a travel agency that books whatever it wants and one that books whatever it wants and shows the fare class on the itinerary.
European procurement teams are already pushing on opaque routing in AI contracts, and I’d expect tier disclosure to be a standard ask within a couple of renewal cycles.
The unit that survives a board meeting - Cost per Accepted Outcome (CPAO)
Step back far enough and both camps are selling the wrong unit.
The labs sell a transparent token with no outcome attached. Perfectly auditable, and it tells a board nothing — no CFO can act on “we consumed 40 billion input tokens at a blended $2.10.”
The embedders sell a procurement-friendly credit with no model attached. Perfectly budgetable, and it hides the one variable that determines whether the money bought intelligence or filler.
The CIO doesn’t want a wine list of models. She wants a receipt for the business outcome.
The unit that survives a board meeting is cost per accepted outcome: dollars per resolved support case, per reconciled invoice, per claim approved — with the human-review rate attached, because an outcome a person had to redo isn’t an outcome, it’s just a draft.
10 cents per agent action tells me what Salesforce charged; it doesn’t tell me whether the action closed anything.
And once the metric is cost per accepted outcome (CPAO), routing stops being a technical detail, because whoever controls routing controls that number directly.
Route a workflow to a cheaper model: cost per outcome falls if quality holds, and rises if acceptance drops and humans redo the work.
Handing routing to a vendor means the vendor’s hand is on the enterprise’s cost-per-outcome dial — which is exactly why the disclosure clause matters even for companies that never want to run their own router.
The allocation question underneath all of this was never really “who gets the frontier model,” any more than the travel policy was really about legroom.
It’s “who’s allowed to put frontier-model spend — and frontier-model uncertainty — into a production workflow,” and that’s a management decision no vendor can make.
What I’d do Monday
Concrete moves, in order of effort:
This week. Ask the embedder rep one question in writing: which capability tier served our top 3 agent workflows last month, and where is that in the billing data?
The answer is less important than whether an answer exists.
Also find out what happens at the credit ceiling — budget alert or tripped breaker — before the quarter ends, not after.
This month. Pick the single highest-volume AI workflow and compute its cost per accepted outcome by hand. Total credits or tokens consumed, divided by outcomes a human accepted without rework.
One workflow, one spreadsheet.
Every conversation about AI spend gets sharper once that number exists.
This quarter. Get the 2 clauses — no silent tier substitution, tier disclosure per billable unit — into the next renewal draft.
Renewal is the only moment the buyer has leverage; between renewals these asks are favors.
None of this requires choosing a side in the embedder-versus-lab fight. The credit buyer with a disclosure clause and the token buyer with an outcome metric are both fine.
The enterprise in trouble is the one flying on tickets with no fare class, on a policy it never wrote, measured in a currency only the seller can convert.
Who signed off on your company’s model-allocation policy — and if the answer is “nobody,” who’s operating it right now?
References:
Microsoft Copilot Studio billing and credit rates: https://learn.microsoft.com/en-us/microsoft-copilot-studio/requirements-messages-management
Microsoft Copilot Studio pricing: https://www.microsoft.com/en-us/microsoft-365-copilot/pricing/copilot-studio
Microsoft Copilot Studio pay-as-you-go ($0.01/credit): https://azure.microsoft.com/en-us/pricing/details/copilot-studio/
Salesforce Agentforce pricing: https://www.salesforce.com/agentforce/pricing/
Salesforce Flex Credits rate card (PDF): https://www.salesforce.com/en-us/wp-content/uploads/sites/4/assets/pdf/agentforce/Flex-Credits-Rate-Card-04.21.2026.pdf
Salesforce Agentforce Flex Credits analysis (Constellation Research): https://www.constellationr.com/insights/news/salesforce-revamps-agentforce-pricing-flex-credits-what-you-need-know
Workday AI Flex Credits: https://www.workday.com/en-us/artificial-intelligence/ai-flex-credits.html
Workday Illuminate announcement: https://newsroom.workday.com/2025-09-16-Workday-Illuminate-TM-Expands-with-New-AI-Agents-for-HR,-Finance,-and-Industry
OpenAI API pricing: https://developers.openai.com/api/docs/pricing
OpenAI enterprise spend controls: https://openai.com/index/chatgpt-enterprise-spend-controls/
Google Gemini API pricing: https://ai.google.dev/gemini-api/docs/pricing
Anthropic model pricing: https://platform.claude.com/docs/en/about-claude/models/overview