How to Track Per-Agent LLM Costs (2026 Guide)

The Problem: Your AI Bill Is a Black Box

You ship five agents to production. Sales assistant. Support bot. Data pipeline. Code reviewer. Document summarizer. By end of month, you've spent $840 on Anthropic. But which agent cost $400? Which one cost $12?

If you can't answer that question, you're flying blind.

This is the default state for most teams: a single API key, all agents sharing it, one undifferentiated line on the provider invoice at the end of the month.

The problem isn't the cost itself — it's that you have no way to attribute it, no way to see it coming, and no way to stop it.

Why Per-Agent Tracking Actually Matters

Before getting into the how, it's worth being precise about why aggregate cost visibility isn't good enough.

1. You can't optimize what you can't measure

If you know your total monthly LLM spend is $1,200 but don't know which agent is responsible for what, you have no starting point for optimization. Should you compress prompts? Cache responses? Downgrade models for certain tasks? You can't make those calls without per-agent cost data.

2. Agent cost profiles change without warning

An agent that costs $0.002 per run today can cost $0.40 per run tomorrow. Input data grows. A new feature adds context. A dependency pulls in extra tokens. Without per-agent tracking, these regressions are invisible until the bill arrives.

3. Runaway loops are undetectable from aggregate data

Infinite loops, retry storms, and runaway recursive calls all look identical to "normal usage" in aggregate dashboards — just a higher number. Per-agent tracking with anomaly detection can flag a single agent consuming 10x its normal spend within minutes.

4. Billing allocation becomes impossible at scale

Once you're running 10+ agents across multiple teams or customers, you need per-agent cost data to do chargebacks, per-customer billing, and departmental budget allocation. Trying to reconstruct this from aggregate data after the fact is painful and error-prone.

3 Approaches to Track LLM Costs Per Agent

There's no single right answer here — the approach that works depends on your scale, your stack, and how much engineering time you want to spend on infrastructure vs. product.

const response = await anthropic.messages.create({
  model: "claude-opus-4-5",
  messages: [...],
  metadata: { user_id: agentId }
});

// Capture usage from response
const inputTokens = response.usage.input_tokens;
const outputTokens = response.usage.output_tokens;

// Calculate cost (hardcoded — breaks when pricing changes)
const cost = (inputTokens * 0.000015) + (outputTokens * 0.000075);

// Log it somewhere
await db.insert('llm_usage_logs', {
  agent_id: agentId,
  model: response.model,
  input_tokens: inputTokens,
  output_tokens: outputTokens,
  cost_usd: cost,
  timestamp: new Date()
});

How Costline Handles Per-Agent Cost Attribution

Costline is built around a single premise: your LLM costs should be visible at the agent level, in real time, with budget controls per agent — not aggregated across everything and discovered at month-end.

Here's the core model:

• One API key per provider — you connect your OpenAI, Anthropic (and other) API keys once. Costline reads usage directly from provider APIs.
• Agent tagging via metadata or SDK — each LLM call gets tagged with an agent identifier. Costline maps usage to agents from that tag.
• Real-time cost dashboard — per-agent spend updates continuously, not at end-of-month billing cycle.
• Per-agent budget thresholds — set a spend limit per agent. Get alerted when it's hit. Optionally hard-cut the agent at limit.

Quick Start: 3 Steps to See Per-Agent Costs

const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [...],
  user: "agent:sales-assistant-v2"  // Costline reads this
});

const response = await anthropic.messages.create({
  model: "claude-opus-4-5",
  messages: [...],
  metadata: { user_id: "agent:support-bot" }  // Costline reads this
});

That's the core loop. After setup, the dashboard shows each agent's daily, weekly, and monthly cost trends — and flags anomalies when an agent's spending pattern deviates from its baseline.

What Good Per-Agent Visibility Actually Looks Like

Once you have per-agent cost attribution working, a few things become immediately actionable:

Model right-sizing. You'll likely find that 2–3 agents are using GPT-4o or Claude Opus for tasks that don't require that level of capability. Downgrading those agents to a smaller model is a mechanical cost reduction — often 5–10x cheaper per call with minimal quality impact for structured tasks.

Prompt compression. The agents burning the most tokens are usually doing something inefficient with context — loading full documents, repeating system prompts on every turn, or not caching stable context. Per-agent data makes these targets obvious.

Caching opportunities. If an agent has a high call volume but repetitive inputs, semantic caching can dramatically reduce token consumption. You can't prioritize this without knowing which agents have the right profile for it.

Cost per outcome. Once you know what each agent costs, you can start connecting it to value — cost per ticket resolved, cost per deal qualified, cost per document processed. That's the metric that actually matters for AI ROI conversations.

Summary: Which Approach Is Right for You?