The Output Token Trap: Thinking Loops Burn $20 Before Writing 5 Lines of Code

Every LLM bill has a hidden asymmetry: output tokens cost 3–5x input tokens. Reasoning models made that asymmetry dangerous. An agent that “thinks” before acting is generating output tokens the whole time — and nothing in most billing setups stops it.

The anatomy of a runaway loop

You ask for a small fix. The agent reasons about the file, reasons about its plan, reasons about its reasoning, writes a draft, rejects it, reasons again… Ten minutes later: five lines of code changed, hundreds of thousands of output tokens generated. On a frontier model, that single session can consume a meaningful chunk of a $20 plan — before the diff lands.

This isn’t a hypothetical edge case; it’s the default failure mode of agentic coding, and subscription tiers convert it into mysterious “usage exceeded” walls.

The math, concretely

Say input costs $3 and output $15 per million tokens (a typical frontier-model ratio). A task that reads 50k tokens of context and emits 8k tokens of output costs:

• 8k output × $15/M = $0.12 of output
• 50k input × $3/M = $0.15 of input

Balanced so far. Now add a thinking loop that triples output: the output share becomes $0.36 vs $0.15 — the task now costs 2.5x, driven entirely by generation. Run five such tasks a day and you’re at ~$2.50/day on one model; scale to a stronger model or longer loops and the $20 subscription ceiling arrives mid-afternoon. The exact prices change monthly; the 3–5x asymmetry hasn’t.

Circuit breakers: how to cap the burn

1. Hard generation limits. Set max output tokens per request in your agent config. Generous enough to finish a task, tight enough to kill a spiral. Every serious agent exposes this; almost nobody sets it.
2. Turn budgets. Cap steps/tool-calls per task. A 30-step task that should take 8 steps is a loop wearing a task costume.
3. Provider-side spend caps. A hard monthly ceiling on the API key — the circuit breaker that works even when the agent misbehaves and you’re not watching.
4. Spend visibility. Use agents that show a running cost (some do it natively). You can’t break what you can’t see.
5. Prefer cache-native agents for exploration. Cheap repeated input makes exploration affordable; output loops are then the only thing that can hurt you — which is exactly what 1–4 cap.

The takeaway

The unit economics of AI coding are: input is cheap, output is expensive, reasoning is output. Tools and habits that constrain output (limits, budgets, surgical file reading, prompt caching) are worth more than any model upgrade. When you compare agents on this site, the Limits pillar is largely a measure of how well a tool protects you from exactly this trap.