LLM Agent Cost Attribution Guide: Production 2026

Why Cost Attribution Goes Wrong in Production

The most common failure mode is not bad math — it's late instrumentation. Teams ship the first agent, defer attribution to "once we have traffic," and then spend a quarter retroactively joining Cloudwatch logs to customer records to figure out why gross margin ticked down four points. By the time the data is legible, the pricing conversation with the runaway customer is already awkward.

Three patterns account for almost every production cost incident we see across agency engagements.

• Averages hide distributions. Reporting cost-per-customer as an average papers over a long-tail where 3% of tenants consume 60% of tokens. Without percentile reporting the pricing team optimizes for fiction.
• Retry and tool-call loops go uncounted. Agents that loop through failed tool calls burn hundreds of prompt-cached reads. If your telemetry only counts the user-facing request, you're invisible to the actual burn rate.
• Free tiers are under-instrumented. Teams meticulously track paid-customer spend but treat free tier traffic as a lump. A poorly gated free tier can silently become the largest single line item.

Token Accounting at Four Layers

Every agent request consumes tokens across four distinct layers. Rolling them into a single "input tokens" bucket is the most common reason cost dashboards disagree with provider invoices.

The practical instrumentation shape is a four-column usage record per span: prompt_tokens, tool_tokens, memory_tokens, and response_tokens. Providers return a combined input count, so the split has to happen at your harness layer — count before packing the prompt, not after.

For current list prices across the major providers, reference our LLM API pricing index.

Attribution Dimensions

Three attribution dimensions cover almost every business question a well-run team needs to answer. Build them in parallel so the views can be rotated without re-instrumenting.

A fourth optional dimension, per-model, sits on top: tagging which model (and which effort level) served each span lets you compare effective cost-per-outcome across model choices without re-running traffic.

Prompt Cache Accounting

Prompt caching is the highest-leverage cost lever on any agentic workload with stable system prompts. It also breaks naive dashboards because cached-read and cached-write tokens price differently from standard input.

Track cache hit rate as a first-class metric. A healthy agentic workload with stable system prompts should see 70% or better cache hit rate; below 40% usually indicates prompt drift, unstable tool schemas, or a cache TTL issue that's worth fixing before optimizing anywhere else.

OpenTelemetry Instrumentation Reference

The OpenTelemetry GenAI semantic conventions give you a standard schema every modern LLM tool understands. Adopt them and your traces are portable across Datadog, Honeycomb, Langfuse, and a future-proof data warehouse.

// Example span attributes for one agent turn
span.setAttributes({
  // Provider conventions
  "gen_ai.system": "anthropic",
  "gen_ai.request.model": "claude-opus-4-7",
  "gen_ai.usage.input_tokens": 12480,
  "gen_ai.usage.output_tokens": 2311,
  "gen_ai.usage.cached_read_tokens": 9800,
  "gen_ai.usage.cached_write_tokens": 0,

  // Attribution tags (your conventions)
  "digitalapplied.tenant_id": "acme-corp",
  "digitalapplied.user_id": "u_8814",
  "digitalapplied.task_id": "inbox-triage",
  "digitalapplied.route": "/api/agents/triage",
  "digitalapplied.effort": "high",

  // Layer accounting
  "digitalapplied.prompt_tokens": 8200,
  "digitalapplied.tool_tokens": 2100,
  "digitalapplied.memory_tokens": 2180,
});

Two conventions worth locking in early: use a single namespace prefix for your custom attributes (we use digitalapplied.*) so they filter cleanly in every tool, and always emit the raw token counters rather than pre-computed cost. Pricing changes; counters don't. Re-deriving cost at query time from a pricing table is always cheaper than re-ingesting a quarter of spans when a provider updates list prices.

For deeper implementation details on agent harnesses that produce these spans cleanly, see our Claude Agent SDK production patterns guide.

Scheduled Cost Reports

Dashboards exist so operators can investigate. Scheduled reports exist so nobody has to remember to open the dashboard. Three cadences cover most needs.

Margin Protection Rules

Reports catch drift; rules bound catastrophic loss. Every multi-tenant agent product needs three layers of automatic enforcement, wired before the first paying customer ships.

Graceful Degradation Patterns

When a tenant hits a cap, the best outcome is not a hard failure. Three graceful fallbacks work well.

• Cheaper model fallback. Route from Opus to Sonnet (or equivalent) when daily spend approaches cap. Usually reduces per-request cost 4-5x with acceptable quality loss on most workloads.
• Cached response serving.For read-heavy queries, serve a recent cached answer rather than re-invoking the model. Works particularly well for summarization and Q&A over stable documents.
• Explicit quota error. For workloads where quality cannot be compromised, return a structured "quota exceeded" error with tier-upgrade context. Clearer than silent degradation and drives tier upgrade conversations.

Agency Pricing Integration

For agencies delivering AI capability to clients, attribution data is the foundation of the pricing conversation. Three dominant pricing models each shift token risk differently.

Most agencies we advise settle on a hybrid: bundled monthly for production features with a stable cost-per-outcome, pass-through for experimental workloads under active prompt engineering, and outcome-based only where the outcome is cleanly measurable in existing client systems. Whichever model you pick, the per-tenant-per-route attribution data is the contract-renewal anchor.

For the strategic framing on how token prices are evolving and what that means for bundled pricing, see our analysis of the Anthropic cost problem, and the performance-versus-price efficient frontier.

Debugging Cost Anomalies

When a cost alert fires, the investigation path is consistent. The following five detection signals cover nearly every production anomaly we've seen.

• Tool-call loop. Same tool called with nearly identical arguments 5+ times in a single trace. Usually a convergence bug in the agent loop. Fix: add a loop detector that terminates after N identical calls.
• Prompt bloat. Prompt token count trending upward by 10%+ week-over-week on the same route. Usually caused by accumulating examples or tool definitions. Fix: prune the prompt or split into a cached template.
• Memory runaway. Conversation history growing beyond session expectations. Usually a missing turn-limit or summarization step. Fix: implement rolling summarization or per-session token budget.
• Cache miss storm. Cache hit rate drops from 70%+ to under 40% suddenly. Usually caused by a prompt change that invalidated cache blocks. Fix: audit recent prompt commits and align cache boundaries.
• Model escalation drift. Traffic quietly shifting from Sonnet to Opus. Usually a config or fallback bug. Fix: alert on model mix deltas as a first-class metric.

Worked Example: Multi-Tenant Deployment

Consider a B2B inbox-triage agent shipped to 40 tenants, each with 5-50 users. The agent summarizes new messages, drafts responses, and routes priorities. Monthly token spend sits at roughly $34,000 against $180,000 in contracted revenue — an 81% gross margin before attribution. The reality after instrumentation:

The aggregate 81% gross margin is real but meaningless. Six of 40 tenants — 15% of the book — consume 57% of the token spend and produce margins well below portfolio average. Without attribution, the product team optimizes the wrong prompt; with attribution, the account team has a concrete list for upgrade conversations and a fix priority for the loop bug.

This shape generalizes. On every multi-tenant deployment we've audited, portfolio-level margin hides a 3-5 tenant long tail that is either under-priced, running a loop bug, or sitting on a legacy tier. Finding that tail is the entire job of the attribution stack. For the broader architectural context around running agents at this scale, see our enterprise agent platform reference architecture.

Conclusion

Cost attribution is infrastructure, not reporting. Instrumented properly on day one, it keeps pricing conversations honest, catches runaway tenants before they become margin events, and frames the product optimization roadmap against hard dollars. Skipped or deferred, it forces quarterly scrambles to reconstruct the numbers after margin has already slipped.

The stack is not exotic: four token layers, three attribution dimensions, OpenTelemetry GenAI conventions, scheduled reports, and a three-layer enforcement ladder. Get those right before you ship the first paying tenant, and every subsequent pricing, forecasting, and optimization decision becomes evidence-based.

Frequently Asked Questions