Photo by Jakub Żerdzicki on Unsplash

Beginning in late 2022, during the preview conversations for the first iteration of Copilot, through its launch and at intervals ever since, I told Microsoft’s product team that speed to launch was a short-term advantage. It mattered, of course. In a market defined by attention, fear, and executive urgency, getting there first created momentum. But speed was never the same thing as durability. Any company with enough capital, infrastructure, and planning horizon could eventually compete on availability, integration, and price.

The more valuable opportunity, I argued then and still believe now, was not another Copilot SKU. It was tooling that helped makers turn ambiguous work into deterministic processes with AI assistance. Something that made tools like Power Automate, Power Apps, and Dataverse a first-class destination rather than an afterthought. The Power Platform could have been positioned as the bridge between AI and reality: a place where business users, analysts, and process owners used AI to clarify work, define rules, map exceptions, and build systems that continued running without a model sitting in the middle of every transaction.

Microsoft is the example I know best, but this is not only a Microsoft problem.

It is the dominant playbook across much of the AI and SaaS market. Vendors have raced to put agents, copilots, assistants, and chat interfaces on top of existing work rather than helping organizations make that work more legible underneath. The commercial logic is obvious; a product that promises to think for you is easier to sell than a platform that helps you think clearly, and a recurring consumption model is easier to monetize than a deterministic workflow that, once built, simply does its job. An agent that keeps interpreting ambiguity every month produces a better invoice than a process that resolves the ambiguity once.

That choice may have made sense as a market-entry strategy. It created urgency, adoption, and executive visibility. But it also obscured a structural reality that was always going to reassert itself.

AI does not make organizational ambiguity disappear. It converts it into operating expense.

Recent reporting has made clear: the bill is starting to arrive.

The invoice arrives

Over the past several weeks, the cost question has finally surfaced in the trade press. A Nvidia executive observed publicly that AI is currently more expensive than the employees it was meant to replace. Axios followed with reporting that the total cost of running production AI systems is outpacing the labor savings they were sold against. Futurism noted, with appropriate irony, that the agents companies are deploying often cost more per month than the salaries of the workers they were meant to displace.

This is being treated as news, but it really shouldn’t be.

The cost trajectory was visible in 2023 to anyone who took the time to model what a process-level deployment of large language models would actually require; context, retries, monitoring, orchestration, evaluation, and the ongoing human supervision required to catch the cases the model handled badly.

The launch pricing was a market-acquisition decision. The structural pricing was always going to be different, and it was always going to follow demand.

The cost of AI is not, fundamentally, a function of the technology. It is a function of what the technology is being asked to do.

The promise was subtraction

AI was sold internally, at most companies and by most vendors, as a way to subtract. Reduce labor and friction. Automate the repetitive. Automate, especially, the messy repetitive work that conventional automation could never quite handle: the email triage that required reading between the lines, the report summaries that required judgment, the customer interactions that required context, and the cross-system reconciliations that required interpretation.

This is the framing the dominant vendors have leaned into hardest: AI as the solver for the problems that resisted prior solutions, or AI as the answer to the question of what to do with all the work that doesn’t fit cleanly into a process diagram.

The pitch, made explicit or implicit depending on the audience, is that AI can finally automate the ambiguous.

The pitch is half-true, and the half that is true is the half that is being charged for.

What humans were actually doing

Before AI was deployed against ambiguous work, ambiguous work was still getting done. It was getting done by humans, usually experienced ones, and often the most experienced people in a given function. And the way they were doing it was by absorbing the ambiguity rather than resolving it.

The senior accounts payable specialist who knew that invoices from a particular vendor always arrived with the wrong PO number, and that the right PO could be inferred from the line items. The customer service lead who knew which exception paths required which approvals, even though no document said so. The operations manager who knew that the “ship date” field meant something different in three different systems and could translate between them on the fly. The analyst who knew which data quirks were real and which were artifacts of a migration eight years ago.

This is not a story about heroic individuals, but a window into how organizations actually function. Every company runs on a layer of undocumented translation that lives in the heads of its experienced employees. The official process is a sketch, but the real process is the sketch plus the translation layer.

Most companies have never seriously tried to document the translation layer because doing so is expensive, tedious, and politically uncomfortable. It forces the organization to confront how much of its operation depends on people who could leave.

For decades, this was tolerable; humans are good at absorbing ambiguity. It is, in some sense, what makes them valuable as employees rather than as components.

AI does not absorb. It bills.

Large language models do not absorb ambiguity. Instead, they process it. Every unclear field becomes prompt context that has to be loaded, parsed, and reasoned over. Every undocumented exception becomes a retry, a fallback, or a case that requires human review. Every contradictory definition becomes additional context the model must hold simultaneously and try to reconcile, just as every unclear owner becomes an escalation path dressed up as automation.

This is the structural fact the launch pricing obscured and the trade press is now noticing. When you point an LLM at a well-structured process with clear inputs, defined outputs, and unambiguous rules, it is genuinely cheap to operate, because the model has very little work to do. When you point it at an ambiguous process, however, the model has to do, on every invocation, the work that an experienced employee used to do once and remember.

The cost of that work compounds.

Context windows expand to hold the institutional memory the company never wrote down. Prompts grow to encode the exception logic that lives nowhere else. Orchestration layers proliferate to handle the cases the base model gets wrong. Eventually, monitoring systems are required because no one is quite sure when the model is getting it right.

Each of these is billable, in tokens, engineering hours, or both.

Token costs are not, fundamentally, a technical expense. Instead, they are a measurement of organizational ambiguity.

The context window becomes a landfill for all the structure the company never built.

The subscription on what you didn’t define

The deeper consequence is structural rather than financial. A process that depends on an LLM to function is a process that has been built around a subscription dependency, and the dependency is not just commercial.

When an organization deploys an AI agent against an ambiguous process, it is making a decision to defer the resolution of that ambiguity indefinitely.

The agent papers over the unclear fields, the contradictory definitions, the missing ownership. It does so well enough that the underlying disorder is no longer felt as friction. The exceptional employee who used to absorb the ambiguity has been replaced, but the ambiguity itself is preserved. Instead of living in memory, it shows up in the prompt, the context window, the retry logic, and the human review queue.

This is not automation in a true sense of the word; in reality, it is outsourcing. On a meter, at a price that scales with how much ambiguity you have left undefined.

The strategic problem with this arrangement is not just that it costs more than promised. It is that it removes the pressure that would otherwise force the organization to do the structural work while replacing the team members best equipped to guide the effort. As long as the agent is handling it, there is no urgent reason to define the field, document the exception, name the owner, or reconcile the systems.

The work of building a coherent operating model, which is hard and slow and politically expensive, gets postponed in favor of a monthly invoice.

At this point, you are not paying for intelligence. You are paying for the right to keep not having defined the thing.

The tools that should exist

The vendors building AI products have, as a category, chosen to sell ambiguity-solving agents rather than ambiguity-resolving maker tools. Microsoft is the example I know best, and perhaps the most legible because they have both halves of the stack. They have visibly chosen which half to lead with.

The Power Platform (Power Automate, Power Apps, Dataverse, and the surrounding governance tooling) is the right shape for what AI should enable. It is a maker platform, designed to let people who understand a business process define that process explicitly, in a way that runs deterministically, with clear inputs, outputs, triggers, and approvals. AI in this stack could have been positioned as the thing that helps makers build those processes faster: assistants that identify patterns, suggest flows, draft definition proposals, and surface the ambiguities and conflicts that need to be resolved before the process is built.

Instead, the commercial weight has gone into Copilot, largely in the form of agents that sit on top of unstructured work and try to handle it as-is. New SKUs, new consumption models, new licensing tiers. The maker-tooling story has been allowed to languish because it sells less aggressively. A platform that helps you think clearly is a harder pitch than a product that promises to think for you.

I want to be precise about what this means in practice, because the alternative is not “no AI.” It is AI in the right place.

A few years ago, I built a small system at work: a feedback button, backed by a Power App, that let employees report process issues directly into a structured intake. I used AI during design — to shape the appearance and placement of the button, plan the user experience, and think through the routing logic that would direct different categories of feedback to the right owners in a way that could scale with adoption. Once built, it ran deterministically. There is no LLM in the runtime path. Feedback ingestion does not consume tokens. Monitoring is limited to alerts for failed runs.

It was adopted organically before it was ever formally announced, because it solved a real problem cleanly. The marginal operating cost is roughly nothing.

That system handles work which, in the current market framing, would be a candidate for an agentic Copilot deployment. Capture informal employee feedback, route it intelligently, summarize trends, escalate where needed. An agent could do all of that. It would also send an invoice every month. The deterministic version requires no additional licensing.

This is not a special case. It is the general shape of what AI should be enabling: the resolution of ambiguity into structure, with AI assisting during design and rarely participating at runtime. The architecturally honest version of most current Copilot agent deployments is an automation script with one or two AI-assisted steps in the places where ambiguity is genuinely unavoidable.

Where AI actually fits

There are categories of work where ambiguity is irreducible, and these are the places AI earns its cost. The defining feature is that the ambiguity lives in the input, not in the organization’s failure to define its own operations.

Document intelligence is the clearest example. An invoice arrives from a vendor; the format is one of three hundred variants the company has seen this year. The fields are in different positions, the line items are described in different terms, the totals are calculated under different conventions. A deterministic parser cannot handle this without a separate template for every vendor, and templates are expensive to maintain. Human keying handles it but at the cost of an FTE per tens of invoices a day.

AI handles it well, because the work it is doing, interpreting an unstructured input into a structured one, is the work it is structurally suited for. The ambiguity is real, and it is in the world, not in the company. The cost of running the model against it is proportionate to the cost of the alternatives.

The same logic applies to customer service interactions, where every conversation is novel and retrieval-augmented generation is genuinely the right tool. So, too, with creative ideation, where divergence is the point and a deterministic system would defeat the purpose. Even early-stage system planning, where the work is precisely to surface possibilities that haven’t yet been narrowed. In each case, the AI is doing work that could not be done deterministically without changing the nature of the task. Costs are real but proportionate, because the model is doing work that is structurally appropriate for it.

The distinction that matters is whether the ambiguity is unavoidable or merely undefined. Unavoidable ambiguity is a property of the work itself: novel inputs, creative divergence, or irreducible variability in the world the system is interacting with. Undefined ambiguity is a property of the organization: fields that were never specified, exceptions that were never documented, owners that were never named, and definitions that drift between systems because no one has done the work to reconcile them.

The two look superficially similar from inside a process. They are economically opposite.

The taxonomy follows from the distinction. AI is the right tool for unavoidable ambiguity. Deterministic systems are the right tool for avoidable ambiguity. Maker tooling – the part most vendors have underinvested in – is the bridge between them, and the place where AI does its highest-leverage work: helping people convert ambiguity that should have been resolved into structure that no longer needs to be reinterpreted.

Most current enterprise AI deployments are the second case being handled as if it were the first. The bill reflects the mismatch.

Closing

The organizations that succeed with AI over the next decade will not be the ones with the largest models, the widest context windows, or the most aggressive agent rollouts. They will be the ones that learn to distinguish between two kinds of ambiguity.

Some ambiguity belongs to the work. A customer writes in with a novel problem. A document arrives in a format no system has seen before. A team is exploring possibilities that have not yet been narrowed. In those cases, AI earns its cost because interpretation is the task.

But much of the ambiguity inside organizations does not belong to the work. It exists because fields were never defined, exception paths were never documented, owners were never named, and systems were allowed to drift apart while experienced employees held the operation together.

That is the ambiguity AI is most often being asked to process. And when it does, the model is not creating leverage. It is reconstructing, again and again, the structure the organization declined to build.

Before deploying an agent, the question should not be “Can AI handle this?” Increasingly, the answer will be yes.

The better question is: Should this still be ambiguous after we understand it?

If the answer is yes, AI belongs in the runtime path. If the answer is no, AI belongs upstream, helping people clarify the work, define the rules, map the exceptions, and build systems that no longer need intelligence in every transaction.

The token tax is not the price of intelligence. It is the price of making intelligence repeatedly reconstruct what the organization refused to define.