Skip to content

Insights

Your AI Agent Bill Is Unpredictable Because Your Agent Is

By Matt Fishman, Founder and CEO at Privion

Last week I caught up with a friend. His company just green-lit a rollout of both Microsoft Copilot and Claude across the whole org. Big win on paper.

He wasn't celebrating. The cost was part of it, sure. But the real weight was the governance and compliance overhead the new billing model dragged in with it. Who can use what. Which users get capped at which tier. Which department cost center eats the consumption. How you even audit a bill that moves every month.

That's the whole problem, and it's worth understanding why.

What Microsoft actually changed

On June 16, Microsoft launched Copilot Cowork, an agent that runs office tasks on its own. Drafting documents, building spreadsheets, comparing files, prepping meetings. The tool still needs a paid Microsoft 365 Copilot subscription. But now every task it runs is billed separately, based on how much compute it burns.

The unit is a Copilot Credit. Pay-as-you-go runs $0.01 per credit, or you prepay packs of 25,000 credits for $200 a month. A single agent response can eat several credits depending on how much it retrieves and does. Cowork itself runs on frontier models: Opus 4.8, Sonnet 4.6, GPT 5.5 on the top tier.

To keep the bills from running away, the service ships disabled by default. Admins cap spending per employee, per team, or per department.

Charles Lamanna, Microsoft's executive vice president for Copilot and agents, described the shift plainly to AFP. It's “like you're filling up your gas tank at the pump.” His reasoning: there's no single user license that makes sense anymore, because different users consume wildly different amounts of compute.

Microsoft moved off pure seat licensing because AI workloads vary dramatically by user and by task. That's a fair reason. Consumption pricing aligns price with compute, and when compute genuinely varies, that's the honest way to charge for it.

What consumption pricing actually exposes

Here's the part worth sitting with. Consumption pricing makes sense when compute usage genuinely varies. The challenge is that many enterprise workflows don't vary nearly as much as the pricing model assumes.

A Microsoft rep would tell you, correctly, that Copilot was never meant to replace deterministic workflow automation. Agree with that. The problem was never Microsoft's pricing. Pay-as-you-go is just a scale that reads out a number you were already generating. What it exposes is which workflows should never have been implemented as generic agents in the first place.

Because a generic agent can't assume anything about your workflow. On every run it over-reasons, re-retrieves the same context, and re-sends a growing transcript through a frontier model. For genuinely open-ended work, that's the cost of the flexibility, and it's worth it. For a fixed, repeatable process, it's pure waste, and the meter just makes the waste visible for the first time. You were paying it before. Now you see it monthly, per department, with your name on the cost center.

That's what my friend is fighting. Two teams of the same headcount post very different bills, because one runs heavy retrieval and actions while the other runs light Q&A. A cost center can't budget against a number that moves every month for reasons nobody controls. And every one of those knobs, the per-user caps, the tier assignments, the cost-center routing, becomes a governance artifact somebody has to own, document, and defend in an audit. The tool is metered. The overhead of metering it is not.

Caps don't control cost. They ration value.

Here's the trap in the cap mechanism. Finance sets a per-user or per-department ceiling to make the bill safe. Fine. But that ceiling is measured in compute, not outcomes. When a user hits the cap, the agent doesn't finish cheaper. It stops. Mid-task.

So the cap doesn't control cost. It rations value. The finance-approved ceiling becomes the exact point where the tool quits being useful. You've made the bill predictable by making the usefulness unpredictable. That's a bad trade, and it's the only trade a metered generic agent offers.

The better approach: build the system, don't rent the agent

The fix isn't a cheaper agent. It's a different architecture. You stop paying to re-buy generality on every run and pay once to engineer the workflow.

  • Deterministic code for the boring 80%. Most of what an agent does isn't fuzzy. Parsing, formatting, moving data between M365 and a database, conditional branching. That's not AI work. That's code. Write it once. It costs effectively nothing to run and it does the same thing every time.
  • Right-size the model for the 20% that's actually hard. The expensive anti-pattern is a frontier model doing trivial work. Route classification, extraction, and routing to a small cheap model. Reserve the Opus-class call for genuine judgment and language generation. This is the single biggest lever after killing the glue code.
  • Engineer the context. Agent loops re-send a growing context on every turn, so a ten-step task costs far more than ten single calls. Compact state between steps. Retrieve only the chunk the next step needs instead of stuffing the whole transcript. Cache the stable system prompt so you're not paying full freight for it on every call.
  • Batch what isn't realtime. Most “cowork” work isn't synchronous. Overnight reports, bulk document processing, scheduled summaries. Run those async at roughly half the price instead of streaming them live.
  • Narrow pipelines over one do-everything agent. A general agent burns tokens exploring because you told it nothing. Decompose the job into narrow flows with model calls at specific decision points. Use an agent where you genuinely need open-ended adaptability. Use a pipeline everywhere else, which is most places.

The payoff is the thing the metered agent structurally cannot give you: a predictable cost per run. When the workflow is fixed, the system does the same work every time, so it costs the same every time. You can put a real number in a cost-center forecast and defend it.

The pattern under all of this

We've been saying AI sprawl is content sprawl with a new logo. This is the same disease in a new organ. Call it orchestration sprawl. Companies are bolting general-purpose agents onto every workflow, paying a metered frontier model to rediscover the same process thousands of times, and then capping the bill until the tool breaks.

Generic metered agents have a place. For exploratory, one-off, unpredictable work, gas-pump pricing is honest and fine. Pay for what you use when you don't know what you'll use.

For a repeated production workflow, it's the wrong tool. You know exactly what that workflow does. So you engineer the cost out of it once, and you own a system with a bill you can predict instead of renting an agent with a bill you can only cap.

This is why we increasingly design AI as one component of a larger system rather than the system itself. The model should provide judgment where judgment is valuable. Software should handle everything else. That split is what makes a workflow predictable, auditable, and cheap to run, and it's the opposite of handing the whole job to a generic agent and metering the result.

My friend doesn't have a licensing problem. He has an architecture problem wearing a licensing costume. The caps, the tiers, the cost-center routing, the audit trail he now has to maintain, all of it is governance overhead he inherited because the workflow lives on a meter. Move the workflow into a purpose-built system and most of that overhead evaporates. Fixed behavior, fixed cost, one thing to document instead of a consumption model to police.

The rollout will work. But the workflows that matter, the ones his teams run every day, don't belong on a meter. They belong in a system.

Sources

Pricing and product details in this post are drawn from the following, current as of publication. Microsoft's consumption pricing moves, so confirm live figures before acting on them.

Matt Fishman is Founder and CEO at Privion. We design AI systems where the model provides judgment and software handles everything else: fixed behavior, predictable cost, and a bill you can put in a forecast. More at priviontech.com.