Cheapest AI models for coding, ranked by cost per task

How this ranking works

Every model is priced per million tokens (input / output). But the ranking metric is cost per task: we assume a typical coding task consumes ~30K input tokens (repo context, prompt) and ~5K output tokens (the patch), then adjust for each model's known characteristics — verbosity, first-attempt success rate, and caching behavior. All figures use September 2026 listed prices from the JetAI dashboard.

The ranking

*DeepSeek off-peak rates. Estimated cost per task adjusts for expected verbosity and retry rates; your mileage varies — measure on your own workload.

Notice the paradox in the table: Luna has the lowest sticker price but ranks #2, because its per-task cost estimate assumes it handles fewer complex tasks on the first attempt. DeepSeek V4.1 Flash earns #1 by combining near-bottom pricing with genuinely capable coding performance. This is the whole argument for cost-per-task ranking: it punishes models that are cheap per token but expensive per result.

#1 DeepSeek V4.1 Flash — the budget king

At $0.30/$1.20 per million tokens during weekday peak hours — halved to $0.15/$0.60 off-peak — DeepSeek V4.1 Flash is the cheapest model that still writes real production code. The off-peak window (outside 01:00–04:00 and 06:00–10:00 UTC weekdays) covers most hours of the day, and DeepSeek's cache-hit pricing is roughly 2% of the input rate.

Trade-off: weaker instruction-following on ambiguous prompts than frontier models, and output quality varies more run to run. It shines when you validate output automatically — tests, linters, type checkers — and let it retry cheaply. For agent loops with verification, retries at $0.60/M output are nearly free.

#2 GPT-6 Luna — cheapest sticker, limited scope

Luna at $0.10/$0.50 is technically the cheapest per token in this lineup. For mechanical coding work — boilerplate generation, bulk refactoring, docstring writing, simple migrations — it's genuinely excellent value.

Trade-off: it's a bulk tier, not a reasoning tier. Hard debugging, architecture decisions, and novel problem-solving belong on a stronger model. The winning pattern: Luna does the mechanical first pass, GPT-6 Sol handles escalation.

#3 Grok 4.7 — the mid-tier sweet spot

At $2/$6 with $0.50/M cached input, Grok 4.7 matches GPT-6 Sol on input price but undercuts it 40% on output. Since coding tasks are output-heavy (generated code, explanations), that output gap matters: our baseline task costs ~$0.09 on Grok 4.7 versus ~$0.11 on Sol. The cached-input rate also makes it strong for long-repo agent sessions.

Trade-off: smaller ecosystem — fewer integrations and less community tooling than OpenAI or Anthropic models. If your stack is built around OpenAI-compatible tooling this matters less than it used to, but check your toolchain before committing.

#4 GPT-6 Sol — the safe default

Sol at $2/$10 is the model most teams should start with and most will never need to leave. Capability is strong across languages, tooling support is the broadest in the industry, and Batch/Flex drops it to $1/$5 for async jobs. It ranks #4 on pure cost-per-task, but #1 on "fewest surprises."

Trade-off: you're paying a brand premium on output tokens — $10/M versus Grok 4.7's $6/M for comparable work. Worth it if your team already has OpenAI-based evals, agents, and workflows.

#5 Claude Opus 5.5 — the premium that's cheaper than it looks

$4/$20 looks expensive next to this list, but Opus 5.5 has two properties that change the math: $0.20/M cache reads and strong first-attempt quality on complex tasks. In JetAI's own 4-experiment coding-agent eval, Opus 5.5 went 4-0 over GPT-5.6 Sol and Grok 4.7 (12 pts vs 7 vs 4) — eval-only, n=1 tasks, draft PRs unmerged, not a universal benchmark). In a long agent session with 80% cache hits, the effective input rate falls to about $0.96/M (0.2×$4 + 0.8×$0.20), which is where the table's ~$0.13/task comes from — and a task completed in one attempt on Opus 5.5 beats a task that took three attempts on a model costing half as much.

Trade-off: sticker shock, and overkill for simple edits. Reserve it for hard tasks and long agents. Full breakdown in the Opus 5.5 pricing deep dive.

Capability trade-offs, summarized

• Under ~$0.01/task (DeepSeek, Luna): excellent for volume, mechanical work, and verified retries. Struggle with novel reasoning and ambiguous specs.
• ~$0.09–0.11/task (Grok 4.7, GPT-6 Sol): the production middle — capable across most coding tasks, predictable, well-tooled.
• ~$0.13/task (Opus 5.5): the reliability pick. Cache economics and first-attempt quality make it competitive on hard, long-horizon work.

Three patterns that cut coding bills further

1. Route by difficulty. Send every task to the cheapest model first; escalate only failures. Most production codebases see 70%+ of tasks solved at the bottom tier.
2. Cache your context. Repo overviews, style guides, and system prompts repeated across turns bill at cache-read rates (down to $0.20/M on Opus 5.5, ~2% on DeepSeek).
3. Schedule off-peak. DeepSeek halves every rate off-peak; Batch APIs cut OpenAI/Google/Anthropic async jobs ~50%. Nightly refactors and test generation should never pay interactive rates.