The problem isn’t that AI teams lack cost data. It’s that the token dashboard and the cloud bill describe different systems, owned by different teams, with no reliable way to connect them.
A support agent may resolve one ticket after five model calls, a retrieval step, two tool calls, and a retry. The business records one completed case. The infrastructure records a scatter of requests, pods, memory, accelerator time, and shared services. Until those records meet, cost optimization is partly guesswork.
Why Do Token Metrics and Cloud Bills Tell Different Stories?
Token counts are useful. They show how much text a model received and returned, and they help teams compare prompts, models, or routing choices. But they don’t tell you what happened around the model call, how much compute supported retrieval and tool use, how many failed attempts came first, or whether the final result did anything useful.
The State of FinOps 2026 shows how quickly AI moved into ordinary FinOps work: 98% of respondents now manage AI spend, versus 63% in 2025. But a bigger budget line still doesn’t tell you which workflow burned the money or why.
Two document-processing jobs can use roughly the same number of tokens. One may finish with a single model request. The other may retrieve context from several stores, call an external service, fall back to another model, and run the document again after a failed validation check that the user never sees. The token totals look similar while the execution paths do not.
Unite.ai has already examined why token counts don’t automatically represent business value. The next step is to connect those counts to the workloads that produced them. Otherwise, a team can improve cost per token while making cost per completed task worse.
What Does a Complete Cost Chain Look Like?
A useful cost chain starts with the outcome the business cares about. That might be a resolved support case, a processed document, an accepted code change, or a completed agent workflow. Everything below it needs an identity that can be followed through the system.
The application layer provides the first connection. A request ID, trace ID, workflow name, or conversation ID can tie several model and tool operations to one piece of work. Without that thread, ten related events look like ten unrelated charges.
The OpenTelemetry conventions for GenAI agents offer an emerging vocabulary for this layer. They cover operations, providers, requested models, agents, conversations, token usage, tool execution, errors, and workflows. The conventions are still marked as under development, so teams shouldn’t treat them as a finished universal standard. They are useful because they make the correlation problem concrete.
Then comes infrastructure. AWS’s split cost allocation data for EKS can assign shared compute and memory costs to Kubernetes pods and expose details such as cluster, namespace, deployment, node, workload name, and workload type. For supported accelerated instances, the data also covers GPU, Trainium, and Inferentia reservations.
That’s the other half of the chain. A trace can explain what the application tried to do; Kubernetes allocation can show which resources carried the work. Unite.ai’s guide to deploying and monitoring LLMs on Kubernetes provides the wider production context, including resource allocation, scaling, and observability.
The join won’t happen by accident. Teams need a stable identifier that survives long enough to connect application telemetry with workload labels, allocation records, or another mapping layer. Customer data doesn’t belong in Kubernetes tags. Teams should decide which low-cardinality identifiers can safely connect a workflow category, service, or feature to the resources it consumed.
Once that application context is in place, teams can start tracking Kubernetes costs by workload and connect namespace, CPU, memory, and GPU usage back to the work being performed. That still doesn’t tell you whether the workflow created business value, but it gives the infrastructure side of the calculation something concrete to attach to.
Which Unit Metric Should the Business Trust?
There is no single AI cost metric that every team should use. Cost per token answers a model-consumption question. Cost per pod answers an infrastructure-allocation question. Neither tells a product owner whether the feature is earning its keep.
The best denominator is usually the smallest outcome the business can define clearly, and the product team can influence. A support operation might track cost per resolved case. A document system might use cost per successfully processed file, while a coding assistant could examine cost per accepted change rather than cost per suggestion.
Success changes the math.
A workflow with a low cost per attempt may be expensive if it fails often, triggers repeated validation, or sends too many cases to human review. That is why teams should separate cost to attempt from cost to complete and, where possible, cost per accepted outcome. The last number is often the most useful because it includes the work the system produced but the business couldn’t use.
Agent systems make this harder because their paths can change from one run to the next. Unite.ai’s analysis of the economics of scaling agentic AI workloads covers routing, tool calls, retries, and workflow-level attribution. Those behaviors belong in the unit metric when they consume resources, even when the final user sees only one answer.
The metric still won’t be perfect. Shared services, cached results, batch jobs, and delayed processing can blur attribution. A decision-useful estimate is better than false precision, especially when it tells engineers which layer deserves investigation.
Who Owns the Number?
The hardest part may be organizational. ML teams understand model calls and evaluation. Platform teams understand workloads and cluster behavior. FinOps understands billing data and allocation rules. Product teams know which outcome matters.
No one team owns the full chain.
That creates a predictable argument over whose dashboard is correct. The ML team may point to lower token use, while the platform team sees GPU hours climbing and the product team sees fewer completed tasks than before. All three observations can be true at once. The shared metric has to explain the relationship between them.
A workable starting point is one production workflow with a clear completion event. Give it a stable identifier. Carry that context through the model and tool traces, map it to the service or workload running in Kubernetes, and choose one business denominator. Then bring the teams together when the number moves unexpectedly.
That review matters more than a polished dashboard. A sudden increase may come from longer prompts, a new fallback path, underused GPU capacity, a changed autoscaling policy, or a product decision that sends more work through the AI feature. Each cause belongs to a different owner.
Automation should come later. A recommendation engine can only act on the labels and thresholds it receives, and a bad denominator can make an efficient system look wasteful or reward a cheap workflow that users reject. Teams need enough shared visibility to distinguish model behavior from application design and infrastructure allocation before they let a system act on the result. Otherwise, an automated cost fix can reduce capacity, raise latency, and move the expense somewhere less visible.
The Cost Chain Has to Be Shared
AI cost control will stay fragmented as long as every team optimizes only the layer it can see. Tokens, traces, pods, accelerators, and invoices aren’t rival measurements. They are pieces of the same cost chain.
The companies that connect them won’t get a perfect number on day one. What matters is whether the team can trace a high bill back to the workflow that caused it, work out what changed, and decide if the result justified the cost.
