KPMG Survey: Why Token Billing Makes Enterprise AI Costs Hard to Predict

Why is the transition to token-based pricing making enterprise AI costs hard to predict? A new KPMG Survey highlights a growing enterprise challenge: companies are struggling to predict costs as AI systems shift from fixed subscriptions to token-based pricing. As enterprises move AI from experimental pilots into daily production workflows, controlling variable inference costs has become a new operational challenge. Historically, flat-fee subscription models insulated companies from the variable infrastructure costs behind a unified per-seat pricing model. Today, because AI platforms increasingly rely on usage-based infrastructure and external model providers, establishing transparent usage monitoring and cost attribution practices is becoming essential for enterprise AI operations.

Why the KPMG Survey Data Matters: Reconciling AI Integration with Unpredictable Budgets

At a Glance

• A recent KPMG global AI survey found that many executives struggle to understand and control AI operating costs.
• The rapid transition from flat-fee software subscriptions to variable, metered “pay-as-you-go” token models has made budget forecasting highly volatile.
• Inefficient AI consumption patterns and unmonitored API calls are driving massive, unexpected monthly bill overruns across diverse enterprise departments.

The financial landscape of enterprise software integration has undergone a major transition. For over a decade, the business model of digital tools relied on predictable, flat-fee software-as-a-service (SaaS) subscription tiers. Organizations paid a fixed rate per user, which allowed finance departments to forecast operational expenses with extreme precision. This flat-fee predictability insulated companies from the underlying computing overhead, as software vendors absorbed the variable infrastructure costs behind a unified per-seat pricing model.

However, as advanced generative systems and large language models (LLMs) migrate into core business operations, this fixed-price predictability has dissolved. Many software providers are shifting more infrastructure costs toward usage-based pricing models. Because each conversational request consumes a variable number of tokens depending on prompt complexity and context length, software providers are shifting the financial burden directly to the end-user. The financial implications of this shift extend beyond simple IT governance.

According to the KPMG Survey, which polled 2,145 senior executives across 20 countries, approximately 29% of respondents could not identify the specific sources driving their rising AI expenditures, while nearly one-third admitted they did not understand the underlying economics of token consumption. In typical deployments, employees and automated agents can generate large volumes of requests without clear usage boundaries, resulting in unexpected billing spikes. For large enterprises, unpredictable AI expenses also create new challenges for financial planning, procurement, and governance teams.

Systemic Root Causes: The Opaque Nature of Token-Based Computing

At the technical level, the high volatility of AI pricing stems from the very nature of token-based computing. Unlike traditional web applications that process standard, structured database queries, LLMs process data through tokens—the basic semantic units of machine learning models. Every request is converted into tokens, which are counted as billable input or output units.

Because LLMs preserve previous attention states through a Key-Value (KV) Cache during generation, memory requirements and inference costs can increase as context windows expand. In many common development pipelines, a single multi-step agent query can consume thousands of tokens in seconds, transforming simple questions into high-cost server transactions.

[Predictable Flat-Fee SaaS]
  Unified Monthly Payment ──> Unlimited Platform Access ──> Fixed, Overage-Free Operating Costs


[Volatile Token-Based Consumption]
  Variable User Prompts ──> Dynamic Token Consumption (KV Cache Accumulation) ──> Unpredictable, Volatile Billing

This lack of predictability is compounded by a shared responsibility model in cybersecurity. Security incidents involving compromised AI middleware have demonstrated that exposed API credentials can create unexpected usage risks. A recent supply-chain exploit targeting open-source AI proxies allowed attackers to intercept and store private API keys.

In one documented incident, a small development team faced severe financial impact, accumulating tens of thousands of dollars in unauthorized charges on commercial models within a mere forty-eight hours, according to reported industry security incidents. This gap between real-time network transactions and delayed financial visibility creates a severe security loophole that traditional firewalls fail to secure.

The broader lesson is that distributed systems need reliable mechanisms to preserve context when execution moves across independent environments. Similar state-preservation challenges appear in mobile attribution systems where acquisition context must survive transitions between browsers, app stores, and native applications. When standard browser referrers are missing or cookies are blocked, mobile attribution systems must rely on server-side state matching to correlate separate events without compromising user privacy.

Build vs. Buy: Comparison of Context Preservation Approaches

Although they solve different business problems, both architectures must preserve operational context across distributed systems where client-side state is unreliable. Managing distributed AI and digital application workflows requires teams to evaluate whether to build custom state systems or adopt standardized infrastructure. Developing a robust technical response to the risks exposed in the KPMG Survey requires a combination of real-time monitoring and software optimizations. Developers must evaluate whether to build custom session-matching databases or purchase standardized, pre-built integration SDKs.

Architectural Evaluation: Custom Build vs. Standardized SDK

The table below compares standard methodologies for managing session state and conversion context:

While custom database configurations can handle basic context, specialized server-side state preservation can optimize development resources. Depending on implementation requirements, organizations may build their own server-side session management system or adopt commercial platforms. For instance, OpoInstall provides server-side mechanisms for campaign parameter restoration and deferred deep linking, allowing organizations to preserve attribution context across web-to-app transitions while reducing reliance on client-side identifiers. These capabilities help simplify attribution implementation and maintain campaign context without requiring developers to build custom context-matching infrastructure. Engineering teams can evaluate these approaches to balance data protection and measurement consistency.

Integration Checklists: Preparing Your Architecture for Lightweight, Cost-Effective Deployment

To secure data pipelines and ensure conversion consistency as platforms transition to secure, server-side data models, engineering and product teams must adopt robust state preservation workflows.

Developer Implementation Checklist

• Enforce Key Rotation and Scanning: Implement robust key management protocols, including strict access controls, secret scanning within your codebases, and regular credential rotation. Never embed keys directly in client-side code or public repositories.
• Establish Financial Guardrails: Set hard spending limits, daily budget caps, and real-time billing alerts on all external API integrations.
• Audit Third-Party AI Service Dependencies: Regularly evaluate the size and compilation dependencies of all integrated libraries to prevent performance bottlenecks.

Product & Growth Strategy Checklist

• Monitor AI Usage Sources: Track model usage sources, request volume, and cost attribution across internal teams and external providers.
• Review Third-party API Costs: Track API consumption patterns and identify unnecessary high-cost workflows.
• Establish Transparent Data Routing: Set up clear parameters to trace data flow paths and resource footprints across platforms.
• Measure AI Workflow ROI: Evaluate how each integrated library or SDK impacts the overall operational budget to eliminate redundant billing.

By establishing these structured guidelines, development teams can transition their applications to safer, more compliant architectures while maintaining operational continuity.

As AI platforms adapt to new regulatory requirements, engineering teams will increasingly rely on transparent usage monitoring, secure API governance, and server-side context management. Evolving AI architectures require a shift toward reliable usage monitoring, secure governance, and transparent cost management.

Organizations that combine transparent cost monitoring with secure cross-platform context management can build more predictable and scalable digital infrastructure. By implementing decentralized caching architectures, cryptographically signed metadata, and robust parameter pass-through frameworks, organizations can protect their operational pipelines from data-transfer bottlenecks. These practices help organizations build scalable AI systems and distributed applications with more predictable operational behavior.