Google Cloud’s newest AI agent billing controls, shipped this August, lead with a hard project-level spend cap: hit the limit and the agent’s API calls pause, with alerts firing at 50, 80, and 100 percent of budget. That is a chargeback-grade enforcement mechanism, bolted onto a project that may still be sharing one invoice across three teams. It stops runaway spend well. It does not tell a product team whether its AI feature is worth what it cost, because a spend cap only ever answers how much a project used, never whose feature drove it.
The same gap shows up without any billing feature at all. Finance’s spreadsheet has the quarter’s total AI spend and none of the per-team split. Engineering can produce that split from the usage export, but it lives in a query nobody in finance can run, so the number arrives late, if it arrives before the invoice does. Whichever way a team’s allocation reaches it, if it lands as a bill before it ever landed as a report, the team fights the bill instead of checking the math.
Chargeback bills a team’s budget for its share of AI spend. Showback reports that same number without moving any money. Every FinOps program that has actually run both agrees on the order: showback first, long enough to survive a team disputing the number, then chargeback once it does.
Showback and chargeback, named
The FinOps Foundation groups both under its Allocation capability, alongside the Allocation Accuracy Index (AAI): the share of total infrastructure cost attributed directly and correctly to the team, project, or business unit that drove it. Showback and chargeback are two ways of acting on that number once it exists, not two names for computing it.
Showback reports a team’s AI spend against their usage, visible in a dashboard or a monthly email, with no budget transfer attached. Its job is to build agreement that the number is right before anything financial rides on it.
Chargeback moves the dollars: the team’s cost center is billed for its attributed share, and that share now shows up in their P&L. Chargeback only works once a number has survived being looked at.
Both depend on the same attribution math. A shared model endpoint allocated wrong under showback is a dashboard nobody trusts. The same error under chargeback is a disputed invoice, and disputed invoices are where allocation models go to die.
Six things that make AI spend harder to allocate than plain cloud spend
Cloud allocation had a known answer: tag the resource, bill the tag. AI spend breaks that pattern in specific, nameable ways.
| Driver | Why it breaks simple allocation | The fix |
|---|---|---|
| Shared model endpoint | Multiple features call the same deployed model; the invoice has one line for all of them | Tag at the request level by feature, not by account or endpoint |
| Prompt caching | A cached read’s discount belongs to whichever call warmed the cache, not the one that benefits from it | Attribute by measured cache-hit ratio per feature, not an even split |
| Agent-to-agent calls | An orchestrating agent triggers calls against models another team owns and pays for | Attribute to the task’s initiating feature, not the model’s nominal owner |
| Provisioned throughput pools | One reserved pool serves several applications, so idle capacity has no natural owner | Allocate by measured throughput share, re-measured monthly, not by headcount |
| Retries and fallback routing | A failed call to a cheap model retried on an expensive one lands its cost with the retry, not the original request’s budget | Count retries and fallbacks against the feature that triggered the original request |
| Batch API jobs | Run on a schedule a platform team owns, on behalf of five product teams’ data | Allocate by the job’s declared owner tag, enforced at submission, not inferred after the fact |
Three of these (shared endpoints, provisioned pools, and retries) are the same cost drivers covered in what one AI request actually costs; this is the allocation side of those same drivers, not a repeat of the arithmetic. Agent-to-agent calls get worse as orchestration gets deeper, which is also why what an AI agent costs to run treats cost per resolved task, not per request, as the real unit: allocation has to follow the same unit or it undercounts the task that actually consumed the budget.
Why showback has to come first
A team that has watched its own number for a full budget cycle accepts it, because they had time to argue with it while nothing was at stake. A team billed cold on the first cycle fights the bill, and the fight is rarely about the arithmetic. It’s about being handed a number they’ve never seen, calculated by a team they don’t work with, for a shared endpoint that became “their” cost the same week finance decided it should be.
Google Cloud’s own spend-cap mechanism is the visible version of skipping this step. A hard cap pauses an agent’s calls the moment a project crosses its limit, no dispute window, no chance to check the attribution first. That is the right control for stopping a runaway agent. It is the wrong first control for a team encountering its AI allocation for the first time, because the first thing it teaches them is that the number can hurt them before they’ve been able to trust it.
Run showback for at least one full budget cycle on any new allocation before a dollar moves under it.
When to switch from showback to chargeback
Four signals, not a calendar date, mark readiness:
- The number has survived a dispute. At least one team has challenged the allocation and the re-run produced the same answer, or a documented correction.
- Authority matches the bill. The team being charged holds the lever that changes the number, model choice, cache configuration, retry policy, not just the workload that triggers it.
- A reconciliation process exists in writing. Not “email finance”; a documented path to re-run a disputed number and get a real answer inside a known number of business days.
- The allocation grain matches the decision. If chargeback bills at the account level but the decision that would change the number lives at the feature level, chargeback will bill the wrong team for the right reason.
Miss any of the four and chargeback converts a math problem into a trust problem, which is a worse problem to have.
Choosing an allocation model by product shape
Not every AI workload allocates the same way, even inside one company.
| Product shape | Allocation difficulty | Recommended model |
|---|---|---|
| Dedicated model deployment, one team | Low: usage and cost already map to one owner | Chargeback directly; showback adds little |
| Shared model endpoint, several features | High: needs request-level tagging before either model works | Showback first, chargeback once tagging is verified |
| Multi-tenant RAG index | High: retrieval cost and generation cost often split across different owners | Showback on both halves separately; chargeback only the half a team actually controls |
| Agentic workload with sub-agent calls | Highest: cost accrues across a call chain that can cross team boundaries mid-task | Showback at the task level (cost per resolved task) before any chargeback conversation starts |
The mistake: chargeback on a number nobody has seen
The mistake is skipping straight to chargeback on a newly shared model endpoint because finance wants the budget line closed this quarter. The bill goes out, the receiving team has never seen the allocation methodology, and the first response is not “let’s check the caching math.” It’s “why are we suddenly paying for a service two other teams also call.” The symptom is a chargeback model that gets renegotiated, informally, in every budget meeting for the next two quarters, because nobody trusted the first invoice enough to stop arguing about it.
The rule
Never chargeback a number a team has not already seen as a report. Showback is not a courtesy step before the real control. It is the step that makes the real control survivable.
This piece describes allocation mechanics, not accounting treatment. Whether AI spend gets capitalized or expensed, and how a chargeback shows up in a team’s P&L versus a cost center, is a question for your finance and legal team, not this page.
FAQ
What’s the difference between chargeback and showback?
Showback reports a team’s AI spend against their usage without moving any money; chargeback bills that same amount to the team’s budget. Both rely on the same underlying attribution math. The difference is what happens once the number exists, not how it gets calculated.
Should AI teams start with chargeback or showback?
Showback first. FinOps programs that have run both agree on the sequence because a team that has watched its own number for a full cycle accepts it, while a team billed cold on day one disputes the bill instead of checking the underlying math.
How long should showback run before switching to chargeback?
At least one full budget cycle, and longer if the allocation covers a shared model endpoint or an agentic workload with cross-team calls. The signal to switch isn’t a date; it’s a number that has survived a real dispute and a documented process for re-running it.
How do you allocate cost for a shared AI model endpoint?
Tag at the request level by the feature that triggered the call, not by account or endpoint, since the endpoint itself serves several features at once. Cache hits, retries, and fallback routing all need to be attributed to the originating feature specifically, or the allocation undercounts whichever team’s traffic drives the shared cost.
What is the FinOps Allocation capability?
A capability in the FinOps Foundation’s framework covering how cost gets attributed to the team, project, or business unit that drove it, measured in part by the Allocation Accuracy Index. Chargeback and showback are both downstream of this capability; neither works if the underlying attribution is wrong.
Does prompt caching affect chargeback accuracy?
Yes. A cached response’s discount belongs to whichever team’s call benefited from the cache hit, not the call that happened to warm it first. Splitting that credit evenly across teams, instead of by measured cache-hit ratio per feature, is a common source of disputed chargeback numbers on shared endpoints.
What to do next
Pick one shared endpoint, run showback on it for a full budget cycle with request-level tagging by feature, and don’t convert it to chargeback until a disputed number has survived a re-run. When the allocation model needs to become a reporting path finance runs without an engineer in the room, that’s the engagement on FinOps consulting for AI products. The rest of the FinOps for AI practice is on the home page.
I put a number on what an AI product costs per request, per active user, and per subscriber, early enough to change the model, the architecture, or the price. If you’re shipping something with a model behind it and nobody can tell you what it costs, email me.
Have a number nobody can explain?
Send a note and I will get back to you.