Best AI for coding

Who this page is for

This page is for developers and teams choosing a model for coding work: an assistant in the editor, a coding agent that edits files and runs commands, or an API model inside your own tooling. It covers language models used for software engineering, not code-completion products or IDE plugins as such.

If you would rather pay a monthly fee for a chat app with a coding agent than pay per token, see the best AI subscription for coding, where consumer plans are scored per price tier on model quality, coding agents, usage limits and price.

How this ranking works

The ranking combines five criteria into one score. The weights are fixed and add up to 100%. Our methodology explains how each criterion is scaled and combined.

• DeepSWE v1.1, 45%. DeepSWE tests coding agents on 113 long-horizon tasks across 91 repositories, written from scratch to limit training-data contamination ^[1]. It is the closest match to real software engineering work that we track, so it carries the largest weight.
• Terminal-Bench 4.0, 20%. Terminal-Bench measures agents completing tasks in a command-line environment, such as builds, debugging and tooling ^[2].
• Blended price, 25%. Coding agents resend large amounts of context across long sessions, so cost per token matters. Lower is better, on a log scale, so that a few very expensive models don't flatten the differences among the rest.
• Context window, 5%. A larger window lets the model see more of a codebase at once. The weight is low because most current flagship models already document 500,000 to about one million tokens.
• Tool calling, 5%. Coding agents read and edit files and run commands through tool calls. The weight is low because nearly all current text models support it.

Which benchmark results count

Scores from different setups are not directly comparable, so each benchmark criterion uses a setting group: a list of stored settings we treat as comparable for this ranking.

• DeepSWE v1.1: all v1.1 runs on the official mini-swe-agent harness, which Datacurve's leaderboard uses for every model ^[1], or on a harness that the source does not state, at any reasoning effort. Runs on provider-specific coding agents are left out. So, for example, Mistral's DeepSWE figure for a preview of Mistral Large 4, measured with a separate harness run by Artificial Analysis ^[3], is not part of the group.
• Terminal-Bench 4.0: every 4.0 run counts, whatever the harness and effort. The benchmark always pairs a model with an agent, and its leaderboard lists each combination of harness, model and effort separately ^[2]. Many models only have results on their provider's own agent, such as Claude Code, Codex or Grok Build ^[4].

Within each group, a model counts with its best result. Independent results are preferred over results a provider reports itself; if only a provider result exists, it is used and marked "self-reported". The methodology box on this page lists every stored setting in each group.

A model needs data for at least 60% of the total weight to be ranked. Terminal-Bench, price, context and tool calling together make up 55%, so only models with a DeepSWE v1.1 result in the group can be ranked.

How to read the results

• Scores are relative. Each criterion is rescaled from 0 to 100 across the candidates on this page. 100 means best among these models, not perfect, and adding or removing a model can shift the others.
• Check the setting. The table shows the setting behind each score, including reasoning effort and harness where the source states them.
• "Self-reported" marks a result that comes from the model's own provider, run on a setup the provider chose.
• Small gaps are noise. DeepSWE has only 113 tasks, so differences of a few points are within noise ^[1]. Terminal-Bench 4.0 margins are about three points ^[4].

Limitations

Grouping lets us compare most current models, at the cost of comparing runs that were not set up identically. Provider-reported coding scores move by several points depending on the setup:

• DeepSeek reports DeepSWE v1.1 scores between 65.5% and 74.2% for the same model, the first release of DeepSeek-V4.1-Flash (September 2026), depending on which agent harness it used ^[5].
• OpenAI reports GPT-6 Astra's DeepSWE score separately for each reasoning effort, from 67.0% at low effort to 74.1% at extra-high effort ^[6]. Because the group takes each model's best run at any effort, a model whose provider published a high-effort run can look stronger than one with only a lower-effort result.
• Anthropic reports 70.6% on Terminal-Bench 4.0 for Claude Sonnet 5.5 from its own run on Claude Code at max effort ^[7], while the public leaderboard lists 61.8% for the same model, harness and effort ^[4]. Where both exist, the ranking uses the independent one.

Further caveats:

• Terminal-Bench results in the group mostly pair each provider's models with that provider's own agent, so part of the score reflects the agent rather than the model.
• Many DeepSWE results are reported by the model's own provider; they are marked "self-reported" in the table.
• Results from earlier benchmark versions are not comparable with DeepSWE v1.1 or Terminal-Bench 4.0, and we don't mix them ^{[1] [2]}.
• A missing result doesn't mean a model is weak at coding, only that we have no comparable measurement. Models without a DeepSWE v1.1 result in the group don't appear in the ranking.
• The data behind this page is as of October 2026.

All published results

The tables below list every published result we hold for both benchmarks, each with its setting and who reported it, including runs outside the ranking's setting groups.

How to choose for your own work

1. Start from the ranking, then check the benchmark pages. On DeepSWE v1.1 and Terminal-Bench 4.0, look for models with results in the same harness you plan to use, or in the official leaderboard setting ^[8].
2. Check cost at your volume. Coding agents resend large amounts of context on every step, so input price and caching matter more than for chat. Use AI pricing and the cost calculator.
3. Compare the shortlist side by side with model comparisons and the individual model pages: context window, maximum output, tool calling and data policy.
4. Test on your own repository. Run the same handful of real tasks, such as a bug fix, a refactor and a test-writing task, with each candidate in your own harness. That is the only result that measures your setup.

Related guides

• How to choose an AI model
• How to compare AI models
• Reasoning models explained
• Context windows explained
• How to reduce AI API costs