The use of large language models is shifting. It is no longer just people typing questions into a chat window, but increasingly software: AI agents work through several steps independently and send their own requests to the models in the process. According to current observations, these agents consume around five times as many tokens as direct use by humans. The machine share is now ahead of the human share.

Tokens are the billing unit for language models – roughly speaking, word components that are counted both in the request and in the response. Anyone who uses a model via a programming interface generally pays per token. For project budgets, this is the decisive lever: it is not the number of users that drives costs, but the amount of text processed.

Why agents consume so much

The reason lies in the way they work. A human asks a question, reads the answer and perhaps formulates a follow-up question. An agent breaks a task down into sub-steps, checks intermediate results, calls tools, processes their returns and starts the next run. Each of these steps is a separate model request – and each request carries all or part of the previous context with it.

On top of that, agents read things that no human would read in full: log files, configurations, API responses, entire directory structures. What would be a two-line question in a chat quickly becomes a context window of several thousand tokens in agent operation. Failed attempts and repetitions come on top, because an agent that discards one path and tries a second pays for both.

The memory requirement should not be underestimated. Agents need memory – intermediate results, histories, knowledge bases for enriching requests. That shows up in the infrastructure bill, not just in the model calculation. And the more automation emerges in the market, the more demand grows for precisely this computing and storage capacity.

What this means for cost calculation

The practical consequence: anyone who integrates agents into development or automation processes cannot simply extrapolate empirical values from chat use. A pilot with ten test cases says little about the costs in regular operation with a thousand transactions per week. The cost curve is not flat but proportional to volume – and with poorly bounded agents it is disproportionate, because every additional step pulls in new context.

At the same time, this is not an argument against agents. An agent that shortens a manual process from 40 minutes to three minutes may well consume significantly more tokens than a chat prompt. The question is not whether consumption is high, but whether it stands in a comprehensible ratio to the effort saved.

Four starting points for planning

  • Cost per transaction instead of a monthly flat rate: Calculate a single run – how many model calls, how much context per call. This figure times the expected volume gives a reliable basis. A flat rate based on gut feeling does not.
  • Limit context deliberately: Not every step needs the full history. Summaries, targeted excerpts and clearly scoped tasks noticeably reduce consumption without damaging the quality of the result.
  • Choose models by task: Classifying, formatting or extracting often works with smaller, cheaper models. The large model remains reserved for the steps that really need it.
  • Termination criteria and upper limits: Agents without a limit on the number of steps can run in loops. Hard limits per transaction, budget limits per period and alerts for outliers are part of the operating concept, not an optional extra.

Transparency as an operating prerequisite

Anyone operating agents in production needs metrics. Tokens per transaction, cost per transaction, success rate, share of repetitions: without these key figures, the bill at the end of the month remains a surprise. It makes sense to assign consumption to the respective use case from the outset. Only then can it be assessed which workflow pays off and which merely impresses.

Equally important is the honest question about the alternative. Some tasks that begin as an agent project are solved more cheaply and reliably with a classic rule, a script or a clean interface. The agent is the right choice when tasks are unstructured, change frequently or require text and context to be interpreted.

For web and software projects, this means: agents belong in ongoing operating costs, not in the one-off project sum. Anyone who uses them should make consumption measurable, technically limit context and the number of steps, and decide per use case whether the benefit justifies the tokens. That way, automation remains a calculable item – and not a cost block that only becomes visible after go-live.

Sources