By Marcin Marczyk, Delivery Director at Addepto, a KMS Technology company

A year ago, the dominant incentive inside major tech companies was to burn through as many AI tokens as humanly possible.

Some firms even instituted internal leaderboards ranking employees by token consumption, a practice nicknamed "tokenmaxxing." That era is ending. In its place comes a sharp reversal that Silicon Valley is already calling "tokenminimizing."

The trigger was painfully simple: the bills arrived.

This is not isolated to pure-play tech giants. Accenture, which earlier in 2026 warned staff that under-utilizing AI could hurt their promotion prospects, was recently reported to be trying to restrain employees from burning token reserves on trivial tasks, like using LLMs to convert raw PDFs into PowerPoint slides.

The issue became impossible to ignore: AI transitioned from an unmetered, experimental perk into an unpredictable, high-impact cost-structure line item.

A necessary caveat: these examples represent heavy early adopters and do not imply that every company in the market is actively cutting back. However, a broader survey by Wakefield Research for Lanai found that 79% of enterprise executives worry their AI budgets will be slashed if they cannot prove measurable ROI.

"Tokenminimizing" is best understood as a trend among heavy-usage organizations hitting an economic wall, but the underlying mechanics are universal: once AI adoption reaches a certain scale, finance departments step in and demand control.

Three Drivers of the AI Cost Explosion

To understand why AI costs have risen so sharply, we have to name three distinct mechanisms that compound each other.

1. Vendor Billing Changed (The Shift to Metered Usage)

Through 2026, the commercial foundation of enterprise AI fundamentally shifted. GitHub Copilot moved to usage-based billing, replacing fixed premium-request allowances with token-metered credits while leaving base seat prices unchanged, and Anthropic and OpenAI transitioned their enterprise contracts toward usage-based models.

This was a classic, deliberate SaaS-like playbook:

  • Create the habit under flat-rate, heavily subsidized pricing.

  • Build reliance across engineering and operations workflows.

  • Change the billing model to charge per unit of compute, once usage is deeply embedded.

However, this transition was also technically inevitable given the physical nature of LLMs. In older software and classical ML models, scaling usage brought down the marginal cost per user. With LLM inference, every single prompt and response consumes real GPU cycles, RAM, and electricity. Flat-rate enterprise pricing was economically unsustainable for vendors from day one; it was only a matter of time before they passed the real running meter onto the client.

2. A Pre-Existing Habit Met New Tiered Pricing

Long before billing models changed, organizations had normalized a bad habit: routing every single digital task through a frontier LLM, regardless of whether a language model was actually needed.

Accenture's PDF-to-slides example illustrates the reflex: a deterministic task that requires simple file parsing was handed over to a multi-billion-parameter reasoning model purely because "just ask the AI" had become the default company culture.

Vendors encouraged this by selling an AGI-driven narrative, that AI would handle all work faster, better, and cheaper than human effort, and enterprise buyers eagerly swallowed the hype, operating under the illusion that AI was an all-purpose, low-cost hammer for every nail.

When usage-based billing hit, this habit collided with a stark new reality in model pricing:

  • Small and open-weight models stayed relatively cheap (pennies per million tokens).

  • Top-tier reasoning models carried a massive premium ($20+ per million tokens).

Because organizations treated all LLMs as a single, interchangeable "AI" black box, employees naturally defaulted to the most capable (and most expensive) frontier models for mundane tasks. A habit that was merely inefficient under a flat fee became ruinously expensive under tiered, usage-based pricing.

3. Agentic Workflows Multiplied Token Consumption Dramatically

The shift from simple conversational chatbots to autonomous "agentic" workflows adds one more layer of complexity to this already complex landscape, by transforming token consumption from a linear stream into a loop.

  • Standard chatbot exchange: 1 prompt in → 1 response out (one request-response cycle).

  • Agentic task execution: the agent reads a file, plans, calls a tool, evaluates the output, encounters an error, re-plans, calls another tool, and loops continuously until the goal is met.

Each iteration in an agentic loop can involve additional model calls, increasing token consumption and the cost of completing a single task. A task that once took a single cheap interaction suddenly generated dozens or hundreds of billed steps behind the scenes. The price per token didn't change, but the sheer volume of tokens required to complete a single task exploded.

The "LLM-First" Agency Panic: Hype Meets Legacy Reality

As boardrooms and users alike began demanding AI in everything, vendors fed the momentum with promises of near-magical capabilities: technology that was supposedly only months away from replacing traditional software development and wiping out entire categories of SaaS along the way.

Software consultancies and digital agencies responded just as quickly, rebranding themselves as "AI-native" or "AI-first," while in fact they were merely "LLM-focused."

The reality on the ground was spectacularly boring and chaotic:

  • Fragmented, uncleaned enterprise data.

  • Fragile legacy systems unable to parse unstructured outputs.

  • Strict regulatory and privacy constraints.

  • Persistent model hallucinations.

  • A complete absence of calculated ROI.

"Ask anything" was an easy pitch to sell to non-technical executives, but it resulted in the most expensive, compute-heavy models being deployed to answer basic database queries or route internal support tickets: tasks that a simple SQL query, a rules engine, or a small classification model could have executed faster, cleaner, and virtually for free.

When the invoices arrived, the "AI-first" illusion collapsed into frantic cost-cutting, emergency token caps, and an urgent scramble for governance dashboards.

Making AI Useful Without Letting Cost Run the Show

Controlling AI spend does not mean turning against the technology. LLMs are genuinely powerful, and they can already do a great deal.

But it is time to treat them with the seriousness of any other engineering discipline, accounting for messy data, inconsistent inputs, edge cases, unpredictable human behavior, and the constraints of production rather than assuming a laboratory demo will glide through the real world without missing a beat.

Making AI economically viable depends on three core practices:

Match the Method to the Problem (Fixing the Habit)

Many routine enterprise tasks (ticket classification, request routing, sentiment tagging, basic entity extraction) are narrow and deterministic. Classical machine learning (logistic regression, gradient boosting) or small, specialized transformers remain far superior, faster, and infinitely cheaper than LLMs.

A 2026 systematic review across 68 studies demonstrated that fine-tuned small language models achieved 85–90% accuracy on domain-specific tasks at just 10–25% of the computational cost of large general-purpose frontier models.

Reserve top-tier LLMs for what they actually excel at: interpreting messy, free-form human text, acting as a translation layer for dense technical data, and executing complex, unstructured reasoning.

Think in Layers, Not "One Big Brain" (Fixing Agentic Multiplication)

Keep deterministic systems (SQL databases, hardcoded business logic, classical algorithms) in charge of what happens, and use LLMs strictly for how it is synthesized or explained.

Furthermore, stop treating model selection as a single, global decision. Build intelligent routing layers:

  • Send routine, high-volume tasks to cheap commercial tiers or self-hosted open-weight models (e.g., Llama, Mistral).

  • Route only genuinely complex, ambiguous edge cases to expensive frontier models.

Bounding the scope of what an LLM is allowed to execute prevents agentic loops from spinning out of control and burning budget on simple tasks.

Build Real Financial & Operational Guardrails (Fixing Pricing Exposure)

A vague promise of "increased productivity" is not a business metric. Every AI deployment must be tied to a strict, three-part KPI framework:

  • A baseline (e.g., current average handle time = 9 minutes).

  • A target threshold (e.g., target handle time = 6 minutes).

  • A fixed review window (e.g., evaluated strictly at 90 days).

Tie this directly to token costs: if an AI initiative costs €50,000 per quarter and is meant to save 600 hours of manual labor at €40/hour (€24,000 in savings), it is an economic failure.

Additionally, utilize existing enterprise governance tools, such as budget caps in Databricks Unity AI Gateway, attribution controls in Amazon Bedrock, or Azure AI cost-monitoring controls, to enforce hard spend limits before a runaway script generates a five-figure invoice.

Closing Thought

The cost-cutting measures at Uber, Amazon, and Accenture are not evidence that AI is useless. Rather, they are proof that treating large language models as a one-size-fits-all default has become prohibitively expensive.

However, once cost is integrated into system design from day one rather than discovered after launch, AI stops being a runaway corporate expense and starts behaving like any other mature component in the tech stack: exceptionally powerful where it fits, ruinously expensive where misapplied, and valuable when governed with discipline.