AI Coding Agent Costs: Per-Task Math for 10 Tools

AI coding agent pricing comparisons almost universally anchor on one number: dollars per million tokens. That framing is practically useless for engineering teams because the dominant cost driver isn't token rate — it's loop count, the number of plan-edit-verify iterations an agent runs before the task passes. This guide builds the missing math: per-task cost across 10 tools, modeled at light (1–3 loops), moderate (8–12 loops), and heavy (20–30 loops) workloads.

The stakes are real. Industry-reported figures suggest the average Claude Code session costs roughly $6 per developer per day, with 90% of users staying under $12 — but those averages mask a 100x spread across tool choice and workload type. A heavy scaffolding task on Codex Pro can exceed $5 per run; the same task routed to Aider on Haiku 4.5 costs under $0.10. Teams that don't run this math before committing to subscriptions routinely overpay by a factor of three to ten.

What follows covers the pricing models for all 10 tools, the per-loop token math, Anthropic's 0.1× cache-hit multiplier and its dramatic effect on real costs, the subscription-vs-API breakeven for each tier, and a decision framework by team size and workload mix. All token assumptions are modeling choices — disclosed as such — not universal benchmarks.

Token rate tells you the cost of a single API call in isolation. Agentic coding tools don't make single API calls — they run planning loops. Each loop reads the relevant codebase context (input tokens), produces edits or shell commands (output tokens), observes the result, and decides whether to iterate. A model that charges $5/M input but completes the task in 4 loops can be cheaper than a model at $0.50/M that requires 12.

Three variables determine actual cost per task: (1) the token rate for input and output, (2) the number of loops the model runs before the task passes, and (3) the cache-hit rate, which for Anthropic models reduces the effective input rate to 0.1× on cached tokens. Published comparisons control for none of these. This calculator fixes that by anchoring on three representative workloads and modeling all three variables explicitly.

The ten tools modeled in this calculator span three billing architectures: subscription-gated usage (Copilot, Kiro, Codex subscription tiers), token-metered subscriptions (Cursor, Claude Code API, Grok Build), and open-source with bring-your-own-key (Aider, Cline, Continue). Each architecture creates a different cost profile under heavy use.

Cursor Composer 2.5 ships at $0.50/M input and $2.50/M output — the lowest frontier-quality input rate in this survey. A Fast variant at $3.00/$15.00 per M tokens offers the same intelligence with lower latency, at 6× the cost. Claude Code can route to three models: Opus 4.7 ($5/$25), Sonnet 4.6 ($3/$15), or Haiku 4.5 ($1/$5 — corrected to $0.80/$4 per M for batch mode). GPT-5.3-Codex via API sits at $1.75/$14 per M. Copilot Pro ($10/mo, 300 premium requests) and Pro+ ($39/mo, 1,500 premium requests) are fixed-subscription models where per-task cost depends entirely on utilization. Amazon Kiro Pro charges $20/mo for 1,000 credits at $0.04/credit effective rate, with overage at the same rate. xAI Grok Build launched at $1.00/$2.00 per M tokens via API plus a SuperHeavy subscription at $99/mo (intro, then $299).

A coding agent loop consists of: reading the task context and relevant code (input tokens), generating a plan, edits, or shell commands (output tokens), and optionally consuming the tool-call result or error as additional input on the next pass. Output tokens are consistently priced 4–8× higher than input tokens across all ten tools modeled here — which means a verbose model that generates long explanations alongside its edits can cost far more than a terse model even at the same input rate.

For this calculator, each loop is modeled with a fixed token assumption per workload tier. Light tasks (bug fixes, small refactors): 5K input tokens + 1.5K output per loop. Moderate tasks (multi-file refactors): 20K input + 4K output per loop. Heavy tasks (project scaffolding or large refactors): 30K input + 6K output per loop. These are conservative estimates — real context windows can grow larger, particularly for Anthropic models that retain full conversation history across tool calls.

The second multiplier is Anthropic's prompt caching. Cache writes cost 1.25× the base input rate but are a one-time charge per context block. Cache reads cost only 0.1× the base rate. A session with 60% cache-hit rate effectively pays 0.1× on 60% of its input and 1.0× on 40% — producing an effective input multiplier of approximately 0.46×. At 90% cache hits, the effective multiplier drops to 0.19×. This is the math that makes high-loop Sonnet 4.6 sessions surprisingly cost-competitive with Cursor Composer 2.5.

Rather than model a single generic task, the calculator below uses three workloads that cover the realistic range of agentic coding use. Each is defined by loop count and per-loop token consumption — the two variables that drive total cost once you know the token rate.

The table below calculates total per-task cost for each tool at the midpoint loop count of each workload. Moderate-task figures for Claude Code models include a 60% cache-hit adjustment — the realistic operating point for most multi-session codebases. Heavy-task figures show both uncached and cached costs where applicable. Subscription tools show effective per-task cost at three utilization levels.

Reading the table: Light = 2 loops × (5K in + 1.5K out); Moderate = 10 loops × (20K in + 4K out) with 60% cache for Anthropic models; Heavy = 25 loops × (30K in + 6K out) with 70% cache for Anthropic models. All costs in USD.

The most striking number in the table: Cursor Composer 2.5 Fast at $36.00 per heavy task. The Fast tier's 6× input premium turns a reasonable moderate-task tool into an expensive option for heavy workloads. Unless latency is critical and the task is moderate, the standard Composer 2.5 tier is the correct choice for cost-sensitive teams. See our Cursor 3 deep dive for guidance on when Fast mode actually pays off.

On the other end, Claude Code Haiku 4.5 via Aider or Continue.dev delivers the lowest per-task cost in this survey — $0.02 light, $0.25 moderate, $0.81 heavy. The caveat is Haiku 4.5's quality ceiling: for tasks requiring complex multi-file reasoning or deep architectural understanding, Haiku may require 30–50% more loops than Sonnet or Opus, partially offsetting the token-rate advantage.

Anthropic's prompt caching is documented but routinely ignored in cost comparisons. The mechanics: tokens stored in the cache on first use cost 1.25× the base input rate (a cache write premium). On subsequent reads, those same tokens cost only 0.1× — a 90% discount on input. Cache blocks persist for five minutes by default in Claude Code, reset on each new message.

The effective input multiplier for a session depends on the cache-hit rate. At 0% hits (cold start every loop), you pay full rate. At 30% hits, your effective multiplier is (0.7 × 1.0) + (0.3 × 0.1) = 0.73×. At 60% hits it drops to 0.46×. At 90% hits, you effectively pay only 0.19× the base input rate. For a Sonnet 4.6 session at 90% cache-hit rate, the effective input cost falls to roughly $0.57/Mtok — meaningfully below Cursor Composer 2.5's uncached $0.50/Mtok.

The practical implication: a codebase where Claude Code has already processed the repo map (the dominant input cost in multi-loop sessions) will see 50–80% cache hits on input tokens within the same five-minute session. This is why industry-reported daily costs for Claude Code are lower than a naive token-rate calculation would suggest. The average $6/developer/day figure from independent research already reflects substantial caching — an uncached equivalent would be approximately $12–18/day. For a deeper breakdown, see our Claude Code feature deep dive.

The subscription-vs-API question has a precise answer for each tool once you know your monthly token volume. For Claude Code Pro ($20/mo), the included usage covers a defined amount of Pro plan activity — roughly equivalent to $20–$25 of API-equivalent compute. The breakeven for API-direct sits at the point where your monthly API bill would exceed the subscription fee.

With caching at 60%, Sonnet 4.6 tasks cost roughly 46% of uncached rate. For a developer running 10 moderate-task sessions per week (10 × 4 weeks × $0.50 cached = $20/mo), Claude Code Pro is roughly at breakeven. Go above that frequency and Pro pays; go below and API-direct is cheaper. The credit overhaul announced for June 15 may shift these numbers — see our Anthropic credit overhaul post for the latest changes.

One factor that flips the equation: Grok Build's SuperHeavy subscription ($99/mo intro) includes up to 8 parallel sub-agents. For teams that need concurrent agent execution — running tests, writing docs, and refactoring simultaneously — the effective per-task cost under parallel execution can be 3–5× lower than sequential agent runs on the same token budget. See our Grok Build parallel agents guide for a full breakdown of the concurrency model.

The lowest-cost option in this survey — Aider on Haiku 4.5 at ~$0.02 per light task — is not the best value for every team. Quality at the frontier matters because smarter models complete tasks in fewer loops. A model that closes a moderate refactor in 6 loops instead of 10 saves 40% of the total cost, even if its per-token rate is higher. The per-task cost calculator above assumes fixed loop counts; real-world loop counts vary by model capability.

Industry benchmarks suggest frontier models (Opus 4.7, GPT-5.3-Codex) complete complex multi-file tasks in roughly 60% of the loops required by smaller models. Applied to the heavy workload: Opus 4.7 at 15 loops (instead of 25) costs approximately $3.00 cached vs $2.38 at the full 25 loops for Haiku 4.5. The quality premium disappears. For teams with a high proportion of complex architectural tasks, routing to Opus 4.7 with caching may be the highest-value combination, not the highest-cost one. Our AI analytics engagements routinely surface this pattern in client token-spend audits.

This framing — cost per successful task, not cost per token — is the right evaluation metric for agentic tools. A cheaper model that requires manual intervention to fix its output three times costs more in developer time than a frontier model that gets it right in one pass.

The calculator shows that no single tool wins across all workload types. The optimal configuration depends on three factors: your workload mix (what fraction of tasks are light vs heavy), your loop-count efficiency expectations (how often does the model complete tasks without retries), and your sensitivity to latency vs cost (Fast mode costs 6× more but runs faster). The grid below summarizes the recommended configuration for each team archetype. For Kiro-specific credit modeling, see our Kiro migration playbook.

The critical habit for any team running AI coding agents at scale: track per-task cost, not per-session spend. A session that runs one heavy task costs the same as ten light tasks — but the business value is categorically different. Integrating token spend into your engineering analytics dashboard is the foundation for optimizing the model-routing decisions above. Our AI transformation service includes cost observability as a first-class deliverable on every agent deployment engagement.