The cloud taught us a discipline: treating spend as a first-class metric, measured, attributed, steered. Agentic AI reintroduces the problem in a new form. An agent’s cost is not fixed: it varies on every run, depends on the path it takes, and stays invisible until the bill arrives. And it is now counted in two currencies: money and energy.
FinOps applied to agentic AI is about bringing that variable cost under control, with the same reflexes as for the cloud: measure per run, attribute to a use case, cap before things drift. Here is how we put it in place.
Why an agent’s cost is deceptive
A model call has a known price per token. An agent does not. Between the request and the answer, it can call several tools, restart a line of reasoning, retry after a failure, or spin in a loop. Two runs of the same case can cost anywhere from one to three times as much. Cost is therefore not a property of the agent, but of each run.
This variability has a sneaky side: it goes unnoticed while volumes are low, then climbs at the exact moment the agent succeeds and spreads. An adopted agent is an agent that costs money, and adoption is precisely when an uncontrolled cost hurts most.
The right units of measurement
Cost per run
The first useful unit is not the monthly bill, but the cost of a single run: how much does one full pass of the agent over a case cost, on average and at worst? This unit lets you compare an agent to the manual alternative, set a budget per use case, and spot a cost regression as fast as a quality regression.
Tokens, in detail
Monetary cost breaks down into input and output tokens, step by step. This detail is not cost accounting for its own sake: it shows where the money goes. A context that is too large and reloaded at every step, a tool that returns verbose responses, an oversized system prompt: these wastes are invisible without per-token measurement, and often easy to fix once seen.
In practice, per-token measurement almost always exposes the same culprit: context. As an agent chains steps, it drags along a history that grows and that it pays for on every call. Trimming that context to what is strictly needed, and summarising it rather than replaying it in full, is often the fastest saving, before even touching the model or the tools.
Watt-hours and gCO2e
The second currency is energy. Every run consumes electricity and emits CO2. Tracking Wh and gCO2e per run is not only an extra-financial reporting requirement: it is a design signal. A leaner agent is almost always a faster and cheaper one, because time, money and energy are correlated. AI sobriety is not a nice-to-have, it is an indicator of good engineering.
Attribute, then cap
Measuring is not enough if cost attaches to nothing. Every run must be attributed: which agent, which use case, which team. Without that attribution, a global bill does not tell you what to fix.
Then you cap. A budget per agent and per use case, a ceiling beyond which the agent stops rather than keep spending, a kill switch in case of drift. These guardrails are not comfort options: they are the same ones that make an agent acceptable in production, described in our evaluation framework. An agent with no cost ceiling is as unready as an agent with no limit on its actions.
The most effective lever: the right model in the right place
The heaviest cost item is often the choice of model. Routing simple cases to a fast, cheap model and reserving the heavy models for the tasks that justify them cuts the bill by a large factor with no perceived loss of quality. That is a topic in its own right, which we will cover in an upcoming article. The point here is that a good FinOps setup makes that choice measurable: without cost per run broken down by model, you route blind.
Sobriety as a design parameter
Boiled down, FinOps for agentic AI is about making cost, both monetary and energy, a first-class metric, on par with quality or latency. Measured per run, attributed to a use case, capped by a budget, that cost stops being an end-of-month surprise and becomes a design parameter.
This discipline fits within our industrialisation method: an agent put into production without knowing what it costs, or how to stop it if it drifts, is not industrialised, it is merely deployed. And it builds concretely on the observability and cost tracking of the execution layer, which provide the measurement without which none of this is possible.
Do you want to make the cost of your AI agents visible and controlled? Let’s talk.