Anyone who builds AI functions into web projects or internal tools will sooner or later reckon with tokens. A token is the smallest billing unit of language models – roughly a word fragment that the model reads or writes. Over the past few months, this unit has become the central cost metric, and the distribution behind it has shifted.

According to an analysis by OpenRouter analyst Peter Walker, AI agents have been consuming more tokens than human usage since 6 February 2025. Agent consumption rose fourteenfold, while human usage increased 2.8-fold. Software has thus become the largest consumer of the models.

Why agents consume so much more

The reason lies in the way they work. A human asks a question, reads the answer and perhaps asks a follow-up question. An agent – that is, a program that works through a task independently in several steps – turns this into a chain: read in context, draft a plan, call a tool, check the result, correct it, check again.

Each of these steps carries the previous context with it. Files, specifications, intermediate results and error messages are repeatedly carried along into the prompt. A task that a human completes with two requests thus becomes twenty or more model calls, each with considerable overhead. This is particularly noticeable in software development, because codebases, test outputs and logs are needed there as context.

The bill grows more slowly than the number

A second finding of the analysis is decisive for budgets: almost 70 percent of agent consumption is attributable to cached prompts, which are billed at a lower rate. Prompt caching means that a constant part of the input – such as system instructions or a project file – is held by the provider and is not charged at the full price when reused.

As a result, real costs rise much more slowly than token numbers. For budget planning, this means two things: first, an extrapolation based on token volume alone is misleading and leads to unnecessarily high buffers. Second, the cache share is not a law of nature but a property of the architecture. Anyone who does not deliberately create it pays the full price for every run.

What determines the cache share

Caching takes effect where inputs are stable and recognisable. This can be influenced when building an application:

  • Stable prefixes: System instructions, role descriptions and recurring reference data belong at the beginning of the prompt and should not change between two calls.
  • Variables towards the end: Timestamps, user identifiers or changing parameters at the start of the prompt destroy the reusability of the entire context.
  • Cut context deliberately: Do not drag the full history along, but summarise it in a targeted way or reload only relevant excerpts.
  • Choose the model by task: Routine intermediate steps such as classifying or formatting rarely need the most expensive model.
  • Termination criteria: Agents that work without an upper limit on iterations will loop when in doubt. A limit on steps and outputs per task is a cost measure.

Consequences for proposals and contracts

The shift from human to machine consumption changes how costs arise in projects. With interactive use, expenditure scales with the number of users, and is therefore relatively predictable. With agentic workflows, it scales with the number of processed transactions and with the complexity of each individual transaction – and both are harder to estimate in advance.

It therefore makes sense to treat ongoing model costs as a separate line item from the outset, separate from development effort and hosting. This includes measurement in operation: cost per completed task, cache hit rate, share of calls that did not deliver any usable contribution. Without these metrics, any optimisation remains guesswork.

For pilot projects, it has proven effective to first measure a defined use case with real data instead of extrapolating from benchmarks. A run over a few hundred real transactions provides a more reliable basis than any model calculation – and usually also shows where the context is unnecessarily large.

Not every task needs an agent

The figures invite us to regard agentic architectures as the standard. That falls short. A single, well-formulated model call with a clear output structure is cheaper, faster and easier to test for many tasks than a multi-stage loop. Agents pay off where the solution path is not known in advance and tools must be integrated.

Conversely: where the path is known, it belongs in code. Classic program logic consumes no tokens, is deterministic and can be safeguarded with ordinary tests. The interesting question in projects is therefore less how many tokens an agent consumes, but which sub-steps require a language model at all.

Assessment

For web and software projects, the development means that model costs are turning from a side item into a planning metric in its own right with an operational character – comparable with traffic or computing time, only harder to predict. Anyone who treats prompt structure, context size and termination criteria as architectural decisions early on keeps the difference between token volume and the actual bill large.

And anyone who makes consumption per process measurable can negotiate budgets instead of estimating them.

Sources