Best AI Coding Agents in 2026, Ranked

Summary: AI coding agents are autonomous developer tools that plan tasks, edit code across repositories, run tests, and submit pull requests with less human handholding than autocomplete assistants.

In this September 2026 refresh, Claude Code and Codex share #1. On the official Terminal-Bench 4.0 leaderboard, GPT-6 Astra in Codex now scores 58.2% and Claude Fable 5.1 in Claude Code 57.9%, a gap well inside the margin of error. Cursor rises to #3 after SpaceX completed its acquisition, and Devin rises to #4 on Cognition’s SWE-2 model and absorbs Windsurf, which is now Devin Desktop. Grok Build rises to #5 on price per unit of work and on our own use at MightyBot, where it does much more per dollar than Copilot’s agent, even though its official Terminal-Bench 4.0 score is still weak. Three models enter the list: Pareto, a composite model from Unbiased that our early use puts in the same class as Fable 5.1, at #7; DeepSeek V4.1 Flash, the best cheap coding model we have used, at #9; and GLM-5.3 Flash, a solid cheaper option that in our hands trails DeepSeek, at #11. The structural shift from July still holds: the best teams assign models per task, using an expensive model to plan and cheaper ones to execute in parallel.

Updated September 18, 2026

What Changed in September 2026

• GPT-6 Astra is now the Codex default: OpenAI made it the bundled default when no model is configured on September 4 and added it to the model picker on September 9. OpenAI reports 57.9% on Terminal-Bench 4.0, against 37.3% for GPT-5.6 Sol and 55.8% for Claude Fable 5.1, at $10/$50 per 1M tokens. The Agents API (public beta, September 10) puts the same harness behind an API
• Claude Fable 5.1 reached Claude Code the week of August 31 with a 1M-token context window. Anthropic prices it at $10/$50 per 1M tokens and estimates typical workloads cost 25% less than on Fable 5. On the official Terminal-Bench 4.0 leaderboard, Fable 5.1 in Claude Code leads at 57.9%
• SpaceX completed its acquisition of Cursor on August 14, Grok 4.6 became Cursor’s first-party model, and Projects (September 10) added a coordinator agent that plans work and delegates it to agents
• Cognition removed Windsurf’s Cascade agent on September 8, so Windsurf is now Devin Desktop. Two days later it released SWE-2, post-trained from Kimi K3, at 50.0% on FrontierCode 1.1 Main, and it raised over $2B at a $48B valuation
• GitHub Copilot shipped every frontier model as generally available: Claude Opus 5 (July 24), Kimi K3 (August 6), Grok 4.6 (August 14), Claude Fable 5.1 (September 1) and GPT-6 Astra (September 4)
• DeepSeek released V4.1 Flash on September 10: a 552B-parameter MoE with a 1M-token context window and MIT-licensed weights, priced at $0.15/$0.60 per 1M tokens off-peak and $0.30/$1.20 at peak. DeepSeek reports 31.2% on Terminal-Bench 4.0 in its own harness; it is not on the official board yet
• Unbiased launched Pareto on September 17: a composite model that runs several models on each request and keeps the best answer, at $2.50/$7.50 per 1M tokens, through Unbiased’s API and OpenRouter. All of its benchmarks are vendor-reported
• Z.ai released GLM-5.3 Flash on August 26: 320B total parameters, 18B active, MIT-licensed, priced at $0.15/$0.50 per 1M tokens with a 1M context. Z.ai reports 84.3 on Terminal-Bench 2.1 in Claude Code and publishes no Terminal-Bench 4.0 number
• Grok Build Memory reached general availability on September 16: the agent “now carries conventions, decisions, and project facts from one session to the next”, with /memory and /dream commands, in Grok Build v1.0.34
• The finding that still matters most is mixing providers beats any single vendor’s stack. The casting has changed with the models: Fable 5.1 orchestrating, GPT-6 Astra and Claude Opus 5 splitting implementation and code review across provider lines, and cheaper models absorbing the volume. Cross-provider review is the part that pays, because a model reviewing its own family’s output repeats its own blind spots. Jump to the full pattern

The Top Coding AI Agents in 2026

Quick Comparison

1. Claude Code (Anthropic), Joint #1: Best for Repository-Shaped Work

Claude Code is Anthropic’s agentic coding tool that lives in your terminal, reads your codebase, edits files, runs commands, and manages git workflows through natural language.

It shares #1 with Codex in this refresh, after holding the spot alone since this page began. Claude Fable 5.1 reached Claude Code the week of August 31, and the two top entries on the official Terminal-Bench 4.0 leaderboard both run inside this harness. Claude Code is still the only major agent where you can assign a different model and a different reasoning budget to each worker in a single session.

Key capabilities:

• Claude Fable 5.1 with a 1M-token context window: available in Claude Code since the week of August 31, priced at $10 per million input tokens and $50 per million output tokens; Anthropic estimates it costs 25% less than Fable 5 for typical workloads
• Claude Opus 5 at $5/$25: Opus 5 shipped July 24 at $5/$25 per 1M tokens and holds the third-best entry on the official Terminal-Bench 4.0 board at 53.9%, which makes it the affordable frontier model for review and repo-level work
• Per-subagent model selection: a subagent’s model field accepts sonnet, opus, haiku, fable, a full ID such as claude-opus-5, or inherit, and a separate effort field takes low through max independently of the session setting
• Isolated context per worker: each subagent runs in its own context window and returns only a summary, so search results, logs, and test output never crowd the planning session
• A usable orchestrator seat: run the session on Claude Fable 5.1 and it can plan, delegate, and arbitrate while workers do the building, including workers from other vendors invoked as shell processes, covered in detail below
• Agent teams: for work that outgrows one context window, agent teams give each teammate an independent context, a shared task list, and direct peer messaging
• Cross-session messaging and self-hosted cloud environments: in early August Claude Code added messaging between sessions on macOS and Linux, put self-hosted environments for cloud sessions into public beta on Team and Enterprise, and made auto mode the default permission mode on Pro, Max and Team from August 14
• IDE, CLI, and mobile workflows, plus the Agent SDK for building custom agents on the same infrastructure

Why it’s joint #1: On the official Terminal-Bench 4.0 leaderboard, the one independent board that covers these harnesses, Claude Code holds the second and third entries: Fable 5.1 at 57.9% ± 3.8% (submitted September 1) and Opus 5 at 53.9% ± 3.2%. GPT-6 Astra in Codex sits just above at 58.2% ± 2.8%. Add per-subagent model and effort control and a weekly product cadence, and Claude Code is still the strongest system you can run for repository-shaped work.

The counter-evidence is real and worth stating. GPT-6 Astra now holds the top entry on the official leaderboard, and the board lists its full run at $3.3k against $6.2k for Fable 5.1. OpenAI’s own table reports a similar split, 57.9% against 55.8%, at what OpenAI estimates is 63% lower API cost per task. Anthropic’s own table also gives Fable 5.1 55.8% and Opus 5 52.3% on the same benchmark, a little under the official-board numbers. That is why we call it a tie: the two top scores sit 0.3 points apart with error bars of about three points, and Codex gets there at roughly half the cost.

If your work is driving a computer or a long terminal chain and you are already on the OpenAI API, look at Codex. If it is understanding a repository and changing it in many places, start here.

1. Codex (OpenAI), Joint #1: Best for Terminal-Shaped and Computer-Use Work

Codex is OpenAI’s coding agent platform spanning the Codex app, cloud delegation, an open-source CLI, IDE extensions, and connected ChatGPT workflows. GPT-6 Astra became the CLI’s bundled default in September, and the same harness is now available to developers through the Agents API. Codex gained more ground than any other entry this quarter.

Key capabilities:

• GPT-6 Astra as the default model: the Codex changelog made GPT-6 Astra the bundled default when no model is configured on September 4 and added it to the model picker on September 9; GPT-5.5 retires from ChatGPT and Codex on October 14
• Reported benchmark highs: OpenAI reports 57.9% on Terminal-Bench 4.0, 74.1% on DeepSWE v1.1 and 53.3% on FrontierCode 1.1 Main for Astra; API pricing is $10 per million input tokens and $50 per million output tokens
• Faster computer use: the Codex harness update gives 1.9x faster task completion than the GPT-5.6 Sol experience on the Mind2Web benchmark
• Agents API: public beta on September 10, described by OpenAI as “bringing that same harness and infrastructure that powers Codex to developers through a simple, flexible API” (developer guide)
• Multi-agent worktrees: Codex can run agents in parallel across cloud environments and local workspaces, letting teams split implementation, review, refactor, and test workstreams
• Local + cloud execution: developers can pair in the terminal or IDE, delegate longer work to the cloud, and continue from the same ChatGPT-connected account
• AGENTS.md convention: hierarchical project instructions guide codebase navigation, testing, review standards, and repo-specific engineering practices
• Automations and Skills: background scheduled agent runs and reusable skills make Codex useful beyond one-off code generation, including documentation, issue triage, CI/CD follow-up, and deployment workflows
• Code review quality: Codex is increasingly differentiated by high-signal code review, test generation, and catching integration issues before humans merge changes

Why it’s joint #1: The gap between Codex and Claude Code is now inside the difference between two vendors’ tables. OpenAI’s own table puts GPT-6 Astra at 57.9% on Terminal-Bench 4.0, ahead of Fable 5.1’s 55.8%, and at an estimated 63% lower API cost per task. The official Terminal-Bench 4.0 leaderboard now agrees: GPT-6 Astra in Codex scores 58.2% ± 2.8%, submitted September 3, against 57.9% ± 3.8% for Fable 5.1 in Claude Code, and the board lists Astra’s full run at $3.3k against $6.2k. Codex has the edge on score per dollar. The score gap is too small to separate them.

One correction from the July version of this page: the SWE-bench Pro split we cited, 64.6% for GPT-5.6 Sol against 69.2% for Claude Opus 4.8, comes from OpenAI’s own GPT-5.6 launch table, and we described it as third-party runs. It is vendor-reported. Scale’s public SWE-bench Pro leaderboard does not yet list GPT-5.6, Opus 5 or any Fable model; its top entry is Meta’s Muse Spark 1.1 at 61.5%.

Where Codex leads outright is computer use and the API. The 1.9x Mind2Web speedup is the biggest single harness improvement in this window, and the Agents API makes Codex the only frontier coding harness you can call from your own code. For teams already standardized on OpenAI, it remains an easy call.

Codex vs Claude Code: the direct comparison

They share #1. Claude Code has more control per worker and two of the top three entries on the independent leaderboard. Codex has the top entry by 0.3 points, about half the run cost, and the only frontier coding harness available as an API. That matches our own experience at MightyBot: we run both daily and find them equally good overall, with GPT-6 Astra the stronger of the two at writing code and Claude Fable 5.1 the one we put in the orchestrator seat. Choose Claude Code for repository-shaped work, Codex for terminal-shaped and computer-use work, or run both and put each one in review of the other’s changes.

3. Cursor (Anysphere, now part of SpaceX): Best AI-Native IDE

Cursor is an AI-native code editor (VS Code fork) that integrates AI into every part of the editing experience. SpaceX completed its acquisition of Cursor on August 14, 2026, and Grok 4.6 is now the editor’s first-party model. It rises two places in this refresh.

Key capabilities:

• Grok 4.6 as the first-party model: released August 12; Cursor says it “matches GPT-5.6 Sol on the Artificial Analysis Intelligence Index”, with pricing starting at $2 per million input tokens and $6 per million output tokens
• Projects with a coordinator agent: from September 10, a project’s coordinator agent “doesn’t write code itself; it plans the work, delegates it to agents that implement it”, so one editor session can run a planner over a set of workers
• Cloud agents on your own infrastructure: September 2 added cloud agents on customer-managed infrastructure and computer use on Linux and Mac; since August 27 cloud agents no longer require a connected GitHub or other SCM
• /goal and subagents on their own VMs: added August 19, giving each subagent an isolated machine
• Every frontier model, one editor: Claude, GPT and Gemini models run inside the same agent surface, so model choice is a dropdown rather than a migration
• Cursor Blame (Enterprise): extends git blame to distinguish human edits from tab completions and agent runs
• AI Code Review: in-editor bug detection surfaced in the sidepanel

Why it’s #3: Cursor is where most engineers who use a coding agent already spend their day, and the September changes turned the editor into a delegation surface: Projects gives it a planner that hands work to agents, cloud agents run on customer-managed infrastructure, and computer use covers Linux and Mac. SpaceX ownership settles the funding question and ties the first-party model to xAI’s Grok line.

It sits behind Claude Code and Codex for two reasons. Heavy automation and CI work still lives more naturally in a CLI. And the model Cursor leads with, Grok 4.6, scores 20.3% on the official Terminal-Bench 4.0 board in xAI’s own Grok Build harness, well behind the models the two agents above run by default. Cursor’s other models are one dropdown away, which is the reason that gap costs it only two places.

4. Devin (Cognition), including Devin Desktop, formerly Windsurf: Best for Delegating Whole Tasks

Devin is Cognition’s autonomous software engineer. It runs in its own cloud environment with a browser, terminal and editor, and it is now also the agent inside Devin Desktop, the IDE that used to be Windsurf. On September 8 Cognition removed the Cascade agent: “Devin Local is now the only agent available in Devin Desktop.” Two days later it shipped its own model. Devin rises five places in this refresh and absorbs Windsurf’s former entry.

Key capabilities:

• SWE-2, Cognition’s own model: released September 10, post-trained from Kimi K3, and reported by Cognition as “achieving 50.0% on FrontierCode 1.1 Main, within one point of Fable 5.1 while being 64% cheaper”
• Devin Desktop: the former Windsurf editor, running Devin Local as its only agent since v3.9.19 on September 8
• Fusion in Desktop and CLI: shipped September 11 to both Devin Desktop and the Devin CLI
• End-to-end autonomy: plans, codes, tests, and deploys in its own sandboxed environment with no IDE required
• Computer use for testing: can test desktop applications that run on Linux
• Pricing: Free, Pro at $20 a month, Max at $200 a month, Team at $80 a month plus $40 per seat

Why it’s #4: Devin is the entry to pick when you want to hand over a whole task and read the pull request later, and this quarter Cognition backed that with capital and a model. The September 8 Series E: “Cognition has raised over $2B at a $48B valuation”, and “run-rate revenue has grown from $492M to almost $900M” since May. SWE-2 gives Devin a first-party model that Cognition reports within a point of Fable 5.1 on FrontierCode 1.1 Main at 64% lower cost, which is the economics an agent that runs unattended needs. Folding Windsurf into Devin Desktop removes the roadmap conflict the July version of this page flagged.

It sits behind Cursor because the FrontierCode figure is Cognition’s own, SWE-2 has no entry on the official Terminal-Bench 4.0 board, and delegating whole tasks suits teams that are comfortable reviewing large diffs cold. If that describes you, Devin is the most autonomous option on this list.

5. Grok Build (xAI): Best Value Frontier-Class Harness

Grok Build is xAI’s coding agent, and its case is dollar value. Grok 4.6, released August 12, is its default model at $2/$6 per 1M tokens, the agent’s own grok-build-0.1 costs $1/$2, and since August 19 Grok Build has been available on every plan, on the web and on mobile. It rises three places in this update, from #8 to #5, on that pricing, on subscription value, and on our own use at MightyBot, where it does much more per dollar than Copilot’s agent.

Key capabilities:

• Grok 4.6 at $2/$6: xAI’s frontier model “for coding, agentic tasks, and knowledge work”, priced at $2/$6 per 1M input and output tokens below 200k prompt tokens, with a 500k context window and reasoning effort from low to xhigh
• grok-build-0.1 at $1/$2: the agent’s own lighter model, priced at $1/$2 per 1M tokens
• Memory, generally available September 16: Grok Build “now carries conventions, decisions, and project facts from one session to the next”, with a /memory browser and a /dream command that organizes notes into topic files; it shipped in v1.0.34
• Open-source harness: xAI open-sourced the Grok Build harness and TUI on July 16, so the agent loop is inspectable
• Every plan, every surface: on every plan, on the web and on mobile since August 19, plus the CLI, which shipped v1.0.19 through v1.0.34 between September 4 and September 16
• Other models through a provider: in our own use at MightyBot we run DeepSeek V4.1 Flash inside Grok Build through an API provider such as Fireworks, and it is a very strong harness for it. xAI does not list this as an official integration
• Agent and CLI workflow: a /goal slash command, a /sessions flow, skill and plugin handling, and fast startup on large repositories
• Cursor distribution: Grok 4.6 is Cursor’s first-party model, so it is available inside the most popular AI-native IDE without a separate account

Why it’s #5: Value first. Grok 4.6 at $2/$6 undercuts every model above it on this list, grok-build-0.1 at $1/$2 goes lower, and the harness comes with every plan. In our own use at MightyBot, Grok Build is much stronger than Copilot’s agent and does much more per dollar. That is first-hand experience, not a benchmark result, and it is the reason it moves above Copilot.

The independent number is still weak, and we are not hiding it. On the official Terminal-Bench 4.0 leaderboard, Grok 4.6 running in Grok Build scores 20.3%, against 58.2% for GPT-6 Astra in Codex and 57.9% for Fable 5.1 in Claude Code, and no Grok model has been submitted in any other harness. xAI’s own table shows the same ordering: Grok 4.6 at 65.9% on DeepSWE v1.1 against 73% for GPT-5.6 Sol and 70% for Fable 5, and 26% on Terminal-Bench v3.0 against 34.6% and 34.1%. The one third-party result since August is SWE-Marathon v1.1, where Grok 4.6 (high) in Grok Build scores 31.9% against 45.6% for Fable 5.1 (max) in Claude Code and 42.5% for GPT-6 Astra (max) in Codex. Read the 20.3% through the harness caveat in the Kimi entry: part of it is the model and part is the Grok Build harness. On metered API pricing the value case is weaker than the token prices suggest: the leaderboard lists Grok Build’s full run at $3.6k against $3.3k for GPT-6 Astra in Codex, for a far lower score.

Subscriptions are where Grok Build wins, and most teams pay for coding agents that way. In our own use at MightyBot, a SuperGrok Heavy subscription goes far further in Grok Build than an OpenAI Pro 20x subscription does with GPT-6 Astra in Codex, because Astra uses up the allowance quickly. OpenAI’s own Codex pricing page estimates 100 to 900 local GPT-6 Astra messages per five-hour window on Pro 20x, against 200 to 2,000 for GPT-5.6 Sol on the same plan. Pick Grok Build for high-volume work on a subscription, and keep a stronger model in the reviewer seat.

6. GitHub Copilot (Microsoft/GitHub): Widest Ecosystem, Every Frontier Model on Day One

GitHub Copilot evolved from an autocomplete tool into a full agentic platform spanning IDE, CLI, and autonomous cloud agents. The Copilot Coding Agent takes a GitHub issue and opens a draft PR. It rises two places from the July version because it has become the fastest place to get every frontier model as a generally available option.

Key capabilities:

• Every frontier model, generally available: per the GitHub changelog, Claude Opus 5 (July 24), Kimi K3 (August 6), Grok 4.6 (August 14), Claude Fable 5.1 (September 1) and GPT-6 Astra (September 4) are all GA in Copilot
• Copilot Coding Agent: assign a GitHub issue and it works asynchronously in the background via GitHub Actions, delivering a draft PR when done
• Agent Mode in IDE: reads files, runs code, identifies lint and test failures, and loops to fix, across VS Code, JetBrains, Eclipse, and Xcode
• Custom Agents ecosystem: partner-built and user-defined agents via the .github/agents/ directory
• Plans: Free at $0, Pro at $10, Pro+ at $39, Max at $100 per month; Business and Enterprise seats move to an upfront charge at the next billing cycle, starting October 1, 2026 for existing customers

Why it’s #6: Copilot has the broadest IDE support (VS Code, JetBrains, Eclipse, Xcode, Neovim) and the largest installed base in enterprise, and this quarter it became the surface where model churn costs the least: every frontier model on this page shipped in Copilot as generally available within days of release, on plans from $0 to $100 a month. It stays behind the four at the top because its agent layer runs through GitHub Actions and the IDE rather than a delegation surface with per-worker model control. It sits behind Grok Build on our own use at MightyBot, where Grok Build’s agent is much stronger and does much more per dollar; that is first-hand experience rather than a benchmark, so weigh it as such. The October 1 move to upfront billing for Business and Enterprise seats also changes the procurement conversation for its largest customers.

7. Pareto (Unbiased): Best New Frontier-Class Model to Watch

Pareto is a composite model from Unbiased, built by Circuit & Chisel, “a remote-first team located across the US and Canada.” It launched on September 17. It is not a single model: “Under the hood it runs several models on your request and keeps the best answer.” It enters at #7 on our early use at MightyBot, which puts it in the same class as Claude Fable 5.1. That is first-hand experience, and no independent benchmark of it exists yet.

Key capabilities:

• Composite by design: Unbiased describes it as “a multimodal composite model built for research, coding, and agentic workflows” and says it “never switches models mid-conversation, so your prompt cache, and the savings, stay intact”
• Pricing: $2.50 per 1M input tokens, $7.50 per 1M output tokens, and $0.25 per 1M cached input tokens
• Context: a 262,144-token context window with up to 131,072 completion tokens
• Access: sign up on Unbiased’s site and call its API, or use the OpenRouter listing; we had it running on launch day. Any harness that accepts an OpenAI-style endpoint or OpenRouter can drive it
• Vendor-reported benchmarks: Unbiased’s own model card puts Pareto at 74 on DeepSWE against 67 for Fable 5.1 and 74 for GPT-6 Astra, and at 51 on Terminal-Bench 4.0 against 56 for Fable 5.1 and 58 for Astra. Unbiased adds: “Measured task costs and a composite score have not been published for this release.”

Why it’s #7: In our own use at MightyBot, Pareto’s answers land in the same class as Claude Fable 5.1, at $2.50/$7.50 per 1M tokens against Fable 5.1’s $10/$50. That is the whole case, and it is first-hand. The caution is about evidence, not access: the model launched September 17, every published score is vendor-reported, it has no entry on the official Terminal-Bench 4.0 leaderboard, and OrcaRouter notes that “no independent evaluator has published a score for this model”, including Artificial Analysis. It sits above OpenCode because our early results are strong, and below Copilot because two days of first-hand use is not yet a track record. If the independent boards confirm what we see, it moves up.

8. OpenCode (Anomaly): Best Open-Source AI Coding Agent

OpenCode is an open-source, provider-agnostic coding agent, now developed at anomalyco/opencode. It runs Claude, GPT, Gemini, Grok, Kimi, or local models through Ollama in the same harness. Its site reports “over 208,000 GitHub stars, 950 contributors, and over 13,000 commits” and use by “over 16M developers every month”.

Key capabilities:

• Provider-agnostic: use Claude, GPT, Gemini, Grok, Kimi, DeepSeek, GLM, or local models via Ollama and llama.cpp; no vendor lock-in
• Official support from the cheap-model vendors: DeepSeek says “OpenCode now fully support V4.1-Flash”, and Z.ai tested GLM-5.3 Flash anonymously on OpenCode before release
• Dual-agent architecture: built-in “build” agent (full access) and “plan” agent (read-only analysis), switchable with Tab
• LSP integration: Language Server Protocol support feeds real-time diagnostics and code intelligence back to the LLM
• MCP support: Model Context Protocol for integrating external tools and services
• Desktop app with tabs: alongside the CLI and editor extensions, the desktop app now runs several sessions in tabs

Why it’s #8: OpenCode drops four places from the July version and keeps the open-source label. Its numbers are larger than in July: its site now claims over 208,000 GitHub stars, 950 contributors and 16M monthly developers. What moved it down is the window itself: the two months since July brought patch releases and the desktop tabs, while Cursor shipped Projects and customer-managed cloud agents, Devin shipped a model, and Copilot shipped every frontier model. It sits behind Grok Build on our own use at MightyBot and behind Pareto on our early results with that model, both first-hand calls. For teams where security policy blocks proprietary tools, the ability to run entirely offline with local weights remains a decisive advantage, and it is the harness we would pair with DeepSeek V4.1 Flash, GLM-5.3 Flash or Kimi K3 for a fully self-hosted stack.

MightyBot applies this same agentic architecture beyond coding: learn how policy-driven AI agents automate mission-critical workflows, including a production lending deployment running at 99%+ accuracy.

9. DeepSeek V4.1 Flash (DeepSeek): Best Cheap Coding Model

DeepSeek V4.1 Flash was released on September 10 as a “552B-parameter MoE” with a 1M-token context window and MIT-licensed weights. It enters at #9. In our own use at MightyBot it is excellent for coding at a very low price, and it is the better of the two cheap models on this list; GLM-5.3 Flash is the other.

Key capabilities:

• Price: $0.15 per 1M input tokens and $0.60 per 1M output tokens off-peak, $0.30/$1.20 at peak, with cache hits at $0.003/$0.006. DeepSeek’s rule: “Off-peak rates are half of the peak rates.”
• Context and output: a 1M-token context window with a 384K maximum output, under the model name deepseek-flash
• Open weights: “This repository and the model weights are licensed under the MIT License.” Artificial Analysis counts it available through 12 API providers, including Fireworks at $0.22/$0.66 and DeepInfra at $0.20/$0.60
• Sourced harness support: DeepSeek says “Official partners WorkBuddy (including CodeBuddy) & OpenCode now fully support V4.1-Flash”, and it publishes its own Claude Code guide through an Anthropic-compatible endpoint, where “Models starting with claude-haiku or claude-sonnet are mapped to deepseek-flash.” That is DeepSeek’s integration, not an Anthropic feature. DeepSeek also ships its own DeepSeek Harness CLI
• Where we run it: in our own use at MightyBot we also run it inside Cursor’s agent and inside Grok Build, through an API provider such as Fireworks, and both are very strong harnesses for it. Neither Cursor nor xAI lists DeepSeek as an official integration
• Vendor-reported benchmarks: DeepSeek’s model card reports 31.2 on Terminal-Bench 4.0, 74.2 on DeepSWE v1.1 and 90.6 on Terminal-Bench 2.1, evaluated “with the Minimal mode of DeepSeek Harness and a 1M-token context window”. The model does not appear on the official Terminal-Bench 4.0 leaderboard or on SWE-bench Verified

Why it’s #9: In our own use at MightyBot, DeepSeek V4.1 Flash does real coding work well at a price that changes what you assign to it: $0.15/$0.60 off-peak against $3/$15 for Kimi K3 and $10/$50 for Fable 5.1 or GPT-6 Astra. It is the model we reach for first when the job is volume. It ranks above Kimi K3 because it does most of the same work at a fraction of the price, and below OpenCode because it has no independent coding score yet: the 31.2 on Terminal-Bench 4.0 is DeepSeek’s own run in its own harness, and the model is on neither public board. One honest note: Artificial Analysis scores it 40 on its Intelligence Index, slightly below GLM-5.3 Flash at 42. That index is not coding-specific, and in our hands DeepSeek is the better coding model.

10. Kimi K3 and Kimi Code (Moonshot): Best Open-Weight Model at Frontier Scale

Kimi K3 is Moonshot’s open-weight flagship, and Kimi Code is the company’s own coding harness, which reached version 2.0.0 on September 17. K3 is the open-weight model with the most reach this quarter: it is generally available in GitHub Copilot, and it is the base Cognition post-trained into SWE-2.

Key capabilities:

• Open weights at frontier scale: 2.8 trillion parameters, a 1M-token context window, and native visual understanding, built on Moonshot’s Kimi Delta Attention and Attention Residuals
• Kimi Code 2.0: Moonshot’s own harness reached 2.0.0 on September 17
• API pricing: $3 per 1M input tokens and $15 per 1M output tokens on Moonshot’s platform
• Distribution: generally available in GitHub Copilot since August 6; Cognition’s SWE-2 “is post-trained from Kimi K3”
• Harness-agnostic: usable from OpenCode, Aider, or Kimi Code, so it drops into an existing open stack

Read the numbers carefully. Moonshot’s published coding results are Moonshot-run evaluations, and the company’s own coding table mixes harnesses (KimiCode, Claude Code, Codex, mini-SWE-agent) where harness choice alone can move a score substantially. Moonshot itself says K3 still trails Claude Fable 5 and GPT-5.6 Sol on overall performance. Treat headline scores as a ceiling rather than a like-for-like comparison with the proprietary agents above.

Why it’s #10: K3 keeps the open-weight label at frontier scale and moves down to #10 because DeepSeek V4.1 Flash, in our own use at MightyBot, does most of the same coding work at a fraction of K3’s $3/$15, and because Grok Build and Pareto slot in above on first-hand results. The strongest signal for K3 this quarter came from other companies: GitHub made it a generally available Copilot model, and Cognition chose it as the base for SWE-2, which Cognition reports within a point of Fable 5.1 on FrontierCode 1.1 Main. For teams whose security posture requires self-hosting, pair K3 with OpenCode or Kimi Code and the entire coding-agent stack runs on your own hardware, which for regulated environments is worth more than the last few benchmark points.

11. GLM-5.3 Flash (Z.ai): Solid Cheap Coding Option

GLM-5.3 Flash is Z.ai’s cheap coding model, released August 26. Z.ai’s own description: “With 320B total parameters and just 18B active parameters, it outperforms GLM-5.2 across benchmarks and real-world workloads at one-tenth the price, while approaching Claude Opus 4.8 on coding and agentic benchmarks.” It enters at #11 and absorbs the GLM line from the notable list below. In our own use at MightyBot it is a solid coding option, and DeepSeek V4.1 Flash is better.

Key capabilities:

• Price: $0.15 per 1M input tokens, $0.03 per 1M cached input tokens and $0.50 per 1M output tokens; the larger GLM-5.3 FlashX is $0.37/$1.25
• Context and output: a 1M context length with 128K maximum output tokens
• Open weights: MIT-licensed on Hugging Face; Artificial Analysis counts it available through 18 API providers
• Harness support: Z.ai says “Before release, we tested GLM-5.3-Flash anonymously as ox-alpha on OpenCode and OpenRouter to gather user feedback. It quickly became the most popular model of the week.” Z.ai also publishes Claude Code and Cursor setup guides through its own endpoints, though the example commands in both still name GLM-4.7, and it ships its own ZCode agent
• Vendor-reported benchmarks: Z.ai’s blog reports 84.3 on Terminal-Bench 2.1 (against 85.0 for Opus 4.8), 63.4 on DeepSWE v1.1 and 48.8 on AutomationBench, with Terminal-Bench 2.1 run “in Claude Code 2.1.207”. Z.ai publishes no Terminal-Bench 4.0 number, and the model is not on the official leaderboard or SWE-bench Verified
• The bigger sibling has an independent score: GLM-5.3 (max), a separate and larger model, scored 41.8% on the official Terminal-Bench 4.0 board in Claude Code on an August 14 submission, the highest non-Anthropic, non-OpenAI result there and ahead of Codex with GPT-5.6 Sol at 37.3%. That score does not transfer to Flash

Why it’s #11: GLM-5.3 Flash is the second cheap coding model worth running, and on the only independent number that covers both, Artificial Analysis’s Intelligence Index, it edges DeepSeek V4.1 Flash, 42 to 40. That index is not coding-specific. In our own use at MightyBot, DeepSeek is the better coding model, which is why this entry sits two places lower. It sits behind Kimi K3 because K3 has the distribution: generally available in Copilot and the base for Cognition’s SWE-2. Where the price matters and you want a second cheap vendor for cross-checking, GLM-5.3 Flash is the one to add; the $0.15/$0.50 rate and MIT weights make it easy to keep on the bench.

12. Gemini CLI and Antigravity (Google): Best Free Option

Gemini CLI is Google’s open-source coding agent for the terminal, and Antigravity is Google’s agent IDE. The CLI’s free tier is still the most generous from any frontier vendor: 60 requests a minute and 1,000 requests a day with a personal Google account, on Gemini 3 models with a 1M-token context window.

Key capabilities:

• Free tier: 60 requests a minute and 1,000 a day with a personal Google account, on Gemini 3 models
• 1 million token context window: monorepo-scale input at no cost
• Built-in tools: Google Search grounding, file operations, shell commands, and web fetching out of the box
• Hardened in the window: the CLI’s changes since July were security and reliability work, most recently v0.60.0 on September 15
• Antigravity, Google’s agent IDE: v2.12.2 on September 3 added Gemini 3.8 Flash for Antigravity Enterprise, and v2.14.0 on September 15 added a terminal and Git version control for Enterprise

Why it’s #12: The free tier is why it ranks, and the reason it sits this low is the benchmark record, plus three new paid-but-cheap entries above it. Gemini 3.8 Flash scores 19.1% on the official Terminal-Bench 4.0 board in the mini-SWE-agent harness, the lowest listed result on this page, while OpenAI’s GPT-6 Astra table puts the same model at 73.8% on DeepSWE v1.1. The two figures come from different benchmarks and different harnesses, and the official-board harness is a minimal one, so treat 19.1% as a floor. The window’s changes to Gemini CLI were hardening rather than new capability; Antigravity is where Google is adding features, and most of those are Enterprise-only so far. For individual developers and open-source maintainers who want frontier-model access at no cost, start here.

13. Replit Agent: Best for Rapid Prototyping

Replit Agent is the AI agent inside Replit’s cloud IDE that plans, writes, tests, and deploys full applications. This quarter’s changes were about cost: Free Mode, powered by OpenAI’s GPT-5.6 Luna, arrived August 18, and Intelligent Model Routing on August 26 promises “the same output quality at 65% lower cost than the previous version of Max Mode”.

Key capabilities:

• Free Mode on GPT-5.6 Luna: launched August 18, so the first build costs nothing
• Intelligent Model Routing: August 26; Replit reports the same output quality at 65% lower cost than the previous Max Mode
• Self-testing and self-healing: tests its own code and fixes failures automatically
• Agent-building agents: can build custom agents and workflows that automate complex tasks
• Pricing: Core at $20 a month, Pro at $100 a month, plus Free Mode

Why it’s #13: Replit Agent is the fastest path from an idea to a deployed URL, and Free Mode lowers the cost of trying it to zero. It ranks last because the same integration that makes it fast makes it hard to apply to an existing repository on your own infrastructure. For greenfield prototypes and internal tools it is often the right answer; for the codebase you already have, it usually is not.

Orchestrate With One Model, Execute With Others

Every agent above asks you to choose a model for the session, and every ranking above assumes you will. The teams getting the most out of these tools have stopped answering that question. They put their strongest reasoning model in the orchestrator seat and then hand the actual work to whichever model is best at that specific job, regardless of who trained it.

Anthropic’s models are excellent at coding, and so are OpenAI’s, and the ranking above reflects that.

The finding that matters more is this: a mixed stack beats any single vendor’s stack. Fable 5.1 orchestrating, GPT-6 Astra and Claude Opus 5 splitting implementation and review across provider lines, cheaper models absorbing the volume, produces stronger engineering output than the best all-Anthropic or all-OpenAI configuration you can build.

This is the most consequential change in how these tools get used in 2026, and it is worth more than any single position on this list.

Teams comparing those orchestration choices can use MightyBot’s AI agent platform comparisons to map vendor capabilities to their workflow.

Cast the orchestrator for judgment

Claude Fable 5.1 is currently the strongest option for the orchestrator seat, because the job is decomposition, delegation, arbitration, and knowing when a worker’s answer is wrong. That is long-horizon reasoning, which is what Fable 5.1 is built for and what it is priced for at $10 per million input tokens and $50 per million output tokens, with a 1M-token context window in Claude Code. You use it for a small number of expensive decisions.

Everything downstream is a casting decision, and the casting should follow the benchmarks in this article rather than a vendor relationship:

• GPT-6 Astra takes the terminal-shaped and computer-use work. OpenAI reports 57.9% on Terminal-Bench 4.0 and 1.9x faster computer-use task completion on Mind2Web. Give it the long command-line chains, the CI and deployment scripting, the build-system archaeology, and anything that has to drive a browser.
• Claude Opus 5 takes the repo-level work and the reviews. It holds 53.9% on the official Terminal-Bench 4.0 board in Claude Code at $5/$25 per 1M tokens, which makes it the affordable frontier reviewer. Give it the multi-file refactors, the “why is this actually broken” work, and the reviews.
• DeepSeek V4.1 Flash, GLM-5.3 Flash, Sonnet 5, GPT-5.6 Luna, Kimi K3, or SWE-2 handle the volume: mechanical edits, test runs, codemods, migrations across hundreds of files. DeepSeek V4.1 Flash is $0.15/$0.60 per 1M tokens off-peak and GLM-5.3 Flash is $0.15/$0.50, and in our own use at MightyBot DeepSeek is the better coder of the two. Sonnet 5 is $2/$10 per 1M tokens, Kimi K3 is $3/$15, and Cognition reports SWE-2 within one point of Fable 5.1 on FrontierCode 1.1 Main at 64% lower cost.

Cross-vendor review is the part that actually pays

The obvious version of this is cost arbitrage. The valuable version is putting the implementer and the reviewer on models from different labs.

A model reviewing its own output shares every blind spot that produced it. It made an assumption while writing, and it makes the same assumption while checking. Two models from the same family share most of that failure surface, since they share training data, post-training, and house style.

Two models from different labs do not. When Opus 5 reviews a diff that Astra wrote, it arrives from a different training run, a different post-training process, and a different house style, which is the entire reason a second opinion is worth having.

That gives you two configurations worth running, and the choice between them is about which model’s strength matters more for the risky half of the job:

• Astra implements, Opus 5 reviews. Correct for terminal-shaped work: migration scripts, deployment changes, anything where the writing is command-line heavy but the risk is what it does to the repository. Astra’s computer-use and terminal strengths do the writing, and Opus 5’s repo-level reasoning catches the blast radius.
• Opus 5 implements, Astra reviews. Correct for repo-wide refactors, where the writing is architectural but the risk lives in the build, the test harness, and the deploy path. Opus 5 makes the change, and Astra audits the surface it is strongest at reading.

Fable 5.1 sits above both and arbitrates. When the reviewer rejects the implementer’s work, you have a disagreement between two frontier models, and something has to decide whether the reviewer found a real defect or is pattern-matching against a house style the implementer does not share. That adjudication is exactly the long-horizon judgment call worth spending orchestrator tokens on, and it is the step most people skip when they wire this up.

Wiring it up

No harness ships this. Claude Code’s subagent model field takes Anthropic models only, Codex does not delegate to Claude, and neither vendor has any reason to build the bridge. OpenAI’s Agents API makes the Codex harness callable from your own code, which is a cleaner way to invoke an Astra worker than shelling out, and the cross-vendor layer is still yours to build. That also means nobody can deprecate it out from under you.

The shape that works:

• The orchestrator runs as a Claude Code session on Fable 5.1, holding the plan, the task list, and the arbitration role.
• Workers are invoked as processes. codex exec runs Astra non-interactively against a prompt and a working directory, or the Agents API does the same over HTTP. A nested claude invocation with --model claude-opus-5 does the same for Opus. Both are ordinary calls from the orchestrator, which means anything with a CLI or an API can be cast in a role, including Kimi K3 through OpenCode or Kimi Code.
• Every worker gets its own git worktree. This is the load-bearing piece. Parallel writers on one checkout will corrupt each other’s work; separate worktrees on separate branches make parallelism safe and make each worker’s output reviewable as a diff.
• Handoffs go through files. The implementer writes a branch and a summary; the reviewer reads the diff cold, with no access to the implementer’s reasoning. Denying the reviewer that context is a feature, since a reviewer who has read the author’s justification is already anchored to it.
• The orchestrator merges. Fable 5.1 reads review verdicts, resolves disagreements, and decides what lands.

Where every worker is a Claude model, Claude Code subagents collapse most of that plumbing into frontmatter: a per-agent model field accepting sonnet, opus, haiku, fable, or a full ID such as claude-opus-5, plus an effort field from low to max that overrides the session default, with each subagent getting its own context window.

Resolution runs CLAUDE_CODE_SUBAGENT_MODEL, then the per-invocation parameter, then frontmatter, then the session model, so an unset model field quietly bills at whatever the session is running.

That is the convenient case, and it is a subset of the pattern rather than the pattern itself. The version that mixes labs is more work to build and is the one that catches more bugs.

Put a decision model in front of every tool call

The newest piece of the stack does not write code at all. Jev, released in early access by TypeSafe AI on September 15, is a “System One” model built “to make fast, structured decisions that software can use directly”. It returns typed answers with probabilities instead of text, and it costs $0.042 per 1M input tokens with output free. TypeSafe’s founder, Diogo Almeida, is a former OpenAI researcher and one of the co-inventors of RLHF.

That makes it the right model for the decisions a coding agent makes hundreds of times a session, where an LLM call is too slow and too expensive:

• Tool-call guardrails. jev-guard is “A security hook for coding agents, powered by Jev”. It scores the risk of every tool call with session context (deny, ask, or allow), scans tool results for prompt injection, and checks skills and plugins. It “Works with Claude Code, Codex, GitHub Copilot CLI, Gemini CLI, Cursor, pi, OpenCode”.
• An open version of auto mode. LangChain’s write-up makes the point directly: “Coding harnesses like claude, codex, cursor have shipped some kind of way to classify dangerous actions before they’re taken”, but “this classifier step has been locked away in the closed source parts of the harness.” With Jev, any team can put the same check in its own agents.
• Model routing. LangChain’s model-routing middleware lets Jev read a request and pick the model to run it, so a simple lookup goes to a cheap model and a hard debugging task goes to an expensive one. That is the orchestrate-and-cast pattern above, done automatically.

Jev is on OpenRouter and TypeSafe’s own API. For teams running the cross-vendor setup above, it is the cheapest way to add a safety check in front of every worker’s tool calls.

Other Notable Coding Agents

• Jev (TypeSafe AI): a decision model rather than a code-writing model, and one of the most useful new pieces for coding agents this month. It risk-scores tool calls, catches prompt injection, and routes requests between models at $0.042 per 1M input tokens with free output. See the Jev section above.
• Amazon Kiro: AWS’s agentic IDE. Kiro Web became generally available on September 1, and a Claude Fable 5.1 preview began rolling out to Kiro Enterprise on September 16.
• Factory Droids: Factory raised $200M at a $5B valuation on September 15 for its Droids agents.
• JetBrains Junie: AI coding agent integrated into IntelliJ, PyCharm, WebStorm, and GoLand, with GitHub integration.
• Augment Code: built for very large codebases, with a Context Engine and a code review agent.
• Amp: agentic coding tool built on Sourcegraph’s code search infrastructure, with a semantic code graph for cross-repo understanding; it shipped a desktop app on September 4.
• Cline: open-source coding agent that now ships a main release line (v4.1.19 on September 17), a CLI, an SDK and a desktop app.
• Qwen Code: the Qwen team’s open-source coding agent; stable v0.24.0 shipped September 16 alongside a Qwen Code Desktop release.
• Aider: open-source terminal AI pair programmer that works directly with git. Model-agnostic, supporting Claude, GPT, Gemini, and Grok.

Key Trends Reshaping Coding AI in 2026

The terminal is the new battleground. Codex CLI, Claude Code, OpenCode, Gemini CLI, Kimi Code, GitHub Copilot CLI, and Aider all compete in the terminal. The IDE is no longer the only surface for AI-assisted development: CLI agents offer deeper system access, scriptability, and integration with CI/CD pipelines.

Multi-agent architectures are mainstream. Codex, Claude Code, Cursor, Copilot, and Devin all support spawning parallel sub-agents for complex tasks. A lead agent decomposes a problem, delegates subtasks, and merges results, enabling work that would overwhelm a single agent context. Cursor’s Projects made the lead agent an explicit product feature this month.

Async background agents are the new normal. GitHub Copilot’s coding agent, Codex automations, Cursor’s cloud agents, Claude Code’s cloud sessions, and Devin all run in the background and deliver pull requests when finished. Developers assign tasks and context-switch to other work while agents execute.

Model churn is now monthly. Grok 4.6 (August 12), GLM-5.3 Flash (August 26), Claude Fable 5.1 (in Claude Code the week of August 31), Gemini 3.8 Flash (in Antigravity September 3), GPT-6 Astra (Codex default September 4), DeepSeek V4.1 Flash (September 10), SWE-2 (September 10) and Pareto (September 17) shipped inside six weeks of each other, on top of Kimi K3 reaching Copilot on August 6. Tool choice increasingly means harness choice: the agents that survive are the ones that let you swap models without rebuilding the workflow.

Model assignment is replacing model selection. “Which model do you use” is becoming a question with several answers per session, and the strongest setups cross vendor lines: a frontier reasoning model orchestrating, Astra and Opus 5 taking the tasks each benchmarks best on, and cheaper models absorbing the volume. Putting the implementer and the reviewer on models from different labs catches defects that same-family review misses. See the orchestration section above.

The harness companies are becoming model companies. Cognition post-trained SWE-2 from Kimi K3 and runs it in Devin. Cursor is owned by SpaceX and leads with xAI’s Grok 4.6. OpenAI put the Codex harness behind the Agents API. The line between the tool and the model underneath it is getting harder to draw, which changes what you are actually buying when you standardize on a vendor.

MCP (Model Context Protocol) is the emerging standard. Nearly every tool now supports MCP for connecting agents to external data sources, APIs, and tools, creating a composable ecosystem where agents can be extended without custom integrations.

Massive consolidation is underway. SpaceX completed its acquisition of Cursor on August 14, 2026. Cognition folded Windsurf into Devin Desktop and removed the Cascade agent on September 8, then raised over $2B at a $48B valuation with run-rate revenue approaching $900M. Factory raised $200M at a $5B valuation on September 15. Sourcegraph spun out Amp as a standalone company. Two of the thirteen entries on this page changed owners or absorbed a former competitor inside one quarter.

How AI Agents Are Changing the Engineering Lifecycle

Bug fixing: Agents like Codex, Claude Code, Devin, and GitHub Copilot process customer-reported issues from Jira, GitHub, and Linear, identifying root causes, planning fixes, and generating pull requests. The gain shows up as shorter time from report to reviewable PR; measure it on your own backlog rather than trusting a vendor number.

Code reviews: Codex, Cursor’s AI Code Review, Augment Code’s review agent, and GitHub Copilot provide automated line-by-line feedback, enforce style consistency, and summarize pull requests, cutting manual review effort.

IDE workflow evolution: Inside IDEs, agents provide real-time suggestions, error detection, and multi-file task automation. Developers ask “Optimize this function” or “Generate unit tests for this module” directly in their editor, with agents executing across the codebase.

Beyond the IDE: On GitHub, agents automate commit messages, PR reviews, and bug fixes. Developers focus on architecture and strategy while agents take a growing share of routine commits and reviews.

Looking Ahead

AI coding agents are converging on full autonomy: handling complex multi-step projects from issue to deployed PR with minimal human intervention.

The differentiation is shifting from raw model capability to platform ecosystem: custom agent libraries, MCP integrations, enterprise controls, and feedback loops that improve with every interaction. Teams evaluating those tradeoffs can use the AI agent ROI calculator to model their options.

Companies like MightyBot are applying this same agentic approach beyond coding: using policy-driven AI agents to automate mission-critical workflows, including a production lending deployment running at 99%+ accuracy.

Related Reading

• AI Automation & Agents Market Maps Gone Wild
• Shipping AI That Works: Built x MightyBot