AI Agents Broke the One Rule Business Cases Depend On

An identical AI task can cost 5x more on a different day. Same input. Same system. Different bill.

At first that felt like a reliability problem. The more I sat with it, the more it revealed something else entirely.

If an agent’s cost can vary that dramatically depending on how it reasons at runtime, then the cost of running agents is not a number you can calculate. It is a range with no reliable floor and no enforced ceiling. And that breaks something fundamental about how enterprises make technology decisions.

The business case model that has governed IT investment for thirty years assumed one thing above all else: costs are knowable before commitment. Agentic AI removes that assumption. Quietly, structurally, and without announcing itself.

How the Business Case Used to Work

Before agentic AI, IT investment decisions rested on a simple foundation: every cost input could be estimated before money was committed. The model was not always accurate, but it was always modelable. Variance arrived in predictable forms:

• Scope expanded beyond the original brief
• Timelines slipped and headcount grew to compensate
• Infrastructure scaled faster than projected under load

These were understood failure modes. Finance knew how to account for them. Even cloud pricing, which introduced variable costs, introduced bounded variable costs. You could set an alert. You could model the ceiling. You could govern against a limit. The framework held because the cost inputs, however imprecise, were structurally forecastable.

That is the condition agentic AI removes. Not the accuracy of the forecast. The forecastability itself.

What Agents Actually Cost

An agentic system does not have a cost. It has a cost behaviour. That behaviour is a function of how the agent reasons at runtime, not what the task specification says at design time.

Consider what happens inside a single agentic workflow when something goes slightly wrong:

• The agent misreads a tool response and retries the call
• An intermediate reasoning step produces ambiguity, so the agent expands its context window to resolve it
• A sub-task fails silently, the agent compensates by generating an alternative path
• None of this is visible from the outside. The task completes. The output looks correct. The token count is three times the baseline.

This is not a bug in the agent. It is how reasoning under uncertainty behaves. But it creates a direct collision with enterprise financial governance, which requires costs to be estimated, tracked, and justified before and after every deployment decision.

You cannot build a business case around a cost that has no deterministic relationship with the volume of work being done.

The unit economics that IT strategy teams rely on collapse under this condition. Cost per transaction assumes the transaction has a stable cost. Cost per user assumes usage maps to value predictably. Neither holds when the system is reasoning dynamically, consuming tokens based on what it encounters at runtime rather than what it was instructed to do at design time.

The Signal Most Teams Are Missing

Here is what this gap looks like in practice. An organisation deploys an agentic workflow. Week one costs feel manageable. The team moves forward. Then the agent encounters an edge case it was not optimised for. It loops. Token consumption triples on that task category. No alert fires because no ceiling was defined. No one notices because no one was tracking token consumption as a governed line item.

The first signal that something is wrong often arrives not from an engineering dashboard but from a monthly cloud invoice that does not match any prior model. By then the deployment is live, the team is dependent on it, and unwinding is expensive.

The workaround that practitioners arrive at independently is revealing. They move from no-code agent environments into semi-code environments. They add rules. They constrain the agent's decision surface not through configuration but through Python. They do this because it is the only way to make the agent's behaviour deterministic enough to govern.

That workaround is not a solution. It is a fault line becoming visible. The no-code environment promised that anyone could build with AI. It did not promise that anyone could fix what they built. When the agent breaks and the cost spikes, the person who deployed it opens a support ticket. The person who can actually fix it was never in the room when the deployment decision was made.

Most enterprises have not yet noticed that these are two different people. Part 2 of this series asks what happens when they do.

What This Means for IT Strategy and CIOs

The business case problem will not resolve when models become cheaper. Cheaper inference reduces the unit cost per token. It does not reduce the unpredictability of how many tokens a reasoning task will consume. The structural gap remains even as the price falls.

What enterprise teams are discovering is that agentic AI requires a different governance architecture before it can be responsibly scaled. Not better prompts. Not smarter model selection. A layer that sits between the agent's runtime behaviour and the financial systems that need to account for it.

That layer does not yet exist as a product. It exists as a practice, maintained by teams disciplined enough to build it.

Before deploying agents at scale, the conversation that needs to happen is not about capability. It is about cost observability. Three questions determine whether a deployment is ready to be governed:

Every no answer to those three questions is not a gap to close later. It is a live exposure right now:

• The deployment is running
• The costs are accumulating
• The business case sitting in the approval folder is already fiction

Enterprise AI adoption is moving fast enough that most teams are not asking these questions before they scale. They are asking them after the invoice arrives. By then:

• The dependency is built
• The team is committed
• Unwinding costs more than continuing

That is not a technology problem. That is a governance problem that was mistaken for a deployment decision.

The CFO's question has always been the same: what will this cost? For thirty years, IT had a credible answer.

Agentic AI's honest answer today is: it depends on what the agent decides to do at runtime. That answer does not fit in a business case template.

The question for every CIO and IT strategy team is not whether to adopt agents. It is whether you can afford not knowing what it will cost.

And when that cost spikes or the system fails, a deeper question emerges: Who is actually accountable?

Part 2 explores why, in most enterprises, the answer is unclear and why that matters more than the failure itself.