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-06-05
🔴 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
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.
🤖 Your agent setup
Each "task" runs a multi-turn loop until done. Context accumulates across turns.
Flagship models (Opus, GPT-5.4) are 3-5x more expensive - is that necessary for every turn?
Repeated across every turn. Cache this or pay for it N times.
Each turn = 1 model call + 1 tool execution. Coding agents avg 8-20, research agents 15-40.
This gets added to context every turn. File reads, API responses, search results.
Cost per completed agent 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.
💡 Cost optimization levers
📊 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.