Agent Loop Cost
What does each agent run actually cost?
Multi-turn agents accumulate context every step. Cost grows quadratically, not linearly. Model it before you get a $20K overnight bill.
Pricing verified: 2026-07-28
🔴 Highest-risk AI cost pattern
What this calculator does
Model the cost of a multi-turn agent loop — tool calls, context accumulation, retries — where a naive estimate misses 50-80%.
Why use it
- Agents have a hidden cost explosion: context grows each turn, and every turn pays for the full accumulated context
- Tool-use calls multiply: a 10-step agent loop is not 10x a single call cost — it's often 30x
- Prompt caching is the single biggest lever for agent cost — model it here
New to this calculator? Start with the ⚡ Playground — a few sliders, instant ballpark. Then switch to the 🧮 Calculator for your exact number.
Two ways to use this: visualize in the Playground, then get your number in the Calculator.
What will an agent loop cost?
Tasks × turns × tokens — plus a “runaway tail” for loops that don’t stop. Balanced tier, ~30 days. (Runaway risk fixed at default; see the breakdown.)
Estimated monthly cost
—
Change the input sliders below to see new estimates.
How we got this estimate
—
💡Base = tasks × turns × tokens × rate. The runaway tail adds the cost of a small fraction of tasks looping to their cap — shown in “Why this number”.
Multi-turn agents accumulate context every turn, and one bad loop shouldn't be a $20K surprise.
Set your agent profile below and watch your real per-task cost update instantly.
📊 Not sure of a value? Fields with a ▾ Typical pill offer broad industry ballparks (sourced typical ranges; Agent loops compound context: turn 1 ~2K tokens, turn 10 ~20K. Typical tasks run 4-8 turns; runaways 30-60. The bill is made of the bad days - cap runaway turns/tokens.) so you can move forward now — your result gets more accurate as you replace them with your own measured numbers. Values marked * are rough estimates.
1
Enter key values
Agent turns per task, tokens per turn, task completion rate, tasks/day.
2
Model context growth
Pick linear/quadratic context accumulation. Most agents are quadratic — watch out.
3
Read cost per task
Shows cost explosion from turn 1 → turn N. Total agent cost vs equivalent single-shot.
4
Act on it
If turns > 10, prompt caching saves dramatically. If context > 100K, switch to summarization pattern.
1
Enter agent parameters
Turns per task = average tool-call loop depth. Simple agents: 3-5 turns. ReAct agents: 10-20. Planning agents: can be 50+. Tokens per turn = new content added each turn (tool result + reasoning). Task completion rate = % of tasks that succeed (failed tasks retry, doubling cost). Tasks/day drives scale.
2
Model context growth
Linear growth = agent summarizes context each turn (rare). Quadratic growth = full history passed each turn (common). In quadratic mode, turn N pays for tokens from turns 1..N, so total cost scales as N². A 20-turn agent with 500 fresh tokens/turn ends up passing 10K tokens per call by turn 20 — and you paid for that 10K on every call from turn 1.
3
Interpret the cost breakdown
Per-task cost shows the progression: turn 1 is cheap, turn N is expensive. Total per-task shows the integral. Monthly is per-task × tasks/day × 30. Comparison to single-shot shows how much "multi-turn premium" you're paying. Prompt cache savings projection shows how much caching the stable prefix (system prompt + early turns) can reduce cost.
4
Reduce agent cost
Biggest wins: (1) enable prompt caching on the stable context — see Prompt Cache ROI. (2) summarize context every N turns instead of full history. (3) route turns to cheaper models when not reasoning-heavy (Multi-Model Router). (4) watch out for retries — a 20% failure rate doubles total cost if tasks auto-retry.
👇 Now try the calculator below with your own AI workloads
🤖 Your agent setup
Each "task" runs a multi-turn loop until done. Context accumulates across turns.
Pick a typical agent workload — or switch to ⚙️ Advanced to enter exact tokens
Hint: The agent's main brain. Flagship models cost 3-5x more; only worth it if every step needs deep reasoning.
Hint: Setup text sent every step (instructions + tool list). Turn caching on below or you pay for it each step.
Hint: The opening task you hand the agent, in words. A sentence or two is typical.
Hint: Size of what each tool hands back (file, search result), in words. Piles up every step.
Hint: What the agent writes back each step, in words. Usually short.
Hint: Jobs the agent runs per day at your busiest. Multiplies everything.
Cost per completed agent task
-
-
-
Daily
—
Monthly
—
Tokens/task
—
Daily: —
Monthly: —
Tokens/task: —
Daily spend
-
Monthly spend
-
Total tokens / task
-
-
Context at final turn
-
largest single call
📈 Cost accumulates per turn
Why agents get expensive: context grows every turn.
💡 Optimization levers
🔴 Runaway risk
📊 Same workload, different reasoning model
Agent tasks amplify price differences - every turn pays the premium.
| Model | $/task | $/day | $/month | $/month (cached) |
|---|
🎯 Use this result to
- 🤖 Size your agent budget — Real per-task cost including context bloat from each turn. Most teams underestimate 3-5x.
- 📈 Spot turn-cost growth — Each turn carries forward all prior context. By turn 8 input cost is 3x turn 1.
- 🔧 Tune tool overhead — Bloated tool results are silent cost killers. See exactly how much they add per turn.
- 🔌 Integrate with your AI agents — MCP available for agentic workflow integration. Surface live cost intelligence.