A shared agent serving five business units inside a $2B enterprise quietly cost $40,000 a month, billed to nobody. It sat under an "AI Platform" cost center for nine months, accumulating spend that nobody noticed because no business unit's P&L took the hit. When the platform team finally proposed expanding the agent's scope, the CFO asked the only relevant question — "what does each BU actually consume?" — and the answer was a long silence. The platform team did not know. The budget was unfunded. The expansion proposal died. The agent itself was suspended within 60 days because no BU would absorb the cost when it finally got attributed to them. This is the most common failure mode in shared agent FinOps in 2026: an agent that delivers value across multiple consumers but has no attribution layer, no chargeback mechanism, and therefore no economic ownership. This lesson is the strategist's blueprint for solving it. Per-call tagging at the gateway, allocation to a chargeback ledger, monthly reconciliation, three legitimate allocation patterns (proportional by token, proportional by resolved task, capitation by seat), and the chargeback policy document plus sample monthly statement that BUs will actually pay. By the end you will be able to build the attribution layer from scratch in 4-6 weeks and have a defensible answer when the CFO asks who pays for the agent.

Why Shared Agents Become Unfunded

The pattern is predictable. An AI platform team builds a useful agent — a knowledge-base Q&A bot, a sales-enablement assistant, a customer-service drafter — that multiple BUs want to use. The platform team is heroic and ships it. Marketing uses it. Sales uses it. Customer success uses it. Finance uses it. The agent's spend grows: $3K/month initially, $8K by month 3, $22K by month 6, $40K by month 9. The platform team absorbs all of it because (a) the platform team's budget already exists, (b) the platform team wants adoption, and (c) nobody has built the attribution mechanism that would push the cost back to consumers.

By month 9, three problems compound. First, the platform team's budget is overrun and they're explaining to the CIO. Second, no BU has a line item for the agent in their FY budget because they never paid for it. Third, the agent's growth is uncapped because there's no consumer-side cost discipline — every BU treats it as free.

The CFO conversation that ends the agent goes like this: "How much does this cost? $40K/month. Who pays? AI Platform. Who uses it? Five BUs. What's each BU's consumption? We don't know. Then we can't fund the expansion. Wind it down." The agent dies not because it lacks value but because it lacks economic ownership.

An unfunded shared agent is not a free agent. It is a credit-card balance accumulating against the AI Platform's P&L until someone notices. By the time someone notices, the agent's death is usually faster than its rescue.

The fix is attribution. Attribution turns a shared agent from a platform-team cost into a multi-tenant utility that bills consumers monthly. Once consumers have a line item, two things happen: BUs participate in cost discipline (less casual use, more thoughtful use), and the agent has multiple funded sponsors instead of one orphan owner.

The Attribution Layer: Three Pieces

A complete attribution layer has three pieces. Each is necessary; none alone is sufficient.

Piece one: per-call tagging at the gateway

Every model call the agent makes must carry tags identifying who it's for. At minimum: tenant_id (which BU or customer), agent_id (which agent in the portfolio), use_case_id (what the agent is doing), user_id (who triggered it, for forensics). These tags must be enforced at the gateway — not optional headers that some calls have and others don't.

The tagging mechanism: most modern gateways (Portal26, LiteLLM, Helicone, Portkey) support metadata fields on API calls. The application code that invokes the agent sets the tags; the gateway logs them with the call. Calls without required tags are either rejected (strict mode) or assigned to a fallback "unattributed" tenant (lenient mode for migration). Production should be strict mode.

Piece two: chargeback ledger

A data store that aggregates the per-call cost data into per-tenant, per-period totals. Typically a daily-rollup table in a data warehouse (Snowflake, BigQuery, Databricks) with columns: tenant_id, agent_id, use_case_id, date, total_input_tokens, total_output_tokens, total_cost, call_count, resolved_task_count. The ledger is the source of truth for chargeback amounts. It feeds invoices, reports, and the FinOps dashboard.

Piece three: monthly reconciliation

The process that turns ledger data into actual BU charges. Each month: aggregate ledger by tenant, apply the chosen allocation pattern (covered below), generate a statement per BU, push to finance for posting against BU cost centers. The reconciliation is the artifact that makes attribution real — without it the ledger is just a log file.

The Three Allocation Patterns

Once you have tagged calls and a ledger, the next question is how to actually allocate the cost. Three patterns are legitimate in 2026. Each has different fairness properties and operational complexity.

Pattern one: proportional by token

BU's monthly bill = (BU's total tokens consumed / org's total tokens consumed) * total agent cost.

• Fairness: Heavy token users pay more. Light users pay less. Direct correlation with vendor cost.
• Operational complexity: Low. Sum tokens per tenant, divide, multiply.
• Best for: Agents where token consumption is the primary cost driver (most modern agents). Agents where BUs have wildly different usage patterns (some heavy, some light) and the allocation needs to reflect that.
• Failure mode: Doesn't account for human review labor, overhead, or shared infrastructure. May feel unfair if BU A's queries are technically expensive but produce less business value than BU B's lightweight queries.

Pattern two: proportional by resolved task

BU's monthly bill = (BU's resolved tasks / org's resolved tasks) * total agent cost (including labor and overhead).

• Fairness: Tied to business value delivered, not technical consumption. BUs pay for outcomes, not inputs.
• Operational complexity: Medium. Requires defining "resolved task" cleanly and tagging it per call.
• Best for: Customer service agents, sales-enablement agents — where the unit of value is well-defined (resolved ticket, drafted email). Stakeholder-friendly because BU heads understand "we paid for 8,400 resolved tickets at $X each."
• Failure mode: Requires consistent task definition. Two BUs may have different idea of "resolved." Disputes follow.

Pattern three: capitation by seat

BU's monthly bill = (BU's authorized seats / org's authorized seats) * total agent cost. Often plus a usage overage fee for BUs that exceed a per-seat usage cap.

• Fairness: Predictable. BUs know their bill in advance. Encourages adoption since marginal use is "free" up to the cap.
• Operational complexity: Low to medium. Maintain seat list, calculate share, optionally compute overages.
• Best for: Knowledge-base agents, copilot-style agents — where the value is "access" rather than "outcome volume." Compatible with M365 Copilot, Agentforce per-user pricing models.
• Failure mode: Heavy users effectively subsidize light users. Light-using BUs may complain they're paying for capacity they don't use. Plus there's a temptation to grant seats casually if there's no cost discipline at the seat level.

Which pattern to pick

The strategist's job is to pick the pattern that matches the agent's economics and the org's culture. Most companies in 2026 land on a hybrid: proportional by resolved task as the headline allocation, with a small capitation base (each BU pays a flat $1K/month for "shared platform overhead" regardless of usage) and a token-overage clause for BUs that exceed a fair-use threshold. The hybrid satisfies the three constituencies: BUs want predictability (capitation base), CFOs want fairness (proportional usage), platform teams want to fund infrastructure (overhead base).

The Chargeback Policy Document

The artifact that makes chargeback real and defensible. Three pages, signed by the CFO and the platform owner. Outline:

Section 1: Scope and definitions

• Which agents are subject to chargeback (list)
• What counts as a "tenant" (BU, customer, project — define)
• Definitions: "resolved task," "active seat," "billable call"
• What is included in the chargeback total (LLM tokens, retrieval, gateway overhead, eval, on-call) and what is excluded (platform development cost, eval set authoring — typically platform absorbs)

Section 2: Allocation methodology

• The chosen pattern (proportional by resolved task with capitation base, for most companies)
• The formula: written out explicitly
• How edge cases are handled: unattributed calls, calls during outages, retries
• How rates are set: cost-recovery basis (platform breaks even), markup basis (platform funds future development), or subsidy basis (platform absorbs some)

Section 3: Operational mechanics

• Monthly reconciliation cadence (typically last business day of month, statement issued by 5th of following month)
• Statement format (sample provided)
• Dispute process and SLA (BU has 15 days to dispute; platform resolves within 30)
• How disputes are resolved (audit the call logs)
• Annual rate review (compare actual costs to recovered amounts; adjust rates)

Section 4: Signatures

CFO. Platform owner. Each BU finance lead. Without signatures the policy is a draft.

The Sample Monthly Statement

What the BU finance lead actually receives on the 5th of every month. One page. Concrete.

To: Sarah Chen, Finance Lead, Sales BU
From: AI Platform Chargeback, Finance Operations
Period: April 2026
Statement #: SLS-2026-04

Summary

• Agent: Sales Enablement Drafter (sales-drafter-v3)
• Resolved tasks this period: 4,287
• Active seats: 78
• Total amount: $11,420

Detail

• Proportional task allocation: 4,287 tasks * $2.40/task = $10,289
• Capitation base (platform overhead): $1,000
• Token overage (exceeded 2.5M token fair-use band by 18%): $131
• Subtotal: $11,420

Comparison to prior period

• March 2026 amount: $9,840
• Change: +$1,580 (+16%)
• Driver: Resolved task count up 14% (4,287 vs 3,762)

Trend

(Mini chart showing monthly amount Jan-Apr.)

Top consumers within your BU

• EMEA Outbound Team: $4,820 (42%)
• SMB Inside Sales: $3,290 (29%)
• Enterprise Strategic Accounts: $2,180 (19%)
• Other: $1,130 (10%)

Posting

Cost center: 4220 (Sales Operations)
GL account: 7340 (Internal Service - AI Platform)
Posting date: May 1, 2026

Disputes

Reply to [email protected] by May 20 if disputed.

This format works because Sarah Chen recognizes every part of it. Tasks resolved is a metric she tracks. Comparison to prior month is what she does for her own BU's spend. Cost center is what she posts in. The statement reads like every other internal service chargeback she sees from IT, Real Estate, and Legal. The agent has been normalized as just another internal service.

The Four-to-Six-Week Build Plan

For a strategist with no current attribution layer, the build looks like this.

Week 1: Tagging audit and gateway config

• Inventory which agents are shared (multi-BU consumers) vs single-tenant.
• Confirm gateway supports per-call metadata tags (Portal26, LiteLLM, Helicone all do).
• Define the tag schema: tenant_id, agent_id, use_case_id, user_id, optional task_id.
• Configure gateway to require tags on production calls.

Week 2: Application instrumentation

• Each application that calls the shared agent must set tags. Code change per consumer.
• For Slack/Teams agents: pull tenant_id from workspace ID. For web apps: from session. For batch jobs: from job config.
• Test in staging. Verify tags appear in gateway logs. Verify rejection on missing tags.

Week 3: Ledger build

• Pipeline that pulls gateway logs daily, aggregates per tenant/agent/use_case/date, writes to data warehouse.
• Schema: tenant_id, agent_id, use_case_id, date, input_tokens, output_tokens, cost_usd, call_count, task_count.
• Verify reconciliation against vendor invoice (totals should match within rounding).

Week 4: Allocation engine

• SQL or scheduled job that runs monthly: pulls ledger, applies allocation pattern, generates per-tenant statements.
• Output: one row per BU per month with total, breakdown, comparison to prior period.
• Review with finance to confirm format matches existing internal chargeback templates.

Week 5: Policy doc and stakeholder review

• Write the policy document (template above).
• Circulate to CFO, platform owner, BU finance leads.
• Collect feedback. Iterate. Get signatures.

Week 6: First production reconciliation

• Run the first monthly statement for the prior month.
• Send to BU finance leads.
• Field disputes. Refine process based on first-month feedback.

Typical total effort: 8-12 engineering days plus 3-5 days of finance/policy work. Cost: roughly $25K-$50K in engineering time. The unfunded $40K/month agent pays for the build in the first month.

The Multi-Tenant SaaS Case

Some shared agents serve external customer tenants (a SaaS company with a built-in AI feature serving 200 customer accounts). The mechanics are the same but the use case is different: the chargeback ledger feeds the SaaS company's own revenue analytics and cost-per-customer dashboard, and informs pricing decisions.

The key questions in the multi-tenant SaaS case:

• What is each customer's actual AI cost? (per-call tagging on tenant_id at the gateway)
• Which customers are unprofitable on AI alone? (cost > pricing)
• Should pricing tiers be restructured? (data informs the decision)
• Should the heaviest users be moved to a usage-based pricing model? (data shows whether usage correlates with revenue)

The infrastructure (tagging, ledger, allocation) is identical. The output goes to product and revenue ops instead of finance chargeback. The strategic value is the same: ensuring economic ownership of the agent's cost.

The Failure Modes to Watch

Five failure modes that quietly destroy attribution.

Untagged calls accumulating

Some application doesn't set tags. Calls flow through to gateway, accumulate in an "unattributed" bucket. By month 3 the unattributed bucket is 15% of total spend, allocated to nobody. Mitigation: gateway in strict mode rejecting untagged calls; weekly review of unattributed percentage.

Tag drift

Tenant IDs change as BUs reorganize. Old tags don't match new structure. Allocation gets confused. Mitigation: tag schema versioning; quarterly review with each BU to confirm tagging matches their org structure.

Disputed allocations going stale

A BU disputes a $4K charge. Platform team is busy. Dispute sits open for 5 months. BU stops paying entirely. Mitigation: dispute SLA in policy (resolve within 30 days), tracked in FinOps quarterly review.

Capitation race

With capitation, BUs add seats casually because "marginal use is free." Total seat count grows 3x, capitation rate per seat drops, light users now subsidize heavy users more. Mitigation: per-seat usage cap with overage; periodic seat audit.

Cost-recovery vs markup confusion

BUs assume chargeback is at cost; platform team is marking up 30% to fund development. When BUs find out, trust collapses. Mitigation: explicit disclosure in policy doc. Either cost-recovery or markup is fine, but it must be documented and disclosed.

When Attribution Is Overkill

Not every agent needs full chargeback infrastructure. The threshold is roughly $5K-$10K/month in shared agent spend. Below that, the cost of the attribution layer exceeds the savings from cost discipline. Above it, attribution pays for itself.

For agents below the threshold, the lightweight alternative: simple monthly reporting (here's what each BU consumed last month, no formal billing) creates awareness without operational overhead. When the agent grows past the threshold, upgrade to full chargeback.

For single-tenant agents (only one BU uses it), attribution is unnecessary — that BU is the funder. Put the agent in that BU's budget.

The CFO Test

The strategist's attribution layer passes the CFO test when the answer to "what does each BU consume?" takes 30 seconds to produce and lines up with the monthly invoice. If the answer requires an analyst running queries for two days, attribution is not real. If the answer doesn't reconcile to the vendor bill, the ledger is wrong. The CFO test is the only test that matters because it is the test that decides budget.

Key Takeaways

• The most common failure mode in shared agent FinOps in 2026: an agent that delivers value across multiple consumers but has no attribution layer, accumulates $40K/month of unfunded spend, and dies when the CFO finally asks who pays.
• Attribution turns shared agents from platform-team orphans into multi-tenant utilities with funded sponsors. Three pieces: per-call tagging at the gateway, chargeback ledger in data warehouse, monthly reconciliation that posts to BU cost centers.
• Three legitimate allocation patterns: proportional by token (heavy users pay more, simple math), proportional by resolved task (tied to business value, stakeholder-friendly), capitation by seat (predictable, encourages adoption).
• Most companies land on a hybrid: proportional by resolved task as headline, small capitation base ($1K/month per BU) for shared overhead, token overage clause for fair-use violators. Satisfies BUs (predictability), CFOs (fairness), and platform (infrastructure funding).
• Per-call tagging requires gateway in strict mode (reject untagged calls) with required fields: tenant_id, agent_id, use_case_id, user_id, optional task_id. Calls without tags accumulate in an unattributed bucket that destroys credibility.
• The chargeback ledger lives in the data warehouse (Snowflake, BigQuery, Databricks). Daily rollup of per-tenant cost and call data. Source of truth for invoices.
• The monthly statement is the artifact BU finance leads actually pay. One page. Tasks resolved, allocation breakdown, comparison to prior period, top consumers within the BU, posting details. Reads like every other internal service chargeback.
• The chargeback policy document — three pages, signed by CFO and platform owner — defines scope, allocation methodology, operational mechanics. Without signatures the policy is a draft and disputes never resolve.
• 4-6 week build plan: week 1 tagging, week 2 instrumentation, week 3 ledger, week 4 allocation engine, week 5 policy doc, week 6 first reconciliation. Total effort 8-12 engineering days plus 3-5 finance days. Cost $25K-$50K — the unfunded $40K/month agent pays for the build in month one.
• Five failure modes to watch: untagged calls accumulating, tag drift as BUs reorganize, disputes going stale, capitation race inflating seat count, cost-recovery vs markup confusion. All preventable with policy discipline and quarterly review.
• Attribution is overkill below $5K-$10K/month shared spend; use lightweight monthly reporting instead. Above threshold, attribution pays for itself in the first month. The CFO test: 30 seconds to answer "what does each BU consume," reconciled to the vendor bill.