Cost to Build X with AI (Token Estimator)
Estimate what an AI coding agent will cost to build a story, epic, feature or whole project.
For the “5-point story” scenario, $2.70 to build a 5-point user story — 945,000 tokens with GPT-4o · typical range $1.20–$6.00. Enter your own numbers below to recompute instantly; the full step-by-step math is shown under the worked example.
The unit of work. Ranges assume a whole agent session, not a single prompt.
Below = simpler than usual (low range); Above = gnarlier than usual (high range).
Results update automatically as you type.
- • Ranges are planning estimates over an entire agent session, not a quote. Real usage depends on your codebase, model and iterations.
- Work item
- 5-point user story
- Model(openai)
- GPT-4o
- Est. input tokens
- 900,000
- Est. output tokens
- 45,000
- Estimated build cost
- $2.70
| Below average (simple) | 400,000 | 20,000 | $1.20 |
| Typical | 900,000 | 45,000 | $2.70 |
| Above average (complex) | 2,000,000 | 100,000 | $6.00 |
Pick a unit of work — a story point, an epic, a landing page, an MVP feature — and see how many tokens an AI coding agent (Cursor, Claude Code, Copilot-style) typically burns to build it, and what that costs at today's model prices. Every unit shows an honest Low / Typical / High range because real usage depends on your codebase, model and how many iterations it takes. This is build-time (developer) spend, not the runtime cost of the finished feature.
Not sure what to enter? Typical token ranges
Map agile estimates — story points and epics — onto AI build cost. These are honest planning ranges for how many tokens an AI coding agent burns to build each item — the cost column uses GPT-4o’s current prices.
| Work item | Typical input tokens | Typical output tokens | Typical cost |
|---|---|---|---|
| 1-point user story | 150,000 | 10,000 | $0.4750 |
| 2-point user story | 300,000 | 18,000 | $0.9300 |
| 3-point user story | 500,000 | 28,000 | $1.53 |
| 5-point user story | 900,000 | 45,000 | $2.70 |
| 8-point user story | 1,600,000 | 80,000 | $4.80 |
| 13-point user story | 2,800,000 | 140,000 | $8.40 |
| Epic | 10,000,000 | 500,000 | $30.00 |
Ranges assume a whole agent session (many turns, context re-sent), not a single prompt. See how many tokens does X take for full low/typical/high ranges, or open the Cost to build X estimator to plug in your own model.
How this is calculated
Each unit of work in our reference library has a Low / Typical / High range for input tokens (context the agent re-reads each turn) and output tokens (the code, diffs and tests it writes). We take the range for the unit you pick, apply your chosen model's per-million input and output prices, and — if you set a cached % — bill that share of input at the model's cache-read rate. The headline uses the complexity you selected; the table shows all three scenarios so you can see the spread.
These are session-level estimates for build-time (developer) spend, deliberately shown as ranges. They are for planning, not a quote.
Is this a good result? What to do next
Compare the estimate to what the work is worth, not in isolation. If an AI agent builds a 5-point story for a few dollars of tokens, that's trivial next to an hour of engineering time — the value is usually in speed, not raw token cost. The number matters most at the epic/project scale, where model choice and caching move the total meaningfully.
Typical planning ranges
- 1–3 point story
- ~150k–1.1M input tokens per session
- 5–8 point story
- ~0.9M–3.5M input tokens per session
- Epic
- ~4M–24M input tokens across many sessions
- MVP feature
- ~1.5M–8M input tokens
Ranges are typical planning figures to sanity-check your result, not authoritative benchmarks. Your numbers will vary with use case, volume, and vendor.
How to improve this number
- Split big work into smaller stories — smaller context per session means fewer re-read tokens.
- Turn on prompt caching so re-sent context is billed at the cheaper cache-read rate.
- Use a cheaper model for routine tasks and reserve a frontier model for the hard parts.
- Give the agent tighter, relevant context so it needs fewer iterations.
Common mistakes
- Reading a range as a quote — your codebase and iteration count dominate.
- Forgetting input tokens (re-read context) usually dwarf the output the agent writes.
- Comparing build cost to nothing instead of to engineer time saved.
When to use a different approach
To estimate the cost of running the finished feature (per request, at scale), use the LLM API cost calculator. To model a specific multi-step agent run in detail, use the agent cost calculator.
Worked examples
Real scenarios you can reproduce by loading these presets in the calculator above:
5-point story
- • Ranges are planning estimates over an entire agent session, not a quote. Real usage depends on your codebase, model and iterations.
- Work item
- 5-point user story
- Model(openai)
- GPT-4o
- Est. input tokens
- 900,000
- Est. output tokens
- 45,000
- Estimated build cost
- $2.70
| Below average (simple) | 400,000 | 20,000 | $1.20 |
| Typical | 900,000 | 45,000 | $2.70 |
| Above average (complex) | 2,000,000 | 100,000 | $6.00 |
- Work item: 5-point user story — a whole AI coding-agent session, not one prompt.
- Token assumptions (input / output): low 400,000 / 20,000, typical 900,000 / 45,000, high 2,000,000 / 100,000.
- Rates: $2.5/M input, $10/M output.
- No prompt caching applied (set a cached % to model an agent re-sending context).
- Selected scenario (Typical): (900,000 in + 45,000 out) → $2.70.
Epic
- • Ranges are planning estimates over an entire agent session, not a quote. Real usage depends on your codebase, model and iterations.
- Work item
- Epic
- Model(openai)
- GPT-4o
- Est. input tokens
- 10,000,000
- Est. output tokens
- 500,000
- Estimated build cost
- $30.00
| Below average (simple) | 4,000,000 | 200,000 | $12.00 |
| Typical | 10,000,000 | 500,000 | $30.00 |
| Above average (complex) | 24,000,000 | 1,100,000 | $71.00 |
- Work item: Epic — a whole AI coding-agent session, not one prompt.
- Token assumptions (input / output): low 4,000,000 / 200,000, typical 10,000,000 / 500,000, high 24,000,000 / 1,100,000.
- Rates: $2.5/M input, $10/M output.
- No prompt caching applied (set a cached % to model an agent re-sending context).
- Selected scenario (Typical): (10,000,000 in + 500,000 out) → $30.00.
Landing page
- • Ranges are planning estimates over an entire agent session, not a quote. Real usage depends on your codebase, model and iterations.
- Work item
- Landing page
- Model(openai)
- GPT-4o
- Est. input tokens
- 380,000
- Est. output tokens
- 28,000
- Estimated build cost
- $1.23
| Below average (simple) | 150,000 | 12,000 | $0.4950 |
| Typical | 380,000 | 28,000 | $1.23 |
| Above average (complex) | 850,000 | 62,000 | $2.75 |
- Work item: Landing page — a whole AI coding-agent session, not one prompt.
- Token assumptions (input / output): low 150,000 / 12,000, typical 380,000 / 28,000, high 850,000 / 62,000.
- Rates: $2.5/M input, $10/M output.
- No prompt caching applied (set a cached % to model an agent re-sending context).
- Selected scenario (Typical): (380,000 in + 28,000 out) → $1.23.
Sources & references
Frequently asked questions
Does this include running the feature, or just building it?+
Just building it. This estimates the tokens an AI coding agent burns while implementing the work — the developer-time spend. The runtime cost of calling the finished feature is a separate thing; use the LLM API cost calculator for that.
Why are the numbers so much bigger than one prompt?+
A coding agent works over a whole session: it reads files, proposes changes, runs tests, and re-sends context on every turn. Input tokens accumulate fast, which is why even a small story can be hundreds of thousands of tokens.
How accurate are these ranges?+
They're transparent planning estimates, not a quote. Actual usage depends on your codebase size, the model, prompt caching and how many iterations a task takes — which is exactly why we show Low / Typical / High instead of a single number.
How do I make it cheaper?+
Split large work into smaller stories, use prompt caching so re-sent context is billed at the cache-read rate, pick a cheaper model for routine tasks, and give the agent tighter context so it iterates less.