Agent Cost Attribution: Cut Your AI Spend from $198 to $42/Month

Eight agents running in production. One bill: $198/month. No idea which agent is responsible for which dollar. Sound familiar? This is the attribution layer that turned that bill into $42 — a 79% reduction — by making every token traceable to the task that spent it.

Why Most Developers Have No Idea What They're Spending

When you run agents against the OpenAI or Anthropic API, you get one line item: API usage — $198.43. No breakdown. No agent names. No task types. Just a number that grows every month and a vague sense that something is running too hot.

Without attribution, you can't optimize. You're guessing. The instinct is usually wrong — most developers assume it's their most-used agent. In this production stack, the culprit was a nightly summarization agent that was passing entire conversation histories as context instead of compressed summaries. It ran 47 times/night at ~4,200 tokens each. $89/month. Nobody noticed because it was silent and "working fine."

The Attribution System: Three Files, 20 Minutes

This system wraps your existing API calls with a thin attribution decorator. Every call logs: agent name, task type, model used, prompt tokens, completion tokens, and estimated cost. No external services. No dashboards to pay for. Just a SQLite database and a reporting script you run weekly.

Step 1: The Cost Tracker (Drop This in Your Utils)

Copy# cost_tracker.py — drop in your utils/ directory
import sqlite3, time, functools
from pathlib import Path

# Pricing as of early 2026 — update when rates change
COST_PER_1K = {
    "gpt-4o":             {"input": 0.0025, "output": 0.010},
    "gpt-4o-mini":        {"input": 0.00015, "output": 0.0006},
    "claude-3-5-sonnet":  {"input": 0.003, "output": 0.015},
    "claude-3-haiku":     {"input": 0.00025, "output": 0.00125},
    "claude-opus-4":      {"input": 0.015, "output": 0.075},
}

DB_PATH = Path("~/.agent-costs.db").expanduser()

def _init_db():
    conn = sqlite3.connect(DB_PATH)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS api_calls (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            ts REAL,
            agent TEXT,
            task_type TEXT,
            model TEXT,
            input_tokens INTEGER,
            output_tokens INTEGER,
            cost_usd REAL
        )
    """)
    conn.commit()
    return conn

def track(agent: str, task_type: str = "default"):
    """Decorator: @track('my_agent', 'summarize')"""
    def decorator(fn):
        @functools.wraps(fn)
        def wrapper(*args, **kwargs):
            result = fn(*args, **kwargs)
            try:
                usage = getattr(result, 'usage', None)
                if usage:
                    model = getattr(result, 'model', 'unknown').split('-202')[0]
                    inp = getattr(usage, 'input_tokens',
                                  getattr(usage, 'prompt_tokens', 0))
                    out = getattr(usage, 'output_tokens',
                                  getattr(usage, 'completion_tokens', 0))
                    rates = COST_PER_1K.get(model, {"input": 0.003, "output": 0.015})
                    cost = (inp / 1000 * rates["input"]) + (out / 1000 * rates["output"])
                    conn = _init_db()
                    conn.execute(
                        "INSERT INTO api_calls (ts, agent, task_type, model, "
                        "input_tokens, output_tokens, cost_usd) VALUES (?,?,?,?,?,?,?)",
                        (time.time(), agent, task_type, model, inp, out, cost)
                    )
                    conn.commit()
                    conn.close()
            except Exception:
                pass  # Never let tracking break the actual call
            return result
        return wrapper
    return decorator

Notice the try/except that swallows all tracking errors. This is intentional. Cost tracking is observability, not business logic. It should never take down a real task.

Step 2: Wrap Your Existing Calls (2 Lines Per Agent)

Copy# Before (no attribution):
def summarize_today(notes: str) -> str:
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=800,
        messages=[{"role": "user", "content": f"Summarize: {notes}"}]
    )
    return response.content[0].text

# After (with attribution — 2 lines changed):
from utils.cost_tracker import track

@track("daily-summarizer", "summarize")   # ← add this
def summarize_today(notes: str) -> str:
    response = client.messages.create(    # ← response object unchanged
        model="claude-3-5-sonnet-20241022",
        max_tokens=800,
        messages=[{"role": "user", "content": f"Summarize: {notes}"}]
    )
    return response.content[0].text

The decorator intercepts the return value, pulls usage from the response object (works with both Anthropic and OpenAI SDKs), and writes to the database. Zero change to your business logic.

Step 3: The Weekly Report (Run This Every Monday)

Copy# report.py — run weekly: python3 report.py
import sqlite3
from pathlib import Path

DB_PATH = Path("~/.agent-costs.db").expanduser()

def weekly_report(days=7):
    conn = sqlite3.connect(DB_PATH)
    since = __import__('time').time() - (days * 86400)

    rows = conn.execute("""
        SELECT agent, task_type, model,
               COUNT(*) as calls,
               SUM(input_tokens) as total_in,
               SUM(output_tokens) as total_out,
               SUM(cost_usd) as total_cost,
               AVG(input_tokens) as avg_in
        FROM api_calls
        WHERE ts > ?
        GROUP BY agent, task_type, model
        ORDER BY total_cost DESC
    """, (since,)).fetchall()

    print(f"\n{'Agent':<28} {'Task':<18} {'Model':<22} {'Calls':>6} "
          f"{'Avg In':>8} {'Cost':>9}")
    print("-" * 100)
    total = 0
    for r in rows:
        agent, task, model, calls, tin, tout, cost, avg_in = r
        print(f"{agent:<28} {task:<18} {model:<22} {calls:>6} "
              f"{int(avg_in or 0):>8} ${cost:>8.2f}")
        total += cost
    print("-" * 100)
    print(f"{'TOTAL':>82} ${total:>8.2f}")
    conn.close()

if __name__ == "__main__":
    weekly_report()

The Three Culprits (What the Data Always Reveals)

Once you have attribution data, the same patterns show up in every stack. Here are the three most common cost killers — plus the fix for each:

Related Library Items