I Finally Added Up What My AI Agent Actually Costs. The API Bill Was 3% of It.

For eight months I told people my agent stack cost "about $40 a month." I said it in a comment thread. I think I said it in a sales page. Last weekend I finally did the accounting properly — 90 days, every invoice, every hour — and the real number was $3,916. The API bill was $126.90 of it.

That is not a typo and it is not a rounding error. It is 3% of the total. The other 97% was me.

What I actually counted

The setup: one agent on a Raspberry Pi 5 that drafts content, answers support mail, and runs release checks for three small products. Ninety days ending October 30. I exported every Lemon Squeezy payout, every invoice, and — the part I'd been avoiding — a timer log of my own review time.

The revenue side, before anyone gets excited:

• 164 sales, $1,486 gross
• minus payment fees and 7 refunds → $1,271 net

The cash cost side:

Line item	90 days
LLM API (all models)	$126.90
VPS + Pi power	$27.00
Off-site backups	$9.00
Domain + transactional email	$14.00
Monitoring (uptime + SMS alerts)	$23.00
Replacement SD card and a UPS after the 2 AM death	$71.00
Total cash	$270.90

$271 in cash against $1,271 net. If I'd stopped there I'd have written a very smug post about 78% margins.

Then the line I'd been leaving out of every calculation for four months: 6.2 hours a week of review time, averaged over 13 weeks. That's 81 hours. At the $45/hour I charge consulting clients, it's $3,645.

Total economic cost: $3,916. Net revenue: $1,271. The business lost roughly $2,600 in the quarter while I was telling people it was nearly free to run.

The part that actually stung

The API cost wasn't the surprise. The surprise was what I was spending those 81 hours on.

I went through my review log and tagged every session. Roughly:

• 34% — re-checking work the agent had marked complete
• 26% — fixing formatting and tone in things it had already "fixed" once
• 19% — reading logs to figure out why something didn't run
• 14% — actually improving the system
• 7% — answering customers about things the agent got wrong

Two-thirds of my time was verification, not creation. I had built a machine that produced drafts faster than I could trust them, and I was calling the difference "automation."

Here's the failure in one line: I was measuring the cost of the agent in tokens, and the cost of the agent was in attention. Tokens are cheap and legible. Attention is expensive and invisible. So I optimized the thing I could see, which is exactly backwards.

I also found a specific, embarrassing pattern in the numbers. In the month I added six new agent capabilities — a calendar sync, a second content format, an auto-tagger, three small integrations — revenue went up $180 and my review time went up 2.1 hours a week. That's about $95/week of my time to support $45/week of revenue. I shipped six features with a negative return and felt productive the entire time, because every one of them demoed beautifully.

Three things I got wrong, in order of expense

1. I priced my own time at zero. Not deliberately — I just never put it in the spreadsheet, so every feature looked free. The moment review time got a dollar value, three of the six features I'd shipped that month were obviously not worth keeping. One of them, the auto-tagger, I deleted the same day and nothing broke.

2. I tried to fix a systems problem with a longer prompt. Classic. The review burden came from unclear completion criteria, so I wrote a 900-word policy explaining what "done" meant. It made things worse in a way I've already written about — the agent started treating friendly sentences as overrides. The actual fix was twelve lines of code that refused to mark a task complete without a specific artifact in the output directory. Structure beat prose by a mile.

3. I priced by vibe. $19 because $19 felt like a "real product." $3 because $3 felt too cheap to matter. Over 90 days, the $3 item sold 96 units and the $19 item sold 11. Units aren't revenue, but the conversion gap was 9:1 and it told me something I'd been ignoring: at $3 nobody deliberates. At $19 everybody does, and my page wasn't good enough to survive deliberation. I'd been treating pricing as a statement about my work instead of a hypothesis about the buyer.

What I changed, and what it did

I killed three capabilities. I put a hard cap on what the agent can do without a human artifact check. I stopped counting "tasks completed" and started counting "tasks completed and accepted without edits." And I moved the review window from daily to twice a week, batched, which sounds small but cut context-switching almost entirely.

Six weeks in: review time is down from 6.2 to 2.1 hours a week. Cash cost is basically unchanged, which is the point — the fix wasn't cheaper models, it was less surface area. Margin is positive now even at my consulting rate, and I trust the output enough to ship it without reading every line.

The 40-minute version of this audit

If you run any agent on a schedule, you can do this tonight with no new tooling.

Step one: pull per-task token spend out of your logs. If you're not logging usage, that's the first fix.

import json, collections

# $ per million tokens: (input, output) — adjust to your models
RATES = {"gpt-4o-mini": (0.15, 0.60), "claude-sonnet": (3.00, 15.00)}

runs = collections.Counter()
cost = collections.Counter()

for line in open("agent.log"):
    try:
        r = json.loads(line)
    except json.JSONDecodeError:
        continue  # skip non-JSON lines instead of dying halfway through
    task = r.get("task", "unknown")
    pin, pout = RATES.get(r.get("model", "gpt-4o-mini"), (0, 0))
    u = r["usage"]
    cost[task] += u["prompt_tokens"] / 1e6 * pin
    cost[task] += u["completion_tokens"] / 1e6 * pout
    runs[task] += 1

for task in sorted(cost, key=cost.get, reverse=True):
    print(f"{task:28} {runs[task]:5} runs  ${cost[task]:7.2f}  ${cost[task]/runs[task]:.3f}/run")

Step two: for one week, set a timer every time you touch something the agent produced. One number per day is enough. Don't estimate — estimate is how I got this wrong for four months.

Step three: divide. Cost per accepted output, and minutes of your time per accepted output. Sort by minutes. The top three items are where your actual margin is leaking, and they are almost never the ones with the biggest API bill.

Step four: kill one thing. Not refactor — kill. The feature with the worst review-to-value ratio, deleted, this week. If nothing breaks in seven days, it was never load-bearing.

That last step is the one I resisted longest, and it's the only one that moved the number.

---

I keep the full cost-tracking schema, the completion-artifact check, and the batching pattern I use now in The Solo Operator's AI Agent Playbook — code LAUNCH90 at checkout makes it $1.90. If it doesn't save you 5 hours in week one, reply to the receipt for a refund.

If you've done this math on your own stack, I'd like to know what your review-to-cash ratio looked like. Mine was ugly and I'd feel better knowing I'm not the only one.