Every finance leader signing off on an AI initiative in 2026 has heard the pitch: models are cheaper than ever, the technology pays for itself, and per-token prices keep falling. All of that is true. And it is exactly why so many organizations are now staring at invoices they cannot explain.

The uncomfortable reality is that AI does not bill the way enterprise software has billed for the last two decades. It introduces a cost structure most budgeting frameworks were never built to handle, one where the unit price drops every quarter while the total bill climbs relentlessly. Companies that treat tokens like another line item on a SaaS contract are the ones getting surprised. This piece breaks down where the money actually goes, weighs it honestly against the value AI delivers, and lays out a practical playbook for keeping spend under control before it controls you.

The paradox at the heart of the bill

Start with the math that confuses everyone. Total spend is price multiplied by volume. In AI, the price per token is collapsing, yet the invoices keep growing. The reason is that volume is expanding far faster than price is falling.

This is not a new phenomenon. In 1865, the economist William Stanley Jevons observed that as steam engines became more efficient and coal grew effectively cheaper to use, total coal consumption went up, not down, because cheaper energy unlocked more uses for it. The same logic now governs AI budgets. When a model call cost real money, teams reserved AI for high-value tasks where the return was obvious. At a fraction of a cent per thousand tokens, the financial gate that used to limit deployment disappears, and suddenly AI gets applied to dozens of marginal use cases that were previously “too expensive to bother with.”

The numbers bear this out. By various market analyses, generative AI spending across enterprises roughly tripled in 2025 even as headline token prices fell by an order of magnitude or more. The FinOps Foundation’s 2026 State of FinOps report found that a clear majority of enterprises, about 73%, saw their AI costs exceed original projections. The same body of research shows the share of cost-management practitioners now responsible for AI spend leaping from roughly a third to nearly all of them in the span of a couple of years. Deloitte went as far as publishing a dedicated CFO guide to AI token economics in early 2026, a topic that did not exist on most finance radars eighteen months earlier.

Why tokens aren’t seats: the mental model that breaks budgets

For nearly twenty years, enterprise software ran on a simple premise: pay per seat, scale predictably. Add a user, add a known monthly cost. Finance could forecast it on a spreadsheet. AI demolishes that premise.

A token is the unit AI models bill against, roughly four characters of text, or about three-quarters of a word. You pay separately for input tokens (everything you send the model) and output tokens (everything it generates back), and output typically costs anywhere from two to six times more than input because generating text is more compute-intensive than reading it.

Here is what makes this dangerous for budgeting: cost is tied to interaction intensity, not headcount. One employee using AI to summarize emails might consume a few thousand tokens a day. Another, on the identical license, running code generation or deep document analysis across long context windows, can consume millions. Same seat. A thousandfold difference in cost. And none of it is visible until the bill arrives. Seat-based software has fixed cost per user; AI has variable cost per action, and actions are volatile, hard to forecast, and, critically, invisible by default.

The hidden cost multipliers most teams never see

The sticker price of a model is the part everyone looks at. The part that breaks budgets is the architecture around the model. Here are the mechanisms quietly inflating real-world bills.

1. Context window bloat (the stateless tax)

Large language models have no memory between calls. They are stateless. To create the illusion of an ongoing conversation, the application must resend the entire history with every new request. Turn one might be 200 tokens. By turn ten, you are re-transmitting thousands of tokens just to add “okay, thanks.” You pay for the same context, over and over, on every single turn. As one engineer put it, it is like buying the same newspaper again every time you want to re-read a paragraph.

2. The agentic loop multiplier

This is the single biggest driver of runaway spend in 2026. Agentic systems (AI that takes multiple autonomous steps, calls tools, and feeds results back into itself) compound token usage at every step. Because each call is stateless, the agent ships the full and growing conversation, plus tool outputs, plus instructions, on every iteration. By the twentieth step of a loop that reads files, the input on a single call can exceed 50,000 tokens. One task can cost several dollars; a team running many such tasks daily can reach six figures a month. Gartner’s analysis pegs agentic workflows at 5 to 30 times the token consumption of a standard chatbot for the same notional task. Worse, poorly built agents can enter recursive loops, over-query systems, or silently retry on failure, generating exponential usage and surprise bills with no natural governor.

3. Reasoning tokens you can’t see

Modern “reasoning” models think before they answer, generating extensive internal chain-of-thought that you are billed for even though much of it never appears in the final response. For complex tasks this can dwarf the visible output. Defaulting every query to a heavyweight reasoning model, the “Big Model Fallacy,” is one of the most expensive architectural mistakes an organization can make.

4. RAG and “just-in-case” context

Retrieval-Augmented Generation injects retrieved documents into the prompt so the model can answer from your data. Done carelessly (retrieving too many chunks, with too much overlap, on every request), it becomes a major hidden cost center. The failure pattern is treating all available context as “always include.” Context expands to fill whatever window you give it, and you pay for every token of scaffolding you didn’t even write.

5. Tool-call overhead, retry storms, and model drift

Large JSON or log payloads get reinjected into prompts. Timeouts trigger retries that multiply attempts. Fallback paths repeat prompt blocks. Debug metadata leaks into production payloads. Each is small in isolation; together they show up as “random variance” in a bill that only tracks totals, which is precisely why most teams never trace the spike to its source.

What it looks like when it breaks

These dynamics are not theoretical. A series of widely reported cases in 2026 illustrate the range of damage.

Most prominently, Uber reportedly exhausted its entire 2026 AI coding-tools budget by April after aggressively pushing engineers to adopt agentic coding assistants, with per-engineer costs reaching $500 to $2,000 a month. The internal dynamic is instructive: leadership encouraged adoption with leaderboards and public rankings, then discovered that unconstrained consumption has no natural brake. Microsoft has been reported to face similar overruns. The structural problem is identical everywhere: consumption-based pricing colliding with per-seat budgeting, value that is hard to isolate, and incentives that reward maximum usage rather than maximum efficiency.

At the extreme end, a three-person open-source team ran an experiment with roughly a hundred autonomous coding agents and posted a 30-day API bill of $1.3 million across more than 600 billion tokens. (The relevant caveat: the project’s founder had joined the model vendor, which was footing the bill. It was a research project exploring what software development looks like when token cost is no object, not a startup’s survival math.) It is a useful upper-bound illustration of how far agentic consumption can run, not a template.

More representative is the mid-market pattern. A growth-stage software company with around 35 engineers, running a mix of coding assistants and a custom autonomous bug-triage agent, reported an $87,000 bill for a single month, then cut it dramatically within 30 days by routing routine work to a cheaper model and pruning agent context. One enterprise was reported to have consumed roughly a trillion tokens over six months, translating to several million dollars in unplanned cost, before finance even understood what was driving it.

The pattern repeats at every scale: the spend is invisible until the invoice arrives, and by the time someone notices, it is often a large multiple of where it started.

The other side of the ledger: where the spend is worth it

None of this is an argument against AI. Treated as a warning instead of a verdict, the cost story has a flip side that deserves equal weight: when the work is high-value and the architecture is disciplined, token spend can be one of the best-returning lines in the budget.

The same falling unit costs that enable waste also enable genuine new capability. Tasks that were uneconomical two years ago, such as continuous code review, document-heavy due diligence, always-on monitoring, and large-scale summarization, are now viable. The teams seeing real returns are those that can answer a simple question: what business outcome did this token spend produce? When a coding agent ships features faster than the engineering time it replaces, a $1,000-a-month seat is cheap. When AI closes support tickets or security alerts faster and more accurately, the cost-per-outcome math favors the spend. Deloitte’s CFO guidance illustrates the upside with a concrete case: the development platform Vercel reported that its heaviest token spenders were also its most productive employees, with a single high-spend day plausibly saving the company far more than it cost.

The problem is not adoption. The problem is consumption without a connection to value. AI spending that tracks to measurable outcomes is an investment; AI spending that grows because nobody is watching is a leak. The discipline below is what separates the two.

The security and due-diligence lens

For organizations where AI runs inside security operations or appears on the other side of an acquisition, token cost is not just a finance issue; it is an operational-risk and diligence issue.

Inside a security operations center, the most common token-budget failure is not bad prompts; it is unbounded context combined with always-on AI sitting in a high-volume queue. Every alert gets the same heavyweight treatment even though most are routine, “just in case” context (full alert payloads, log samples, asset inventories, past tickets) gets attached to every call, large models get used for simple field extraction, and systems silently retry on timeouts. Success gets measured as activity (how many AI runs) rather than outcomes such as how many incidents closed faster. The result is a cost curve that scales with alert volume rather than with value delivered.

Shadow AI compounds the risk. When employees adopt AI tools outside any central governance, both usage and spend accumulate invisibly, with no tagging, no budget, and no audit trail. That is both a cost-control gap and a data-exposure one.

In an M&A context, all of this becomes a diligence line item. A target’s AI spend can be a leading indicator of margin risk: consumption-based costs that scale with usage, contracts built on per-seat assumptions that no longer hold, and agentic deployments whose token economics were never formally modeled. An acquirer evaluating a heavily AI-dependent business in 2026 should treat “where does the token budget go, and does it track to value?” as a standard question, not a footnote. Gartner has gone as far as projecting that a large share of agentic AI projects will be paused or abandoned by 2027, citing rising costs, unclear business value, and inadequate risk controls as the primary reasons.

The playbook: managing token spend before it manages you

The response that has emerged is a new discipline, FinOps for AI, applying the same accountability cloud computing got a decade ago to AI inference. It rests on four pillars: visibility, optimization, governance, and accountability. Here is what each looks like in practice.

Pillar 1: Visibility (you cannot manage what you cannot see)

• Tag every call with user, team, project, and task type. Untagged spend is unmanageable spend; tagging is what turns a mysterious total into an attributable one.
• Split input vs. output and demo vs. production, since they have different root causes and very different acceptable levels.
• Watch the tail. Bloat usually hides in p95/p99 outliers, not the average. Review the expensive 1% of calls, not just the mean.
• Build dashboards finance and engineering share, so cost-per-feature and cost-per-customer are visible to the people who can act on them.

Pillar 2: Optimization (the technical levers, in order of ROI)

• Model routing and cascades. Use a cheap, fast model to classify difficulty, then escalate to an expensive model only for the hard cases. This is the highest-leverage single change for most teams, and the antidote to the Big Model Fallacy.
• Prompt caching. Repeated system prompts and long, stable context (a big instruction block, a reference PDF) can be cached for up to roughly 90% off on subsequent calls. This is transformative for RAG and agents, but it is off by default in many frameworks, so it has to be deliberately turned on.
• Batch processing. For anything that does not need a real-time answer, such as nightly jobs or weekly analytics, batch APIs run roughly 50% cheaper. Combined with caching, effective cost can drop to around a quarter of the standard rate.
• Context discipline. Hard-cap conversation history (for example, the last 8 to 12 turns), prefer compact structured memories over raw transcripts, and retrieve fewer, better-ranked RAG chunks rather than dumping everything in “just in case.”
• Output caps and input validation. Set maximum output tokens on low-risk flows, and reject oversized inputs (count tokens before sending) so a pasted 100-page document never silently becomes a bill.

Pillar 3: Governance (controls that prevent the leak)

• Per-agent and per-team token budgets, with throttling as a cap is approached and automatic pause or kill for anything that blows through it. Dedicated tooling for this now exists precisely because agents can run away.
• Approval thresholds and rate limiting on high-cost workflows.
• Anomaly alerts that fire when spend drifts (a model processing more tokens, a feature’s call volume spiking, a RAG pipeline over-retrieving) and point at the responsible service before month-end.
• Bring shadow AI into the light with a sanctioned tool catalog and central billing, so consumption is governed rather than discovered after the fact.

Pillar 4: Accountability (tie spend to value)

• Give every AI initiative a business sponsor and a defined business case, not an open-ended IT budget. Treat AI as a strategic investment with ROI expectations, not a utility cost.
• Measure cost-per-outcome, not cost-per-run. “How many incidents closed faster” beats “how many AI calls we made.”
• Run regular use-case reviews to retire low-value consumption and reinvest in what pays.
• Model the economics before you scale. Estimate monthly cost as (daily requests x avg input tokens x input price) + (daily requests x avg output tokens x output price), then buffer 2 to 3x for prompt iteration. The invoice surprises come from the deployments where this was never done.

A 30-day starting point

If your monthly AI bill is already meaningful and you cannot say precisely where it goes, you do not need a year-long program to regain control. A focused month gets most of the way:

• Week 1, Instrument. Tag every API call by user, team, and task type. Stand up a basic spend dashboard.
• Week 2, Find the concentration. Identify the handful of features, teams, or agents driving the majority of spend, and inspect the p95/p99 tail.
• Week 3, Apply the top levers. Turn on prompt caching, route routine work to cheaper models, cap context windows and output length on the biggest offenders.
• Week 4, Govern. Set per-team budgets, wire up anomaly alerts, and assign each major use case a business owner accountable for its ROI.

The bottom line

Token prices are falling, and they will keep falling. That is exactly why the bill keeps rising: cheaper tokens unlock more uses, and usage growth has decisively outpaced price relief. The organizations that thrive in this environment are not the ones waiting for the next price cut. They are the ones who accept that AI spend grows even as unit costs drop, build the visibility to see where it goes, and put governance in place that enables growth while preventing waste.

Managed deliberately, AI token spend is one of the highest-return investments a modern organization can make. Left to compound unwatched, it is a leak built quietly into the architecture of every agentic deployment, invisible right up until the invoice arrives. The difference between those two outcomes is not the technology. It is whether anyone is watching the meter.

References and further reading

• FinOps Foundation, State of FinOps 2026, the survey showing AI cost management rising from 31% of practitioners in 2024 to 98% in 2026.
• Gartner, Gartner Predicts Over 40% of Agentic AI Projects Will Be Canceled by End of 2027 (press release, June 2025).
• Deloitte, AI token economics for CFOs.
• CloudZero, LLM API Pricing Comparison, on per-token rates, prompt caching, and batch discounts.
• The AI Enterprise, The New Enterprise Currency: Why Your AI Strategy Lives or Dies by the Token, on the inference cost paradox and market sizing.
• Oplexa, AI Inference Cost Crisis 2026, which cites the Gartner 5 to 30x agentic token multiplier.
• Studio Global, Inside Uber’s AI Budget Meltdown, on consumption-based pricing versus per-seat budgeting.
• Startup Fortune, AI Cost Savings Are Running Into a Token Bill Problem, on Microsoft and Uber.
• TurboDocx, AI Token Spend Is Getting Out of Control, on the OpenClaw experiment.
• LeanOps, AI Agents Burn 50x More Tokens Than Chats, an audit of agentic spend across engineering teams.
• SiliconANGLE, Portal26 Launches Agentic Token Controls to Cap Runaway AI Agent Spend.
• VentureBeat, How xMemory Cuts Token Costs and Context Bloat in AI Agents.
• SecQube, Controlling AI Token Usage Without Sacrificing Security Outcomes, on token discipline in the SOC.
• Optimum Partners, AI Token Costs and How They Might Wreck Your Budget, on where AI budgets break.

Methodology note: figures attributed to analyst and vendor sources (Gartner, Deloitte, the FinOps Foundation, and others) are reported estimates drawn from the references above. Token prices and provider terms change frequently and should be re-verified against current provider documentation before publication.

Categories: Artificial Intelligence, Cybersecurity Blog

Tags: Agentic AI, AI budgeting, AI cost management, AI FinOps, AI Governance, AI ROI, AI token costs, Enterprise AI, Generative AI, inference cost, LLM pricing, model routing, prompt caching, Shadow AI, token economics