A $400 AI team that meters at $53,403

The number the subscription won't show you

I run an AI coding team on two flat-fee subscriptions — Claude Max 20x and ChatGPT Pro, $200 each, $400/month total. Inside the rate limits it feels "unlimited," and that flat fee is the whole reason the team runs the way it does: agents that review each other across vendors, patrols that never sleep, speculative retries that cost nothing to fire. The meter is off, so you stop counting.

Which raises a question neither vendor will answer: if I paid the metered API for exactly this usage instead of the flat fee, what would the bill be? Claude Code's /usage shows a percentage bar — how much of your window is gone — not a token count, not a per-model split. A ChatGPT subscription has no usage panel at all; only metered API accounts get a dashboard. The number does not exist in any UI.

But it does exist on disk. Both CLIs write a full, request-level log of every call, model and token counts included. So I rebuilt the metered bill the vendors won't show — itemized, per model — from those logs. The gap it exposes is the point of this post.

$400 paid, $53,403 on the meter

One 30-day window (2026-06-24 → 07-24), every model priced at its official API list rate:

That splits into $42,351 on the Codex / ChatGPT side and $11,052 on the Claude side, across 558,466 requests and 76.6 billion tokens. This is a list-price counterfactual, not $53,403 of money saved — §6 spends the honest limits, and they matter. But the raw gap is real: for this usage, the metered API would have charged 133× what the subscription did.

The itemized bill, per model

A single total hides where the money goes, so here is the whole thing broken out — every model, its real token counts by bucket, and the list-price subtotal. Nothing is a mystery figure: each subtotal is just tokens × the published unit price.

Codex CLI (ChatGPT Pro) — $42,351

† 61,486 requests logged no model name; priced at OpenAI's default sol/5.5 top tier — a ceiling for that slice (§6).

Claude Code (Claude Max) — $11,052

Every subtotal is mechanical. Take the biggest line, gpt-5.6-sol — tokens × the published $/million:

Now group the whole bill by what you're paying for instead of by model, and the shape is stark:

• Cache reads + writes: $40,151 — 75% of the bill. gpt-5.6-sol's cache reads alone are $25,802, half of everything.
• Fresh (uncached) input: $6,880 — 13%.
• Generated output: $6,372 — 12%.

That is the signature of agent work: a large context re-sent every turn, mostly served from cache, with comparatively little new text produced each time. It's also exactly the shape a flat subscription absorbs and a meter punishes — which is §5.

Why the total is trustworthy (three traps)

"Tokens × unit price" is trivial. The rigor is entirely in the aggregation, and a naive sum over the raw logs is confidently wrong in three different directions — each big enough to move the headline. The number above only stands because it survives all three.

• Streaming repeats a request, and the counts grow. Claude Code appends a log line as the response builds, so the same request appears on many lines with output_tokens climbing. Sum every line and you multi-count; keep the first and you catch it mid-stream (~28% low on output in a large-session sample). Fix: group by requestId + message.id, keep the last occurrence.
• Forked sessions double-count cumulative totals. Codex logs a running total_token_usage; a forked session inherits its parent's, so summing session finals counts the shared prefix twice — 71.0B versus the true ~66B, a ~7% overcount. Fix: sum the per-turn last_token_usage deltas instead.
• Cached input is a subset of input, not an addition. Codex reports input_tokens as the turn's total and cached_input_tokens as the part served from cache — already inside it. Cache reads bill at roughly a tenth of the input rate, so split them (uncached = input − cached) before pricing, or you overcharge the cached tokens 10×.

Then cross-check: I reconciled the per-turn sum against the session finals and only trusted the number once I understood exactly where the 7% gap came from.

The flat fee is the business model

Annualize the window and the metered equivalent is roughly $641k/year at list price — more, per year, than the fully-loaded cost of a senior engineer in most markets. Read naively, that says "the AI team is more expensive than a person." That is not the lesson — because you would never actually pay it.

The moment the meter turns on, you change how you run: cut concurrency, trim the big context you re-send every turn, kill the speculative retries and the always-on patrols — precisely because each cache read now has a price. The $641k is the cost of this exact operating mode at list price, not a check anyone would write. And that inversion is the real point:

The flat subscription isn't cheaper compute — it's what makes the operating mode viable at all. Always-on, self-reviewing, multi-agent autonomy only pencils out because the marginal token is free at the point of use. Bill the same behavior through the metered API and the arithmetic flips — it costs more than the human it was meant to leverage — so nobody runs autonomy that way. The subscription is the enabling technology, not a discount on it.

So the figure worth watching isn't the $53,403 trophy. It's the 133× gap between what you pay and what the same behavior meters at — because that gap is the entire budget for running agents like a team instead of like API calls.

Honest limits

• A counterfactual, not money saved. "$53,403 of value" is what this usage would list at on the metered API — not a check anyone wrote, and (per §5) not what you'd actually spend, because metered pricing would change how you run.
• The volume needed repeated quota resets. The Codex side didn't fit inside one standard weekly allowance — the weekly limit hit 100% three separate times in the window, cleared by several resets (some manual, some vendor-side). So the headline is "a subscription plus resets," not a single stock plan.
• Mostly a floor, with one ceiling to name. The logs cover only the two CLIs — nothing from the claude.ai web/mobile apps, ChatGPT's web/app, or cloud runs — and those omissions only push the figure up, as do two price caveats: one Claude model was on introductory pricing, and OpenAI's cache-write volume is never populated in the logs (the field exists but is always 0; excluded, bounded under +$1,700). The one caveat that cuts the other way, and the largest single estimate in the bill: ~10% of the total ($5,401, 61,486 requests) comes from sessions with no recorded model, priced at OpenAI's default sol/5.5 top tier — a ceiling for that slice. sol is ~90% of the labeled requests, so it's a defensible central guess, but if those sessions were a cheaper model the slice could fall ~$4,300 (~8% of the headline). Net, the exclusions likely still make the total a floor; that one slice is the exception to flag.

Recap

1. Ask the question the meter hides. A flat-fee AI subscription shows a percentage bar or nothing; the per-model, per-token usage exists only in the local CLI logs (~/.claude/projects, ~/.codex/sessions). Rebuilding the metered bill is just tokens × list price.
2. Itemize it, don't total it. One 30-day window: $400 paid, $53,403 metered — 133×. Cache reads and writes are 75% of that, and one model's cache reads are half the bill. The breakdown is the story; the lone total hides it.
3. Trust it only after three traps: streaming repeats a request (dedupe, keep the last), forks double-count cumulative totals (sum per-turn deltas), and cached input is a subset of input (split before pricing).
4. The flat fee is the enabling technology. At a ~$641k/year metered run-rate, always-on autonomous agents would cost more than a human — so nobody runs them metered. The subscription's flat marginal cost is what makes an AI team economically sane. The number to watch isn't the trophy total; it's the 133× gap that funds running agents like a team.