Why AI spend needs to be attributable, not just visible

The monthly cloud bill lands and the AI line item has tripled. Finance asks why. Security asks who. The platform team pulls up the usage dashboard they turned on three months ago, the one everyone was proud of, and it shows a single number: total spend across every model call that month. It does not show which team made the calls, which project they belonged to, or whether the spend was expected. Three people are now in a meeting trying to reconstruct an answer from memory.

This is not a tooling gap. It is the gap between visibility and attribution, and most enterprises are standing in it as we speak. 

Can we connect our identity systems to the AI gateway to get a real-time feedback loop on cost?

Yes, and that connection is the easy half of the problem. The hard half is making the resulting data mean something to the team that generated it, before the invoice arrives rather than after.

Wiring an identity provider into a gateway tells you whose credential made a call. That is necessary, but it is not attribution. Attribution means a dollar of spend is traceable to a unit of work a budget owner actually recognizes: a team, a project, a cost center, a piece of work in progress. Most organizations have the first part and not the second, which is why the dashboard can answer “how much” and nobody can answer “why” or “was that worth it.”

Visibility was always going to come first

Totals are cheap to build and satisfying to look at. A chart that goes up and to the right gives the appearance of control. It is also, on its own, close to useless for governance, because a number without an owner cannot be managed. Nobody adjusts behavior in response to a total they are not personally responsible for.

Enterprises evaluating AI and MCP gateways keep arriving at a version of the same ask, in different words: route cost data back through the identity and cloud systems we already run, so a team sees what its own work costs while the work is happening, not in a report a month later. Some ask for it at the level of a work package or an arbitrary internal cost-center ID, not just a user or a group. Others ask for the ability to say, plainly, that a given task cost a specific, attributable amount, the same way a cloud bill attributes a server’s cost to the team that provisioned it.

That is a different and harder ask than a dashboard, and it is the one that actually changes behavior.

Why attribution is harder than it looks

Attribution requires identity to survive every hop a request makes, not just the first one. A person prompts an agent. The agent calls a model. The model’s response triggers a tool call. The tool call touches a system that costs money to run. If the identity that started that chain gets dropped anywhere along the way, by the time the bill is generated, the only thing left to blame is a service account or a shared API key, and service accounts cannot be asked why they spent what they spent.

This is also why bolting cost tracking onto an existing proxy after the fact tends to produce wrong numbers rather than no numbers, which is worse. A configuration that drifts from how spend is actually occurring doesn’t fail loudly. It fails by quietly mis-attributing cost until someone downstream makes a decision based on bad data.

What attribution actually requires

One gateway every model call passes through, tied to a real identity provider. If some traffic reaches models directly and some goes through a gateway, you have two sources of truth and neither is complete. Stacklok’s AI Gateway, generally available today, is built to be the single path, integrated with identity providers like EntraID and Okta, so a model call carries a real identity rather than a shared key from the moment it is made.

Audit and usage data exported to the observability stack the team already trusts. Attribution data that lives in a vendor-specific silo gets checked rarely and trusted less. Audit logging and OpenTelemetry traces flowing into Splunk, Datadog, Grafana, or New Relic mean a cost question gets answered inside the tools a platform or security team already has open, not a new login they have to remember exists.

One governance model for model spend and tool spend together. Agent and MCP tool-call activity drives cost the same way model calls do, and treating the two as separate investigations means running the same reconciliation exercise twice. A single governance model for agent and MCP access, where identity, policy, and audit data flow through one system rather than two, is what makes a unified answer possible instead of two partial ones that have to be manually stitched together.

None of this is exotic. It is the same discipline cloud infrastructure teams already apply to compute spend, applied to AI spend a few years later than it probably should have arrived.

What to do this quarter

1. Put every path to a model behind one gateway tied to your identity provider. A direct API key issued “just for now” is the thing that breaks attribution six months from now. Close that door before it becomes a habit.
2. Pick one team and make attribution to a real cost center a condition of broader model access. A forcing function changes behavior faster than a policy document that nobody reads until an audit.
3. Route audit and usage data into the observability stack your security team already watches. If finding a cost answer requires logging into a system built only for this purpose, people will stop checking it within a month.
4. Treat agent and tool-call spend as part of the same governance conversation as model spend, not a separate budget line owned by a different team with a different dashboard.
5. Ask whether your current setup can answer “which team, which project, why” for last month’s bill. If the honest answer is no, that gap is this quarter’s work, not next year’s.

Where to start

Multiple Global 2000 enterprises with thousands of active users have already run into this exact wall: a usage dashboard that is accurate and still useless, because accuracy and attribution are not the same property. The fix starts with identity, not with a better chart.

Stacklok’s forward-deployed engineers work with platform teams directly, on the Kubernetes infrastructure those teams already run, to wire identity, the AI Gateway, and the observability stack together so that spend is attributable from day one rather than reconstructed after the fact.