Claude Code is the pick for most professional developers. The rest of this list answers narrower questions: Cursor if your attention lives in an editor, OpenAI Codex for async delegation, Antigravity on the Gemini stack, GitHub Copilot when GitHub is already on the contract, OpenCode, Aider or Pi when it must be open-source, Goose for work that isn’t coding, and Devin to hand off a ticket and walk away.
Carry one caveat into every row: a harness’s model menu is a contract, not an architecture. OpenAI terminates model supply to Cursor on 12 November 2026; Antigravity switches third-party models off on Enterprise. Buy the runtime — planning loop, permission model, context handling — and assume the model list under it can be renegotiated.
Our picks at a glance
| Pick | Entry price | Heavy-use tier | Best for |
|---|---|---|---|
| Claude Code | $20/mo (Claude Pro) | $100 / $200 (Max 5x / 20x) | Pro developers who live in the terminal |
| Cursor | $20/mo (Pro) | $60 Pro+ / $200 Ultra | IDE-first developers, visual diff loop |
| OpenAI Codex | $20/mo (ChatGPT Plus) | $200 (ChatGPT Pro) | Async delegation; pure OpenAI stack |
| Antigravity | Free with Gemini API | $100/mo (AI Ultra) | Gemini-stack developers, multi-agent orchestration |
| GitHub Copilot | $10/mo (Pro) | $39 Pro+ / $100 Max | Enterprises already on GitHub |
| Windsurf | Free tier | $20/mo (Pro) | Cognition stack users, AI-native IDE |
| OpenCode | Free (AGPLv3) | Model tokens only | Open-source at scale, privacy-sensitive work |
| Aider | Free (open-source) | Model tokens only | Mature self-hosted requirements |
| Pi | Free (open-source) | Model tokens only | A hackable minimalist core to extend |
| Goose | Free (open-source) | Model tokens only | Beyond coding — desktop automation |
| Devin | Free tier; $20/mo Pro | $200 Max; $80 + $40/seat Teams | Set-it-and-forget-it autonomous tasks |
Prices verified 5 October 2026 against claude.com/pricing, github.com/features/copilot/plans and devin.ai/pricing; Cursor’s tiers against its billing documentation on 3 October 2026. Devin’s and Copilot’s rate cards both moved since this page last listed them, in opposite directions.
The five questions no vendor comparison answers
Every harness page compares model support, context window and IDE integration. None of them compare the five things below, and each of these has a price or a blast radius attached. Run them on your shortlist before you run a feature matrix.
| Question | What it costs you to get wrong |
|---|---|
| 1. Will the models I chose it for still be supplied? | A forced migration on someone else’s date |
| 2. Does it preserve the prompt cache when reasoning effort changes? | Up to 12.5x on every cache rebuild |
| 3. How many tokens does its own loop spend? | 5–12x the output you can see |
| 4. Is the permission boundary enforced or merely instructed? | Everything the agent can reach |
| 5. Who owns the runtime’s spending knobs? | Compaction, retries and fan-out set by the vendor selling the tokens |
1. Model supply is a contract term. OpenAI invoked a change-of-control clause against Cursor on 28 August 2026, two weeks after SpaceX closed its $60B acquisition of Anysphere, and proposed a 12 November cutoff — with future models not supplied at all, which turns a one-time migration into a widening gap. Antigravity shows the milder form: third-party models switched off on Enterprise only. The practical move is the one both Slack Code and the payments industry’s grab for the neutral routing layer point at — keep the seam between your harness and its models thin enough to move.
2. Cache preservation on effort changes. This appears on no vendor comparison page and has a published multiplier. OpenAI shipped a configuration_update item alongside GPT-6 Astra on 3 September that changes reasoning effort without invalidating the cached prefix. Astra bills cache reads at $1.00/MTok and cache writes at $12.50/MTok, so a harness that skips it pays 12.5x on every rebuild — 3.7x on the input side of a realistic 40-turn session. OpenClaw merged support on 4 September; an open issue against OpenAI’s own Codex client says Codex still mutates request-level configuration instead. Verify it by reading usage fields, not marketing pages.
3. The orchestration multiplier. Every harness spends tokens on its own loop — delegation, cross-critique, verification, synthesis — and almost nobody measures it. Sakana AI made that quantity visible by selling it: Fugu Max and Fugu Ultra v2 price the orchestration loop at $2/$6 and $5/$30 per million tokens, and independent measurement of v1 put the overhead at 5x to 12x the visible output with a ~1,260-token floor per request. Instrument the ratio of total tokens consumed to tokens you actually use: a managed orchestrator is only cheaper than your own loop if its multiplier is smaller, and that is a measurement, not a rate-card comparison. (Fugu is unavailable in the EU/EEA and does not expose its routing.)
4. Permission enforcement, not instruction-following. GreyNoise’s 9 September writeup of an AI-orchestrated campaign against PaperCut NG/MF — hundreds of agents on OpenAI’s Codex harness driving a DeepSeek model, 440 instances across 395 organisations — contains one detail that has nothing to do with capability and everything to do with buying. The agents ignored a 28-country target exclusion list despite the operator holding root, the prompt and the model choice. Evaluate a harness on what it is permitted to reach and how that permission is enforced, not on how well it follows instructions in the happy path. Full analysis.
5. Who sets the spending policy. Since OpenAI opened the Agents API in public beta on 10 September, the runtime layer can be rented rather than installed — sessions, orchestration, compaction, recovery and subagents behind one API call, with no fee beyond tokens, tools and container time. It displaces nothing below (it is a building block, not an end-user harness) and the beta terms are narrow: US-only data residency, no zero data retention, containers billed by wall-clock at $0.09–$5.76/hour with a non-configurable one-hour idle deletion. But it clarifies the question: compaction, retry and subagent fan-out are spending decisions, and in a managed harness the vendor selling you the tokens makes them.
What an AI harness actually is
An AI harness is the runtime layer that wraps an LLM with tool use, multi-step planning, working memory, and a permission model. Strip away any one of those and the result is a chat interface; combine them and the result is an autonomous worker. What it adds on top of “talk to a model”:
- Tool use — read/write files, run shell commands, browse the web, query databases, call APIs
- Multi-step planning — break a task into sub-tasks, execute them in order, recover from failures
- Working memory — keep context across long sessions; remember what’s been tried and what failed
- Permission management — approve/deny actions before they happen; constrain what the model can touch
- Sometimes a UI — terminal (TUI), IDE integration, desktop app, web
It is distinct from the model (a harness can usually swap models; the model can’t swap harnesses), from a chat interface (ChatGPT, Claude.ai, the Gemini app — no tool use, no execution, no agency), from a passive IDE plugin (Copilot’s original tab-complete suggests, it doesn’t act), and from an “AI agent” in the abstract — agents are the outcome, the harness is what makes one possible.
Why it matters as a category: when Claude Code’s ARR crossed $2.5B and OpenAI launched its $4B Deployment Company, the harness layer became where the revenue lives. The sharpest evidence is OpenAI’s own. Repositioning Codex as a platform in August 2026, it reported that scaffolding changes alone took a model from 13.3% to 38.3% on ARC-AGI-3 while cutting output tokens sixfold — on fixed weights.
Our pick: Claude Code
The terminal-first harness that defined the category. Claude Code is what made “AI harness” a meaningful product noun. It runs in your terminal, reads your repo, plans multi-file changes, edits, runs tests, debugs failures, and iterates until the task is done — all without leaving the shell. Anthropic’s Q2 profitable quarter reporting attributes $2.5B+ ARR to Claude Code alone; the JetBrains April 2026 developer survey shows it as the most-loved AI coding tool at 46% (more than double the next tool).
The default model since 22 September is Claude Opus 5.5 at $4/$20 per million tokens, with cache reads down 60% to $0.20 — the line that dominates a long agent session’s bill — and a reported 66.4% on Terminal-Bench 4.0.
Budget a seat as a pricing instrument, not a capacity guarantee. On 14 September weekly limits fell 17% against summer levels when Anthropic converted May’s temporary 50% boost into a permanent 25% uplift over the pre-May baseline. Pro, Max, Team and seat-based Enterprise are affected; 5-hour session limits are unchanged; overflow is purchasable at API rates. Anthropic has never published an absolute weekly token figure, so every number is a percentage of an undisclosed base — and the capacity framing sits awkwardly against the 80%-plus inference gross margins reported the same week.
- Price: Included with every paid Claude plan — Pro at $20/month ($200/year), Max 5x at $100/month, Max 20x at $200/month
- Best for: Interactive multi-file refactors, long-context reasoning work, terminal-native engineering
- Not ideal for: Developers who can’t stand the terminal (use Cursor instead)
Read the full Claude Code review →
Runner up: Cursor
The IDE-first harness for developers who want a graphical experience. Cursor picks up the work Claude Code prefers not to do: full IDE integration, visual diffs, point-and-click file selection, and Tab autocomplete with no real equal in the category. What takes 6 keystrokes in Claude Code takes 2 clicks here, at the cost of a heavier app.
The multi-model abstraction is the thing to re-examine before buying. Cursor’s 2026 pitch was per-request model switching — Claude Opus 5.5, Gemini 3.8, GPT — with the harness shape held constant. The Claude and Gemini halves still hold; the GPT half expires on 12 November 2026, when OpenAI terminates model supply under a change-of-control clause opened by SpaceX’s acquisition of Anysphere. Bring-your-own-key restores local chat and agent but not Tab, Auto mode, cloud agents, automations or the CLI — and on Teams and Enterprise it does not even escape Cursor’s $0.25/M token rate, which its billing docs apply to BYOK usage too (the full migration guide). Buy Cursor for the editor, which is genuinely best-in-class, not for a hedge that turned out to be a contract term.
Budget note: the public pricing page shows two paid prices; the billing documentation lists six tiers up to $200, with no published credit allowance for any of them. Measure a month before you climb.
- Price: Hobby free; Pro $20/month; Pro+ $60; Ultra $200; Teams Standard $40/user; Teams Premium $120/user
- Best for: Developers who live in their editor, visual diff fans, Claude- and Gemini-based workflows
- Not ideal for: Pure async/headless workflows, terminal purists, anyone whose work depends on GPT models inside Cursor after 12 November
For async delegation: OpenAI Codex
The harness that turned around in early 2026. Overshadowed by Claude Code on capability and Cursor on UI through 2024-2025, Codex was reset by the Feb 2026 macOS app, the move to GPT-5.5-Codex with 40% better token efficiency, and the multi-agent v2 release. It now handles async delegation — give it a task, walk away, return — better than anything else in the category.
It also has the most documented integration surface, after OpenAI documented the app-server as a stable target in August and rented the whole runtime out through the Agents API in September. The open caveat is question 2: as of early September, Codex still mutated request-level configuration when changing reasoning effort, forfeiting the cached prefix.
- Price: Included with ChatGPT Plus ($20/month) for moderate use; ChatGPT Pro ($200/month) for heavy
- Best for: Async delegation, pure-OpenAI stacks, terminal + IDE flexibility, teams that want to build on the harness
- Not ideal for: Real-time interactive pair programming (Claude Code wins)
Read the full OpenAI Codex review →
For Gemini-stack developers: Antigravity
Google’s standalone agentic platform — the harness that replaced Gemini CLI. Antigravity 2.0 launched at Google I/O 2026 on May 19 as a four-surface product (desktop app + CLI + SDK + Managed Agents API). Its model selector now offers Gemini 3.8, 3.7 and 3.6 Flash plus Gemini 3.1 Pro — the 3.5 Flash it launched on has been superseded three times over. The desktop app’s multi-agent orchestration UI is the strongest in the category: run a refactor agent, a test-writing agent and a debug agent in parallel in one interface. And the transition is not optional for anyone already in the Gemini stack, because Gemini CLI and Gemini Code Assist IDE extensions both sunset June 18, 2026.
It is also the harness a hyperscaler chose to run a rival’s weights in. On 15 September Google opened Claude Opus 5 to all of its engineers inside Antigravity, on a per-person quota, and pointedly not through Claude Code — separating the two decisions this page is organised around, because the harness is where audit logs, sandbox policy, quotas and code-retention posture live. Read it as a real endorsement of Antigravity’s control surface, then check question 1: per Antigravity’s own model table, Claude Sonnet 4.6, Claude Opus 4.6 and GPT-OSS-120b are available on Free/Plus, Pro and Ultra and unavailable on Enterprise, while every Gemini model is available on all four.
- Price: Free with Gemini API; AI Ultra at $100/month for 5× higher Antigravity limits
- Best for: Gemini-stack shops, multi-agent orchestration, enterprises already on Google Workspace
- Not ideal for: Multi-model shops on Enterprise contracts (third-party models are off), privacy-first work, open-source requirements
Read the full Antigravity review →
For enterprise procurement: GitHub Copilot
The harness that wins by default when GitHub is already on the contract. GitHub Copilot’s value in 2026 isn’t capability lead — Claude Code, Cursor and Codex are all measurably better at hard engineering tasks. The value is frictionless enterprise procurement: if your company already pays GitHub Enterprise, Copilot Agent and Workspace are an upsell, not a vendor evaluation cycle. Workspace is a credible harness in its own right (multi-file planning, task decomposition, PR creation), and Coding Agent ships work without manual review steps. Neither is best-in-class, but both are good enough that procurement convenience wins on the enterprise scoreboard.
Copilot has been metered since June 2026: base prices stayed flat, but each plan now buys an allowance of AI Credits that Chat, Agent and Workspace draw against. Code completions remain free and unmetered, so light users were never exposed — the volatility sits with heavy agent-mode use, where 10–50× bill spikes were reported. Microsoft’s in-house MoE model Project Polaris replaced GPT-4 Turbo as the default engine from August 2026, so the proposition is procurement convenience plus a Microsoft-trained model plus Windows-native agents, minus cost predictability.
Two things moved the credit arithmetic, in opposite directions. On 1 September the promotional allowance for existing organisations expired: included usage fell from 3,000 to 1,900 credits per Business seat and from 7,000 to 3,900 per Enterprise seat — 37% and 44% less, at unchanged seat prices. Individual plans went the other way, picking up a Flex allotment on top of base credits that breaks the original one-dollar-one-credit design in the buyer’s favour: Pro is 1,000 + 500 = 1,500 credits at $10, Pro+ is 3,900 + 3,100 = 7,000 at $39, and a new Max tier is 10,000 + 10,000 = 20,000 at $100. That creates an arbitrage worth checking: a Pro+ seat and an Enterprise seat both cost $39, and Pro+ carries 80% more credits. Without an SSO or audit requirement, price the individual tiers first.
- Price: Free tier; Pro $10/mo (1,500 credits); Pro+ $39/mo (7,000); Max $100/mo (20,000); Business $19/seat (1,900); Enterprise $39/seat (3,900). Overage billed at published API rates per model.
- Best for: Teams already on GitHub Enterprise, light-to-moderate users, low-friction rollouts, regulated environments
- Not ideal for: Cost-predictability requirements; power users on organisation seats (Claude Code Max or Cursor Teams Standard at $40/user is structurally cheaper)
Read the full GitHub Copilot review →
For AI-native IDE believers: Windsurf
The harness that didn’t pretend it was a plugin — and is now owned by the Devin team. Windsurf (originally Codeium) was acquired by Cognition in December 2025 for ~$250M and now runs on Cognition’s proprietary SWE-1.5 model, with unlimited usage included on Windsurf Pro. Discount the launch claim of 13× faster than Claude Sonnet 4.5: Sonnet 4.5 is deprecated and retires on 30 November 2026, and two Sonnet generations have shipped since. The real feature is the native Devin cloud handoff — plan a multi-file change locally, hand it to a Devin cloud session for long-running execution, review the PR when it’s done.
It lags Cursor on the editor loop and Claude Code on raw reasoning, which is why it sits here rather than higher. If you want a Cognition-stack workflow (Devin + Windsurf together), this is the pick.
- Price: Free tier; Pro $20/month
- Best for: Cognition-stack users (Windsurf + Devin), AI-native IDE preference over VS Code forks, plan-locally / execute-in-cloud workflows
- Not ideal for: Multi-model abstractions (Cursor is cleaner), terminal-first work
Read the full Windsurf review →
For open-source at scale: OpenCode
The open-source terminal harness that proved the model. Released June 2025 by the SST team (now Anomaly Innovations), OpenCode reached 150,000+ GitHub stars and 6.5M monthly active developers by mid-2026 — one of the fastest-growing open-source dev tools in recent memory. Go-based CLI, TUI-first interface, client-server architecture so the same agent core runs in the terminal today and a desktop app / CI runner tomorrow. 75+ LLM providers out of the box (Claude, GPT, Gemini, Grok, Llama, Mistral, local Ollama). Privacy-first — no code or context is stored on remote servers.
OpenCode is the right pick for any reader who needs an open-source harness that doesn’t compromise on capability. It’s measurably more polished than Aider and more flexible than commercial harnesses on model choice — and it is the clean answer to question 1, because 75 providers configured by you cannot be renegotiated by one of them.
- Price: Free, open-source (AGPLv3). You pay only for model API tokens.
- Best for: Open-source / self-hosted requirements, privacy-sensitive work, cost optimization (pair with DeepSeek V4 or Gemini for cheap API spend)
- Not ideal for: Zero-setup needs, AGPL-incompatible commercial distribution, multi-agent orchestration
Read the full OpenCode review →
For mature open-source / self-hosted: Aider
The terminal harness with no allegiance to one vendor. Aider is the pick when you need (or strongly prefer) open-source. It’s been the mature open-source harness for two years; it works with Claude, GPT, Gemini, DeepSeek, local Ollama models, anything OpenAI-API-compatible. The capability ceiling is bounded by the model you point it at, but the harness itself doesn’t lock you in.
- Price: Free, open-source. You pay only for the model API tokens
- Best for: Self-hosted requirements, model-agnostic stacks, cost-optimization (cheap models work)
- Not ideal for: Anyone who wants a polished UI or doesn’t want to think about model choice
For hackable minimalists: Pi
The harness that picks “small” on purpose. Pi (also called the Pi Coding Agent) is the minimalist open-source harness from Mario Zechner — long-time open-source author and creator of the libgdx game framework. Pi ships with a four-tool core (Read, Write, Edit, Bash), provider-agnostic model support, and a deliberately small surface area. Everything beyond the core is an extension, packaged as npm modules and shared via npm or git.
The distinguishing feature is the tree-structured interaction model: every message is a node in a navigable tree, so you can rewind to any prior point and branch from there. For exploratory work — comparing refactoring approaches, debugging competing hypotheses, A/B-ing prompts — it beats the linear-conversation model every other harness uses, and no other major harness in 2026 has it.
- Price: Free, open-source. You pay only for model API tokens.
- Best for: Developers who want a hackable core to extend, exploratory / research work, long-time open-source / framework authors
- Not ideal for: Zero-setup needs, teams needing rich enterprise integration, IDE-only developers
For beyond coding: Goose
The general-purpose desktop harness. Goose is Block’s open-source AI harness and the only one here that isn’t primarily about software development. It runs on your desktop, talks to your applications via MCP servers, and handles work like “summarize my Slack threads from this week and draft replies to the urgent ones.”
For coding Goose is fine but not best-in-class. For everything else — desktop automation, document workflows, multi-app orchestration — it’s the harness designed for it, and the MCP ecosystem’s maturation (accelerated by Anthropic’s Stainless acquisition) gives it more capable connectors every month. It is also where question 4 deserves the most attention, because desktop MCP connectors reach mail, files and calendars rather than a repo checkout.
- Price: Free, open-source. Bring your own API key
- Best for: Non-coding workflows, desktop automation, MCP-server enthusiasts
- Not ideal for: Pure coding work (use Claude Code or Cursor)
For autonomous tasks: Devin
The “give it the task and walk away” harness. Devin from Cognition is the most autonomous harness on this list — it runs in its own cloud sandbox, manages its own VM, browses its own web, opens its own PRs. You hand off a Linear ticket; Devin returns with a PR. ARR went from $73M (June 2025) to $492M (May 2026), and Cognition closed $1B+ at a $26B post-money valuation on 27 May 2026. Enterprise customers include Goldman Sachs, Citi, Mercedes-Benz, the U.S. Army and the U.S. Navy.
Devin’s billing unit changed, which matters more than its headline price. This page previously quoted a $500 team plan and a $200 consumer tier; the current self-serve ladder is a free tier with a light quota, Pro at $20/month, Max at $200/month, and Teams at $80/month plus $40 per developer seat (up to 200 users). The substantive change is underneath: Cognition retired the Core/Team plans that metered buyers in ACUs at $2.00–$2.25 each, and self-serve plans now carry an included quota that refreshes daily and weekly, with on-demand usage at API rates and cost per message varying by model, task size and reasoning depth. ACUs survive on Enterprise order forms only. If you rejected Devin because the invoice was unpredictable, that specific objection no longer applies to the self-serve tiers — and a free tier means the evaluation now costs nothing.
The trade-off is control, not cost. Devin is great when the task is well-scoped and you trust the model to make good decisions without check-ins. It’s frustrating when the task needs midstream course correction — other harnesses are more interactive. The structural read: Cognition owns both Devin and Windsurf and runs both on its in-house SWE-1.5 model, the only vertically-integrated harness business in the category — model + autonomous agent + IDE in one company.
- Price: Free tier; Pro $20/month; Max $200/month; Teams $80/month + $40/seat (up to 200 users); Enterprise custom, still billed in ACUs
- Best for: Well-scoped tickets, async pipelines, teams with structured engineering work
- Not ideal for: Exploratory work, interactive debugging, tasks needing midstream correction
How to pick — the rule
If you can answer one of these questions with a clear yes, the picks narrow fast:
- “Do I live in the terminal?” → Claude Code first, OpenCode second, Aider for the more conservative open-source pick
- “Do I live in the editor?” → Cursor first, Windsurf second
- “Am I already on the Gemini stack?” → Antigravity — the June 18 deprecation of Gemini CLI makes this the migration path, not a choice
- “Is my company already on GitHub Enterprise?” → GitHub Copilot wins on procurement, even if not on capability
- “Do I want async delegation?” → OpenAI Codex or Devin, whose free tier now makes trying it cost nothing
- “Do I need open-source / model-agnostic?” → OpenCode for the polished modern pick, Pi for the hackable minimalist, Aider for the mature conservative pick, Goose for anything non-coding — which is also the only real answer for general workflow rather than code
- “Do I depend on a specific vendor’s models?” → question 1 outranks every feature comparison. Check the supply contract, not the model dropdown
If you can’t answer any of these, the safe default in October 2026 is Claude Code: the most compounded product polish, the strongest capability lead, and the lowest risk that the model you bought it for disappears. Budget for the subscription as a pricing instrument rather than a fixed capacity — weekly limits moved twice in 2026, most recently down 17% in September.
The verdict
The harness layer is where 2026’s interesting AI competition is happening. The difference between Claude Opus 5.5, GPT-6 Astra and Gemini 3.8 on hard engineering tasks is closer than the discourse suggests; the compounding advantage sits in how well the harness plans, how cleanly it handles tools, how trustworthy its permission model is, and how fast it iterates after failure. OpenAI’s own 13.3%-to-38.3% scaffolding figure is the number to quote at anyone who still thinks this is a model decision.
For most professional developers in 2026: Claude Code as the primary harness, Cursor for editor work, OpenCode as the open-source fallback. That stack handles roughly 95% of what an individual contributor needs to ship. The other eight — Antigravity, OpenAI Codex, GitHub Copilot, Windsurf, Aider, Pi, Goose, Devin — are right answers to specific questions, each worth knowing exists for the day that question lands on your desk.
The layer above the harness. One caveat on that framing: the compounding advantage may not stay at the harness. Warp’s Factories, in early access since 18 August 2026, bets that pipelines running several harnesses — a different one per stage — are the durable position, precisely because the harnesses are converging. If that lands, picking a primary harness matters less than keeping the choice reversible. Per-run rates are unpublished, so it changes nothing on this list today.
For broader context, see the Claude Code review, the Cursor review, and the best AI coding tools roundup for the in-editor-only view of this market.
What changed
- 5 Oct 2026: Devin dropped ACU metering on self-serve for daily/weekly quotas (free tier, $20 Pro, $200 Max, $80 + $40/seat Teams); Copilot individual plans gained a Flex allotment and a $100 Max tier; page restructured answer-first around the five buying questions.
- 22 Sep 2026: Claude Code’s default model is now Opus 5.5 at $4/$20, with cache reads down 60% — see analysis.
- 15 Sep 2026: Google gave its engineers Claude Opus 5 inside Antigravity and pointedly not Claude Code — see analysis.
- 14 Sep 2026: Claude Code weekly limits fell 17% against summer levels — see analysis.
- 12 Sep 2026: Agents on the Codex harness ignored their own operator’s 28-country exclusion list in the PaperCut campaign — see analysis.
- 11 Sep 2026: The runtime layer became rentable and priced — OpenAI’s Agents API and Sakana’s orchestration-token rate card.
- 7 Sep 2026: Cache preservation across reasoning-effort changes became a harness selection criterion worth up to 12.5x — see analysis.
- 30 Aug 2026: OpenAI moved to terminate Cursor’s model supply on 12 November, making model neutrality a contract term rather than an architecture — see analysis.
Frequently asked questions
What is an AI harness?
The runtime layer that wraps an LLM with tools, planning, memory and permissions — the difference between a model that talks and an agent that works. Claude Code, Cursor, Codex, Aider and Goose are harnesses; the harness, not the model, increasingly determines real-world capability.
What's the best AI harness in 2026?
Claude Code — the category definer, with the deepest interactive agent workflow and 46% 'most-loved' in JetBrains' April 2026 survey. Cursor leads IDE-first; Codex leads async delegation; Antigravity is the Gemini-stack pick; Goose is the only real answer for work that isn't coding.
Terminal-first, IDE-first, or autonomous — how do I choose?
Match the harness to where your attention lives. Terminal-first (Claude Code, OpenCode, Aider) for developers who steer interactively; IDE-first (Cursor, Windsurf, Copilot) for in-editor flow; autonomous/cloud (Codex, Devin) for delegate-and-review workflows.
Do harnesses lock me into one model?
Treat a model menu as a contract rather than an architecture, because that is what it is. OpenAI invoked a change-of-control clause against Cursor after SpaceX acquired Anysphere and is terminating model supply on 12 November 2026 — the clearest demonstration available that multi-model support is a commercial arrangement with a counterparty. Antigravity publishes a model table that offers Claude Sonnet 4.6, Claude Opus 4.6 and GPT-OSS-120b on Free/Plus, Pro and Ultra and marks all three unavailable on Enterprise, so the answer there depends on the tier you deploy on. Genuinely model-agnostic means open-source and self-pointed: OpenCode (75+ providers), Aider, Pi and Goose.
What does an AI harness cost in 2026?
The spread is wider than it was. Open-source harnesses (OpenCode, Aider, Pi, Goose) are free and you pay only model tokens. Subscriptions cluster at $20/month — Claude Pro, Cursor Pro, ChatGPT Plus for Codex, Devin Pro, Windsurf Pro — with heavy-use tiers at $100–$200 (Claude Max, Cursor Ultra, Copilot Max, Devin Max). GitHub Copilot is cheapest to start at $10. The number that actually decides your bill is usually not the seat price but token consumption: metered credits on Copilot, and your own API spend on anything open-source.
Does the harness or the model matter more?
OpenAI's own published figure is the best evidence for the harness. Repositioning Codex as a platform in August 2026, it reported that scaffolding changes alone moved a model from 13.3% to 38.3% on ARC-AGI-3 while cutting output tokens sixfold — on fixed weights. Google supplied the corroborating decision a month later by giving its engineers a rival's model (Claude Opus 5) inside its own harness (Antigravity) rather than adopting Claude Code.