In 2024 we learned to watch the cloud bill. In 2026 the problem changed in nature: we no longer control servers that consume predictably, but AI agents that reason, decide, and call models over and over to resolve a single task. An agent that looked cheap in the demo can multiply its cost twentyfold when it faces a real case, because every reasoning step, every tool invoked, and every retry becomes billed tokens. When that dynamic is replicated across hundreds of users, spend stops being a technical line item and becomes an item on the board's agenda.
The short version: AI agents trigger costs that are hard to predict because they call the models many times per task and use tools autonomously. FinOps for agentic AI consists of giving visibility into spend per agent and per task, choosing the right model at each step, and setting limits before scaling. Without that governance, the bill grows faster than the value.
A call to a language model has a reasonably estimable cost: you send text, receive a response, and pay for the input and output tokens. An agent is another matter. It does not execute a single call, but a loop: it thinks, decides, calls a tool, reads the result, thinks again, and repeats until the objective is met. Each turn of that loop is a new call to the model, and the number of turns is not known in advance.
This generates three sources of spend that the traditional cloud model does not capture well:
Most organizations see AI spend as a single monthly figure from the provider. That is insufficient for governing agents. The right question is not "how much did we spend on AI," but "which agent, on which task, and for which user generated that spend, and what value did it deliver in return."
To answer it, you need to instrument the system with attribution tags from day one:
Without this granularity, any attempt at optimization is blind. With it, the patterns emerge: almost always a handful of agents or tasks concentrate most of the cost, and that is where it pays to act first.
Once there is visibility, the optimization levers are concrete and, in many cases, do not require sacrificing quality. The ones that generate the most impact in our experience are the following.
Not every decision by an agent requires the biggest and most expensive model. Classifying an intent, extracting a data point, or deciding which tool to use can be resolved with a small, specialized model (SLM), reserving the higher-capacity models only for the steps that truly demand deep reasoning. This tiered architecture, in which each step uses the model proportional to its difficulty, is usually the biggest source of savings with no perceptible loss of quality.
A large part of what an agent sends to the model is repeated: the same system instructions, the same tool descriptions, the same background knowledge. Caching those components avoids paying to reprocess them on every call. Add to that caching responses to frequent questions, so the agent does not reason from scratch about a case already resolved.
An agent with no ceiling is a financial risk. It is worth setting explicit limits: maximum number of steps per task, token cap per session, budget per user or per flow, and mechanisms that stop an agent trapped in a loop. These limits not only contain cost, they also prevent degraded behaviors that ruin the experience.
Many costs are eliminated before choosing a model. Shortening prompts, pruning irrelevant history, giving the agent only the tools it needs, and structuring the task so it reaches the answer in fewer steps reduces spend at the root. A well-designed agent is, almost always, a cheaper agent.
It would be a mistake to reduce all this to switching off spend. The goal of FinOps for agentic AI is that every dollar invested in agents translates into measurable value and that decisions about AI are made with data, not with jolts on the bill. That implies constant collaboration between three areas that rarely used to talk: engineering, finance, and the business.
This governance rests on a well-managed cloud foundation. The cost discipline the organization built in its cloud infrastructure is the natural starting point for extending FinOps to AI spend, and agent adoption works best when it is embedded in a deliberate AI-first strategy rather than in scattered initiatives.
Because an agent does not execute a fixed number of calls. It resolves each task with a reasoning loop whose length depends on the complexity of the case, the accumulated context, and the retries. Two similar requests can cost very differently, and that is why cost is better estimated per task than per isolated call.
Not necessarily. The key is to assign the right model to each step: a small, specialized model is enough for classification, routing, or extraction tasks, while the large models are reserved for complex reasoning. Well applied, this tiered architecture reduces costs without the user perceiving any loss of quality.
With attribution. Before optimizing, it is worth tagging spend per agent, per task, and per model to discover where the cost really concentrates. Almost always a few agents or flows explain most of the bill, and that is where the first and biggest opportunities are.
It shares the principles of visibility, attribution, and accountability, but adds a new dimension: the variable, non-deterministic cost of each agentic task, along with its own levers such as context caching, routing between models, and step limits. It is an extension of traditional FinOps, not a replacement.
Spend on AI agents has stopped being an engineering detail and become a leadership conversation. The good news is that control begins with a bounded exercise: instrument visibility per agent and per task, identify where the cost concentrates, and apply the first optimization levers. From there, spend stops being a surprise and becomes a decision. If your organization is scaling agents and wants every dollar invested in AI to translate into measurable value, at SUMāTO we can help you build that governance. Let's talk about your FinOps strategy for agentic AI.