---
title: "What an AI coding agent costs per task: 6 models, real math"
description: "A reproducible cost model for what an AI coding agent costs per task across 6 models. Prices verified 2026-07-13, every assumption editable."
canonical: https://vynaris.com/blog/coding-agent-cost-per-task-6-models
author: "Dhrumil Barot"
author_bio: "Dhrumil is an AI inference and LLM infrastructure expert. Dhrumil built Vynaris to make model access, routing and pricing simple and transparent for developers."
published: 2026-07-13
updated: 2026-08-22
---

# What an AI coding agent costs per task: 6 models, real math

Published 2026-07-13 · Updated 2026-08-22 · By [Dhrumil Barot](https://vynaris.com/about#founder), Founder

A reproducible cost model for what an AI coding agent costs per task across 6 models. Prices verified 2026-07-13, every assumption editable.

The same coding-agent task costs $0.021 on deepseek-v4-flash and $0.85 on Claude Opus 4.8 — a 41x spread on identical work. The reason is not the sticker price per million tokens. It is that a coding agent spends about 20 tokens reading for every 1 token it writes, and it re-reads the same code on every step. Below is the full model, every assumption in a table you can edit, prices verified 2026-07-13 from provider pages.

## TL;DR

- One bug-fix task (8 model calls, ~136k input + ~6.7k output tokens) runs from *$20.92 per 1,000 tasks* on deepseek-v4-flash to *$847.60 per 1,000 tasks* on Claude Opus 4.8. Mid-field: gpt-5.3-codex $331.86, Claude Sonnet 5 $339.04, gpt-5.6-terra $440.56, Claude Haiku 4.5 $169.52.
- Input dominates: at a *20.3:1* input-to-output ratio, the price that matters for agents is the input price, not the headline output price everyone quotes.
- [Prompt caching](https://vynaris.com/glossary/category/inference-and-serving#prompt-caching) cuts the bill *54%* on Anthropic models and *69%* on deepseek-v4-flash, because the stable code context stops being re-billed at full rate on every step.

## What we computed, and why

A chat request is one round trip. A coding [agent](https://vynaris.com/glossary/category/agents-and-harnesses#ai-agent) is a loop: it reads an issue, loads files, plans, edits, runs tests, reads the failures, patches, and repeats. Each pass is a separate model call, and each call re-sends the system prompt, the tool schemas, and the code context. That structure is why agent [inference](https://vynaris.com/glossary/category/inference-and-serving) costs behave nothing like the per-message math people carry over from chatbots.

We modeled one representative task, a small bug fix or feature, as three phases: plan, edit, verify. The goal is not a single "true" number. It is a transparent skeleton you can re-run with your own token counts. All arithmetic is in a script; nothing here was computed by hand.

## The assumptions (edit these)

Every number below is an input you can change. Swap in your own trace and the results move with it.

| Assumption | Value | Note |
| --- | --- | --- |
| Stable prefix per call | 15,000 tokens | system prompt + tool schemas + loaded code context, re-sent each call unless cached |
| Model calls per task | 8 | plan (1) + edit (3) + verify (2), plus 2 for back-and-forth |
| Fresh input per call | 2,000 tokens | new tool results and appended messages, never cacheable |
| Output per call | 838 tokens | reasoning + tool calls + diffs, averaged |
| Total input per task | 136,000 tokens | 8 x (15,000 + 2,000) |
| Total output per task | 6,704 tokens | 8 x 838 |
| Input : output ratio | 20.3 : 1 | this is the whole story |

The 20.3:1 ratio is the load-bearing assumption. Chat apps sit near 3:1 or lower. Agents invert the economics because the [context window](https://vynaris.com/glossary/category/inference-and-serving#context-window) fills with code the model must re-read to stay coherent, and most of that context is [input tokens](https://vynaris.com/glossary/category/cost-and-finops#input-token-cost), not [output tokens](https://vynaris.com/glossary/category/cost-and-finops#output-token-cost).

## Results: cost per task, six models

Prices verified 2026-07-13 from the OpenAI, Anthropic, and DeepSeek pricing pages (sources below). Standard first-party rates, no caching applied yet, no tokenizer adjustment yet.

| Model | Input $/1M | Output $/1M | Cost/task | Cost/1,000 tasks |
| --- | --- | --- | --- | --- |
| [Claude Opus 4.8](https://vynaris.com/models#claude-opus-4-8) | $5.00 | $25.00 | $0.8476 | $847.60 |
| [gpt-5.6-terra](https://vynaris.com/models#gpt-5-6-terra) | $2.50 | $15.00 | $0.4406 | $440.56 |
| [Claude Sonnet 5](https://vynaris.com/models#claude-sonnet-5) | $2.00 | $10.00 | $0.3390 | $339.04 |
| [gpt-5.3-codex](https://vynaris.com/models#gpt-5-3-codex) | $1.75 | $14.00 | $0.3319 | $331.86 |
| [Claude Haiku 4.5](https://vynaris.com/models#claude-haiku-4-5) | $1.00 | $5.00 | $0.1695 | $169.52 |
| [deepseek-v4-flash](https://vynaris.com/models#deepseek-v4-flash) | $0.14 | $0.28 | $0.0209 | $20.92 |

![Cost per 1,000 coding-agent tasks across 6 models](https://cdn.sanity.io/images/u1qdn8dx/production/108e3c1ac367c160e77cbdff10f6047b356b78e6-1260x672.png?w=1440&fit=max&auto=format)

*Cost per 1,000 coding-agent tasks. 136k input + 6.7k output tokens per task, no caching. Prices verified 2026-07-13.*

Notice how the ranking tracks input price almost exactly. gpt-5.3-codex has a high $14 output price but a low $1.75 input price, and it lands cheaper per task than Claude Sonnet 5, whose output is $10. In an output-heavy chat workload the order would flip. Agents reward cheap input.

If you are sizing a real budget, this is the moment to plug your own numbers in: [run the per-task math in the calculator](https://vynaris.com/calculator) with your call count and context size before you commit to a model.

## The tokenizer tax nobody prints on the pricing page

Per-token price is not per-task price, because tokenizers differ. Anthropic states that Claude Opus 4.7 and later, plus Claude Sonnet 5, use a newer tokenizer that produces about *30% more tokens for the same text*. Claude Haiku 4.5 and earlier models use the previous tokenizer.

That means an apples-to-apples comparison (same code, same English prompt) bills the new-tokenizer models for more tokens. Applying the stated +30% to the token counts on those two models:

| Model | Base cost/1,000 | Tokenizer-adjusted /1,000 | Change |
| --- | --- | --- | --- |
| Claude Opus 4.8 | $847.60 | $1,101.88 | +30% |
| Claude Sonnet 5 | $339.04 | $440.75 | +30% |

The adjustment reorders the field. On raw price lists, Claude Sonnet 5 ($339.04) looks cheaper than gpt-5.6-terra ($440.56). On the same task, adjusted for the tokenizer, Sonnet 5 ($440.75) is level with gpt-5.6-terra and more expensive than gpt-5.3-codex ($331.86). The exact multiplier depends on your content, so treat 30% as the provider's stated average, not a guarantee. But do not compare token prices across tokenizer families as if a token means the same thing on both.

## What prompt caching does to the bill

The stable prefix (system prompt, tool schemas, loaded files) is identical across all 8 calls in a task. Without caching, you pay full input price for it 8 times. With [prompt caching](https://vynaris.com/glossary/category/inference-and-serving#prompt-caching), you pay to write it once and then read it cheaply.

Anthropic's multipliers are uniform: a 5-minute cache write costs 1.25x the base input price, and a [cache hit](https://vynaris.com/glossary/category/fine-grained-serving-and-inference-optimization-terms#warm-cache-hit-rate) reads at 0.1x. Applied to our task, the effective input drops from 136,000 tokens to 45,250 token-equivalents — *67% less input*, before touching output.

| Model | No-cache /1,000 | Cached /1,000 | Saving |
| --- | --- | --- | --- |
| Claude Opus 4.8 | $847.60 | $393.85 | 54% |
| Claude Sonnet 5 | $339.04 | $157.54 | 54% |
| Claude Haiku 4.5 | $169.52 | $78.77 | 54% |
| deepseek-v4-flash | $20.92 | $6.51 | 69% |

deepseek-v4-flash saves more because its cache-hit price ($0.0028/1M) is 2% of its cache-miss price, a steeper discount than Anthropic's 10%. OpenAI also offers cached input, but its pricing page did not itemize a per-model cache-read rate in our 2026-07-13 capture, so we left gpt-5.6-terra and gpt-5.3-codex out of this table rather than guess. Caching applies to them too; we will add exact numbers when the page publishes them.

Caching only pays off when calls land inside the cache window and share a prefix. An agent loop on one task is close to the ideal case: the calls are seconds apart and the prefix is stable. This is the single highest-impact change most agent builders have not made.

## What it means for routing

[Right-sizing](https://vynaris.com/glossary/category/routing-and-cost#right-sizing-models) an agent is not one decision. The plan step and the verify step have different quality bars.

- *Route the plumbing, keep the planner.* The verify step, which reads a test failure and applies a mechanical patch, rarely needs a frontier model. Moving verify and simple edits to Claude Haiku 4.5 ($169.52/1,000) or deepseek-v4-flash ($20.92/1,000) while keeping planning on a stronger model captures most of the cost delta without touching plan quality.
- *Input price is your routing signal.* For agents, sort candidate models by input price first. A model with cheap input and expensive output, like gpt-5.3-codex, is well-suited to this read-heavy shape.
- *Cache before you route.* Turning on prompt caching cut 54% here with zero quality change. Do that first; it is a bigger, safer win than most model swaps.

An OpenAI-compatible gateway makes this testable without rewriting provider glue: point one base URL at a router, send verify-step calls to a cheap model, keep planning on the frontier, and compare the invoice. That is the [model routing](https://vynaris.com/glossary/category/routing-and-cost#model-routing) case in one sentence.

## Where this model is wrong

Honesty first, because a cost model that hides its failure modes is marketing.

- *Retries are not in the token counts.* Cheaper models fail the verify loop more often. If deepseek-v4-flash needs 3 extra calls to pass tests where Claude Opus 4.8 needs zero, the per-task gap narrows. Route the cheap model onto steps where a wrong answer is cheap to catch, not onto the planning step where a wrong plan wastes every downstream call.
- *Token counts are illustrative, not measured from your traffic.* We used a public, editable assumption set, not private telemetry. Your prefix might be 40k tokens, not 15k. Re-run the script with your trace.
- *Latency and concurrency have a price this model ignores.* deepseek-v4-flash is cheapest per token, but throughput and rate limits under load are a separate constraint that can push you to a pricier provider for a user-facing agent.
- *The tokenizer adjustment is an average.* The stated 30% varies by content. Measure it on your own prompts before trusting it to the dollar.

When does the expensive model win outright? When one bad plan cascades. On a task where a flawed plan burns all 8 calls and then a human's afternoon, the $0.85 Opus 4.8 run is cheaper than three failed $0.02 runs plus the cleanup. Frontier pricing buys fewer retries, and on the planning step that is often the right trade.

## FAQ

*How much does an AI coding agent cost per task?* On this model (8 calls, ~136k input and ~6.7k output tokens), a single task ranges from $0.021 (deepseek-v4-flash) to $0.85 (Claude Opus 4.8) at standard rates verified 2026-07-13. Prompt caching lowers both ends by 54% to 69%.

*Why is input so much more expensive than output for agents?* Because the agent re-reads its context on every step. At a 20.3:1 input-to-output ratio, input tokens set the bill. Chat apps sit closer to 3:1, which is why chat cost intuition misleads agent builders.

*Does prompt caching really cut agent costs in half?* On the Anthropic models here it cut 54%, and on deepseek-v4-flash 69%, because the stable prefix is re-read cheaply instead of re-billed at full input price. The calls must fall inside the cache window and share a prefix, which an agent loop on one task does naturally.

*Is the cheapest model per token the cheapest per task?* Usually, for read-heavy agent work, because input price drives the total. The exceptions are retry rate (a weaker model that fails verification more often) and the tokenizer a model uses, which changes how many tokens the same text becomes.

*Which model should I route agent steps to?* Keep planning on a stronger model, and route mechanical steps (verification, simple edits, formatting) to a cheaper one like Claude Haiku 4.5 or deepseek-v4-flash. Sort candidates by input price, and turn on caching before you change models at all.

## Sources

- OpenAI API pricing, captured 2026-07-13: https://developers.openai.com/api/docs/pricing
- Anthropic pricing (Claude models, prompt caching multipliers, tokenizer note), captured 2026-07-13: https://platform.claude.com/docs/en/docs/about-claude/pricing
- DeepSeek API pricing, captured 2026-07-13: https://api-docs.deepseek.com/quick_start/pricing
- Cost model script and price snapshot: reproducible from the assumptions table above.

Prices change. We re-verify every figure in this post monthly and stamp updates. Numbers here are current as of 2026-07-13.

Want the same math on your own workload? Vynaris is an OpenAI-compatible gateway that routes each request to the cheapest right-sized model and shows the per-request cost. One base URL swap. Get an API key at vynaris.com.

## About the author

[Dhrumil Barot](https://vynaris.com/about#founder), Founder. Dhrumil is an AI inference and LLM infrastructure expert. Dhrumil built Vynaris to make model access, routing and pricing simple and transparent for developers. [LinkedIn](https://www.linkedin.com/in/bdhrumil) · [X](https://x.com/fyidhrumil)