Usage simulation

How long before Claude Code burns through your plan?

Set how many tasks you run a day, how hard the agent thinks, how much context each call carries, and whether the work fans out across agents. The simulation recomputes the cost per task and shows how many days each plan — Free, Pro, Max 5x and Max 20x — survives.

4 plans 5 effort levels 3 models solo · workflow · ultracode 10k–500k context tokens

Read this before you act on it. Subscription plans do not expose a dollar balance. What they have are usage limits on a rolling 5-hour window plus a weekly cap. This simulation converts consumption into equivalent API spend at list prices and compares it against an estimated monthly budget per plan — a model for comparing scenarios, not Anthropic's billing policy.

01 / 10

The model

A task is not one call. It's dozens.

When the agent works a task it reads files, runs commands, fixes and verifies. Every turn of that loop is a model call — and every call resends the context accumulated so far. That is where almost all of the spend comes from.

GOES IN

Context per call

Conversation history, files read, tool output. It grows as the task proceeds and is resent in full on every turn.

MULTIPLIES

Effort level

Sets how much the model reasons and how many tool turns it takes. From low to max, calls per task grow about 8×.

COMES OUT

Output tokens

Reasoning, prose and code edits, at 5× the price of input. They barely move with effort, though: real calls land near 650 tokens at every level. Effort buys more calls, not longer answers.

chain_cost = calls × ( context × input_price × cache_factor + output × output_price )

task_cost = phases × ( chain_cost × 1.44 + agents × chain_cost × 0.55 )

Parameters per effort level
Effort	Calls / task	Output tokens / call	Typical use

02 / 10

The plans

What monthly budget each subscription stands for

Anthropic does not publish a dollar figure per plan. The numbers below are this simulation's premise: the equivalent monthly consumption, at API list prices, that each subscription tends to accommodate. Substitute your own if experience says otherwise.

What the model does not capture. Plans meter usage in rolling 5-hour windows and a weekly cap, not as a balance you spend however you like. In practice that means you can hit a limit on Tuesday morning and be back at work by the afternoon without having "used up the month". And the Free plan does not include Claude Code at all — the figure there is illustrative, purely to keep four plans on the same chart scale.

03 / 10

Simulator · panel

Your scenario, plan by plan

The bar on each card shows how much of the month is covered: full means the plan lasts the whole 30 days at this pace. covers the month means budget to spare; cutting it close is 20 to 30 days; runs out early is under 20.

04 / 10

Simulator · chart 1

Days before the plan runs dry

The plan's monthly budget divided by the daily cost of your pace. The dashed line marks the 30 days at which the cycle renews — anything past it finishes the month with budget left.

05 / 10

Simulator · chart 2

How far into the five hours you get

The month is not what stops your day. A subscription meters a rolling five-hour window, and when it closes you wait — so the question that matters at 3pm is whether this pace reaches the end of the window or runs out before it. The dashed line is the full five hours; a bar that reaches it means you never feel the limit.

06 / 10

Simulator · chart 3

Effort is the expensive lever

Same context, same model — only the effort level changes. The highlighted bar is what the console has selected; the others show what a task would cost at every other level.

07 / 10

Simulator · chart 4

One agent, a swarm, or ultracode

In solo the task runs as a single loop. A workflow fans out agents in parallel — each with its own context and its own chain of calls. ultracode makes that the default: a workflow on every task, chained across phases, at a minimum effort of xhigh. The axis is logarithmic.

08 / 10

Simulator · chart 5

Big context shortens the month

How many days each plan lasts as the average context per call grows, holding effort and pace fixed. The vertical axis is logarithmic — without it, Free and Max 20x would not fit on the same chart.

09 / 10

Takeaways

Six levers that stretch the same plan

Roughly in order of how much they return. The percentages come from this simulation's own model — recompute them in the console against your scenario.

−95%

Save workflow and ultracode for work that earns them

By far the biggest lever: every agent in the fan-out runs a full chain of its own, and ultracode stacks three phases on top of that. An 8-agent workflow costs roughly 6× a solo task; in ultracode, closer to 38×. Worth it for migrations and audits — not for fixing one failing test.

−70%

Drop the effort level for routine work

Going from xhigh to medium cuts calls per task from 22 to 8. Keep xhigh and max for large refactors and hard debugging.

−55%

Compact the session before it bloats

Context is resent on every call. Dropping from 250k to 100k average tokens cuts input cost in the same proportion — which is exactly what /compact and shorter sessions do.

−60%

Use Sonnet 5 for what doesn't need Opus

Sonnet 5 runs $2/$10 per million against Opus 5's $5/$25 (introductory pricing through 2026-08-31). For direct edits and tests, the quality difference rarely pays for the multiplier.

−45%

Protect the cache: stable prompt first

Caching is a prefix match. A timestamp near the top of the prompt invalidates everything after it and the cache factor goes from 0.25 to 1.0 — input cost quadruples with nothing visible on screen.

−30%

Specify the whole task up front

Every round trip with the user resends the accumulated context. One complete instruction on the first turn usually costs less than the same task discovered across five turns.

What was measured, and what is still a guess. The coefficients below come from tools/measure-usage.mjs, which reads the JSONL transcripts Claude Code writes for every session, priced at API list rates.

Assumed before, measured now
Coefficient	Was assumed	Measured	What the gap means

Use-case profiles — measured, then run through the model
Use case	Context / call	Calls / task	Measured $ / task	Modelled, high	Modelled, ultracode

Every assumption, in one place. API list prices (Opus 5 $5/$25, Sonnet 5 $2/$10 introductory, Haiku 4.5 $1/$5 per million tokens); measured cache factor 0.1335; agent fan-out with the coordinator and agent shares shown above; ultracode at 3 phases with an xhigh effort floor; estimated monthly budgets of $5 / $120 / $600 / $2,400 for Free / Pro / Max 5x / Max 20x; a 30-day month. The prices and the measurements are real; the four monthly budgets are not — no plan publishes a dollar equivalent, and the measured data suggests a heavy Max 5x day alone can exceed $450 at list prices. They are the model's stated basis, so that you can disagree with it precisely.

10 / 10