Best AI Coding Agent Harness (2026): 9 Tools + Model Pairing

TL;DR: Nine harnesses, one finding that reframes the whole category. On OpenRouter’s 30-day app data, the single most-used model inside Claude Code is GLM 5.2, at 3.14T tokens against 1.98T for Anthropic’s own four models combined. Codex is the opposite: roughly 86% of its top-ten traffic stays inside OpenAI’s family. Cline and Pi both lead with DeepSeek V4 Flash. So the honest version of “which harness is best” is two questions, not one. Pick the harness for its control loop, then pick the model separately, because on every tool that lets you choose, developers already do.

TL;DR: Which Harness Should You Pick?

Two of these nine cannot be pointed at an outside model at all in their main agent surface. Three more can, with caveats that matter. The other four treat the model as a config line. That single split predicts more about your bill and your lock-in than any benchmark in this article.

What Is an AI Coding Agent Harness?

A harness is the program wrapped around a model that turns token generation into work on your repository. The model is the engine. The harness is the transmission, the chassis, and the brakes.

Concretely, the harness owns five jobs the model cannot do for itself. It assembles context, deciding which files and prior turns get sent. It defines and executes tools, so a read_file call actually reads a file. It gates permissions, so a rm -rf either runs, prompts, or is refused. It manages recovery, deciding what happens when a patch fails to apply or a test goes red. And it holds session state, so an interrupted run can resume instead of starting cold.

This is why two developers running the same model report wildly different experiences. Swap GPT-5.6 Sol from Codex into Cline and the model is identical while the file-reading strategy, the tool schema, the retry policy, and the approval flow all change. The category name people search for varies (agent harness, coding agent, AI coding tool) but they are describing the same layer.

How Do These Harnesses Actually Differ?

Four axes separate them, and only the fourth is hard to see before you commit.

Where it runs. Terminal-first (Codex, Claude Code, OpenCode, Reasonix, Pi), inside an editor (Cline, Cursor, Copilot), or as a standalone agent manager with its own window (Antigravity 2.0). This decides whether you can pipe it, cron it, or run it over SSH.

Whether the model is yours to choose. The cleanest binary in the category. Either the tool reads a base URL from config, or the model menu is the vendor’s and that is the end of it.

What extends it. Hooks and subagents and skills and MCP servers, versus a deliberately bare loop you build on. Claude Code and Pi sit at opposite ends of this on purpose.

How the control loop behaves under stress. The one that decides whether you keep using the thing. Does it read the right files before editing, keep the diff scoped, run your checks, recover from a failed test without thrashing, and resume after an interruption? A long r/AI_Agents thread on harness selection from July 2026 converged on exactly this, and the top comment put it better than we could:

People often over-index on the model and under-index on the execution loop.

That is the framing this article follows. Model quality is table stakes now. Loop behaviour is the differentiator, and it is also the thing no benchmark reports.

How we tested the loop

Since loop behaviour is the claim, we ran one. We built a small Python repo containing a real bug: a retry helper catches urllib.error.HTTPError, while the OpenAI SDK raises openai.RateLimitError, so the 429 branch never fires and the test fails. Six of the nine tools here (Codex CLI, Claude Code, Cline, OpenCode, Reasonix, and Pi) were pointed at the same gateway and given the identical prompt in the identical repo: run the test, name the one-line root cause, show the fix as a unified diff, edit nothing.

All six named the root cause correctly, which is the least interesting finding and the one to state first. The differences showed up underneath. Codex CLI, OpenCode, and Cline ran the test before answering; Claude Code, Reasonix, and Pi answered from reading the code. On the dead import urllib.error the fix leaves behind, Codex called it out in prose and Claude Code quietly dropped it in the diff; the other four left it in place. And four of the six shipped a patch that still contains the if e.code != 429 guard. Three wrote it out explicitly and one left it untouched by changing only the except line. That guard can never pass once you are catching openai.RateLimitError: its .code is the API’s string error code, never the HTTP status (that lives in .status_code), so e.code != 429 is always true and the retry path is unreachable.

That last one is a model artefact more than a harness one, which is exactly the point: the harness decides whether the loop verifies its own patch, and none of these six did.

The three we could not run this way are Copilot and Cursor, which need paid seats to reach agent mode with a custom provider, and Antigravity, which requires a Google sign-in before it will talk to anything. Their sections below are sourced from vendor documentation and first-party CLI output rather than from an equivalent run, and say so.

Which Model Do Developers Actually Run in Each Harness?

Most roundups tell you which tool to buy and stop. The more useful question, and the one people actually search, is which model to put in the tool once you have it. OpenRouter publishes per-app model usage for apps that opt into tracking, which turns that question into data instead of opinion.

Here is the 30-day picture as of 2026-08-11, from each tool’s public OpenRouter app page.

Read down the last column and you get a personality test for each tool.

Claude Code is the most concentrated, and it is concentrated on someone else’s model. GLM 5.2 alone is 49% of its top-ten traffic. Add up Opus 4.8, Sonnet 5, Opus 5, and Fable 5 and Anthropic’s own lineup reaches 1.98T, which GLM 5.2 beats by roughly 1.6x on its own. Kimi K3 and both DeepSeek V4 Flash builds also make the top ten. The harness people rate most highly for its loop is, for this population, mostly a chassis for non-Anthropic engines.

Codex is a monoculture. Seven of its top ten are OpenAI models and together they take about 86% of the top-ten volume. The three outsiders (DeepSeek V4 Flash, Nemotron 3 Ultra, GLM 5.2) split the remaining 14%. This is what the Responses-only constraint looks like in aggregate: it is not a wall, but it is a filter, and most people do not bother climbing it.

Cline is priced-in from the start. DeepSeek V4 Flash leads at 1.26T, Step 3.7 Flash follows at 812B, and the first Anthropic model appears at position ten with 87.7B, about 2.6% of the top ten. Cline users are optimising for cost per task, not for the model on the leaderboard.

Pi has the flattest distribution of the four measured here. Its top model takes 20%, and its top ten spans DeepSeek, Zhipu, Moonshot, Anthropic, OpenAI, xAI, and Nvidia. For a tool whose pitch is “primitives, not features,” the usage pattern matches the pitch.

What this data does not cover, and you should not let anyone tell you otherwise. OpenRouter only sees traffic that went through OpenRouter from apps that opted into tracking. Everyone running Claude Code on an Anthropic subscription, Codex on a ChatGPT plan, Copilot on GitHub’s own inference, or Cursor on Cursor’s models is invisible here. So this is not market share. It is something narrower and, for anyone reading a harness comparison, more useful: it is what developers choose when the choice is actually theirs. Note also who is missing entirely. Antigravity, GitHub Copilot, OpenCode, and Reasonix have no entry in this dataset, for two different reasons that the sections below make clear.

The short version, by model

If you arrived here searching for the best harness for a specific model rather than the other way round:

Codex CLI: OpenAI’s Agent, and the Protocol That Defines It

Where it runs

Terminal only, as a Rust binary from npm i -g @openai/codex, with a separate desktop app on the side. Configuration lives in ~/.codex/config.toml and project instructions in AGENTS.md. It reached #15 in OpenRouter’s global app ranking and #8 among coding agents over the last 30 days, which is smaller than its mindshare suggests because most Codex users never leave the ChatGPT plan.

What it costs

Bundled with ChatGPT subscriptions, or pay-as-you-go against an API key. The bundling is the reason its OpenRouter footprint understates it.

What extends it

AGENTS.md, MCP servers, and an import command that pulls Claude Code and Cursor configuration across. The sandbox is the strongest in this roundup: OS-level isolation using seatbelt on macOS and Landlock plus seccomp on Linux, with approval modes layered on top. If you auto-approve shell commands, that gap is worth real money.

What it locks you into

The protocol, not the vendor. Codex speaks only the OpenAI Responses API; wire_api = chat was removed and current builds refuse to start with it. A gateway therefore has to expose /v1/responses, not just /v1/chat/completions, and support is per model rather than per gateway. Two details trip people up repeatedly: the model ID prefix only applies under a custom model_providers entry, and a gateway advertising a model does not mean that model is reachable over Responses. Setup details are in the ofox Codex integration guide and the model provider page.

“Per model rather than per gateway” is easy to nod along to and hard to picture, so here is what it looked like when we hit it. Codex 0.147.0 with a correct provider block returned Invalid 'input[0].tools[0].description': empty string on every request. We put a logging reverse proxy in front of the gateway and read the body Codex actually sends: it declares its tool namespaces in a developer message, and the functions namespace ships with description: "". Replay that same body against five models and three reject it, one has no Responses provider at all, and one completes. Fill in that single empty string and the previously failing model returns 200. The request was never the gateway’s fault or ours. The client emits a field that some upstreams validate as minLength: 1 and others ignore.

The practical lesson is the one worth carrying into any harness: when a client and a gateway disagree, capture the wire format before you start changing config. We spent one proxy and five minutes on this; guessing at wire_api values would have cost an afternoon and produced the wrong conclusion.

Claude Code: Deepest Extension Surface, Mostly Running Other People’s Models

Where it runs

Terminal, installed via npm, with a plugin ecosystem and an IDE bridge. It is #2 in OpenRouter’s global app ranking with 7.97T tokens and 302 distinct models seen.

What it costs

A Claude subscription, or API billing, or a third-party gateway. The three paths differ enough that “what does Claude Code cost” has no single answer.

What extends it

More than anything else here. Hooks fire on tool events, subagents run scoped tasks in their own context, skills package reusable procedures, MCP servers add tools, and CLAUDE.md carries project instructions. If you want the harness to encode your team’s process rather than your own habits, this is the one that supports it.

What it locks you into

Less than the name implies. ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN redirect it at any endpoint speaking the Anthropic Messages API, which is why GLM 5.2, Kimi K3, and DeepSeek all appear in its usage data. Two environment variables is the whole procedure:

Note what the model does and does not carry over. GLM 5.2 named the exception-type mismatch correctly, but its patch keeps the if e.code != 429 guard, which can never pass: on openai.RateLimitError, .code is a string error code, not the HTTP status. Same harness, same prompt, different model, subtly worse diff. The real lock-in is behavioural: the system prompt, the tool schema, and the context strategy are tuned for Claude models, so a swapped-in model inherits assumptions built for something else. See the ofox Claude Code integration guide and its model provider page for the exact variables. If you are moving the other way, we have a step-by-step migration from Claude Code to Codex.

Google Antigravity: One Brand, Four Surfaces

Where it runs

All over, which is the confusing part. Antigravity now ships as four separate things: Antigravity 2.0, a desktop command centre for running several local agents in parallel; Antigravity CLI, a terminal surface; Antigravity IDE, the full editor; and an SDK for scripting your own agents. It launched in November 2025 as an agent-first IDE and has since expanded outward from that.

Some coverage has reported that Gemini CLI is being shut down and replaced by Antigravity CLI. We went looking for the primary source and could not find one. As of 2026-08-11 that claim is unsupported. The google-gemini/gemini-cli repository is not archived, carries no deprecation notice, and still publishes on its preview, stable, and nightly channels. Neither antigravity.google nor the Google Developers Blog states it. Treat the two as coexisting until Google says otherwise.

What it costs

Free for individual developers at the time of writing, with a paid organisational tier and higher usage ceilings on Google’s upper AI subscription plans. You are buying an allowance, not tokens.

What extends it

The 2.0 manager runs multiple agents concurrently and lets the main agent spin off temporary subagents so parallel work does not pollute the primary context. A built-in browser gives it a way to verify UI changes visually rather than by assertion.

What it locks you into

The model menu. Antigravity exposes Google’s own models plus a curated set of third-party options, and there is no base URL to redirect. It has no entry in OpenRouter’s app data because there is nothing to route. If you have already standardised on a gateway, Antigravity is the tool in this roundup that will not join.

You can confirm that from the flag surface alone. We installed the CLI (brew install --cask antigravity-cli, version 1.1.12) and its whole option list has no --base-url, no --provider, and no --api-key. Asking it to list models does not get you a list; it gets you a sign-in wall.

That sign-in wall is also why Antigravity is the one tool here with no key-only path at all. Copilot and Cursor stayed out of the failing-test run because agent mode with a custom provider is behind a paid seat, but a seat buys you in. Antigravity requires a Google account before it will talk to anything, and no amount of paying changes that.

GitHub Copilot: The Default Everyone Has, Billed by Credits

Where it runs

Everywhere GitHub reaches: VS Code and other IDEs, the Copilot CLI in the terminal, a cloud coding agent that opens pull requests, and code review inside GitHub itself. Breadth is the product.

What it costs

This changed and a lot of writing about it is stale. Billing now runs on GitHub AI Credits, where 1 credit equals $0.01. Free is $0, Pro is $10/month including $15 of credits, Pro+ is $39 including $70, and Max is $100 including $200, with Business and Enterprise seats priced separately. Inline completions and next-edit suggestions do not consume credits at all; chat, agent mode, code review, and the Copilot CLI do. Recent changelog entries add per-cycle credit visibility and session limits you can set inside the CLI and SDK. Because pricing pages move, check the current plans page before you budget against these numbers.

What extends it

MCP servers, custom instructions, and repository-level configuration, plus auto model selection in the CLI that routes by task type.

What it locks you into

The model menu, with one asterisk. Copilot’s own surfaces run Copilot’s models. An outside endpoint is reachable only through a third-party VS Code extension, only in Copilot Chat, and only on an Individual subscription; Business and Enterprise seats cannot use it, and Tab completion keeps running GitHub’s model regardless. The ofox Copilot integration guide documents that path including the exact provider fields, and is honest about where it stops.

Cursor: A Very Good Editor With a Closed Engine Bay

Where it runs

As a standalone editor. It is the most widely adopted paid tool in this roundup and, in OpenRouter’s coding-agent ranking, it sits at #11 with 471B tokens over 30 days, roughly one seventeenth of Claude Code’s volume on the same platform. That gap is the point rather than a knock: Cursor’s inference is its own, so almost nothing needs to leave.

What it costs

A per-seat subscription with usage tiers on top.

What extends it

Rules files, MCP servers, and a strong multi-file editing loop. Its Tab model is the one feature people most often say they cannot replace, and it is a genuine reason to keep the editor even if the agent work happens elsewhere.

What it locks you into

More than any other tool here, and our own documentation says so plainly. The ofox Cursor page is titled a compatibility notice rather than a setup guide: Tab completion is hardcoded to Cursor’s models and cannot be replaced, Agent mode is unavailable with a custom provider, free-tier accounts cannot use custom models at all, and even the Chat path that does work gets overridden by Auto mode. The recommendation it lands on is the one experienced users reach independently, which is to keep Cursor as the editor and run Claude Code or Codex CLI in its built-in terminal. That is not a workaround so much as an accurate description of how the two layers should divide.

Cline: The Budget-Optimised Loop

Where it runs

As an extension inside VS Code and JetBrains. It is #4 in OpenRouter’s global ranking and #2 among IDE extensions, active since October 2024, which makes it the oldest entry in OpenRouter’s app data among the tools here.

What it costs

Nothing for the extension. You bring a key, and the usage data suggests users pick that key with cost firmly in mind.

What extends it

A plan-then-act split, a task board for managing parallel work, MCP servers, and browser automation for verifying front-end changes. The planning surface is genuinely stronger than most terminal agents offer.

The provider surface is the widest here by a distance: 185 providers on the list, with “OpenAI Compatible” as a first-class entry rather than an escape hatch buried in advanced settings.

What it locks you into

Very little. Any OpenAI-compatible or Anthropic-compatible endpoint works, which is how DeepSeek V4 Flash came to be 37% of its top-ten traffic. Pointing it at a gateway is one cline auth command, and the loop then behaves the same as it does on a first-party key:

The failure mode reported most often by users is loop reliability rather than lock-in: in the r/AI_Agents thread, one user described jobs stalling on malformed tool calls and moved to a fork that handled them more gracefully. That is a single report and worth weighing as one, but it points at the axis that matters, which is the loop rather than the model. We hit one adjacent rough edge ourselves: pointing the CLI at a reasoning-capable Claude model over the OpenAI-compatible path failed with an internal text part ... _reasoning_0 not found error, while non-reasoning models on the same endpoint ran clean. Setup is in the ofox Cline integration guide.

OpenCode: Model-Agnostic by Construction

Where it runs

Terminal-first with a desktop app and editor surfaces, installed as opencode-ai from npm, MIT licensed, with AGENTS.md for project instructions. It does not appear in OpenRouter’s app rankings, which reflects tracking opt-in rather than absence of users.

What it costs

Free and open source. You pay only for tokens.

What extends it

AGENTS.md, MCP servers, and a provider layer that reaches every provider listed on models.dev, 183 of them when we checked on 2026-08-11, with mid-session switching. ofox ships as a built-in provider, so the setup is an environment variable rather than a JSON block.

What it locks you into

Nothing structural, which is the whole design. On the same failing-test task, it was the one that showed its work most completely, running the suite, printing the traceback, then reading the source before answering:

The tradeoff is that a harness with no default vendor also has no vendor tuning its prompts for you, so getting the best out of it takes more configuration than Claude Code or Codex asks for. The ofox OpenCode integration guide covers the provider setup, and we compared the two terminal agents head to head in OpenCode vs Codex CLI.

Reasonix: Community-Built, DeepSeek-Tuned, Cache-First

Where it runs

Four places off one local engine: a CLI and TUI, a desktop app, a browser surface, and a VS Code extension that talks to the same backend over ACP. It ships as a single static Go binary with CGO_ENABLED=0, installed by npm i -g reasonix on any OS or brew install esengine/reasonix/reasonix on macOS. Version 1.23.0 shipped on 2026-08-10, so it is actively maintained.

The name needs a correction before anything else. Reasonix is not a DeepSeek product. It is a community project at github.com/esengine/DeepSeek-Reasonix, MIT licensed, with its own site at reasonix.io. DeepSeek’s official documentation lists Claude Code, GitHub Copilot, and OpenCode as documented agent integrations and does not mention Reasonix. The third-party site carrying most of its coverage states on the page that it is independent and unaffiliated. The tool is real and interesting; the DeepSeek branding on it is not official.

What it costs

Free and open source, plus whatever your model costs. The design goal is that the second number stays small.

What extends it

MCP servers contribute tools and prompts, and Extension Protocol v1 sidecars go further by intercepting runtime events, adding providers, and shipping versioned plugin packages. Everything is declared in a single reasonix.toml with no hardcoded models. It also ships the safety furniture a long unattended run needs and Pi deliberately omits: plan mode, a permission layer, a workspace sandbox, and per-turn checkpoints you can read and undo. One capability nobody else here offers is running an executor model and a planner model together in separate cache-stable sessions.

What it locks you into

Nothing at the protocol level: any OpenAI-compatible endpoint is one config entry, and reasonix.toml is the whole of it:

The interesting bias is in the loop itself, which is engineered around DeepSeek’s prefix-cache behaviour so a long-running session keeps hitting cache instead of re-paying for context. That is a real differentiator if you leave an agent running for hours, and close to irrelevant if you work in short bursts. Because DeepSeek’s cache matches on complete units rather than byte-for-byte prefixes, the savings arrive later in a session than people expect; plan around the shape of your work, not the headline cache rate.

Pi: A Harness That Ships Almost Nothing on Purpose

Where it runs

Terminal, and also as print/JSON output, an RPC service, and an embeddable SDK. Install with npm i -g @earendil-works/pi-coding-agent; version 0.84.1 landed on 2026-08-07. It is #7 in OpenRouter’s global app ranking with 2.79T tokens and MIT licensed.

What it costs

Free and open source.

What extends it

An extension API, and deliberately little else. Pi ships without MCP, without subagents, and without a plan mode, and describes this as a choice rather than a roadmap gap: primitives, not features. If you want those capabilities you build them on the extension surface. For teams that already have opinions about how their agent should behave, starting from a bare loop is faster than fighting someone else’s defaults. For everyone else it is more work on day one.

What it locks you into

Nothing, and its usage data proves it: 15+ providers, mid-session model switching with /model, and the flattest model distribution of any tool measured here at 20% for its top model. Adding one is a block in ~/.pi/agent/models.json and nothing else:

One caveat deserves flagging because the project documents it openly: Pi has no built-in permission system for filesystem, process, network, or credential access, so sandboxing is your job. Run it in a container if you are giving it anything sensitive. The r/AI_Agents thread also carries a user report that Pi burns noticeably more tokens than a rival harness for equivalent work, which fits a design that leaves context strategy to you.

Other AI Coding Agents Worth Knowing

These did not get full sections either because they occupy a narrower slice or because we could not put them through the same hands-on pass.

Are Antigravity and GitHub Copilot the Same Thing?

Someone asked exactly this in the r/AI_Agents thread, after seeing Antigravity rated well and Copilot rated poorly by the same person. It is a fair challenge, and the answer is instructive because superficially they are the same product category: a big-vendor tool with a curated model menu and a subscription instead of a token bill.

They diverge on how the meter runs. Copilot bills against a credit balance that agent work draws down, so heavy sessions on an expensive model can exhaust a month’s allowance quickly, and the user in that thread reported a colleague clearing $30 of budget in five days. Antigravity meters differently, with usage ceilings tied to plan tier rather than a per-request balance, which changes the feel from watching a wallet drain to hitting a wall and waiting. Neither is universally better. If your work is bursty, a credit pool with rollover-free monthly reset is wasteful; if it is steady and heavy, a fixed ceiling is more predictable.

The second difference is verification. Antigravity ships a browser it drives itself, so front-end changes get visually checked inside the loop. Copilot’s strength is the opposite end, being wired into pull requests, code review, and CI where the work lands rather than where it is written.

Which Harnesses Work Remotely or Async?

Terminal-native tools are the ones you can put on a server. Codex CLI, Claude Code, OpenCode, Reasonix, and Pi all run headless over SSH, and Pi goes furthest by exposing print/JSON, RPC, and SDK modes designed for exactly that. Cursor is tied to a running editor. Copilot goes furthest in the other direction, with a cloud agent that accepts an issue and returns a pull request without a machine of yours being involved. Antigravity 2.0 runs several agents in parallel but they are local agents in a local window.

Cline is the surprise in this column. The extension needs an editor, but the CLI does not: it starts a local hub daemon and a browser dashboard that tracks connected clients and running sessions, which makes it viable on a box you have SSH’d into.

If unattended, long-running work is the goal, the shortlist is short: a terminal harness plus a model with stable caching, which is precisely the niche Reasonix was built for.

What Does a Month of Agent Coding Actually Cost?

The most informative number we found this month came from a user rather than a vendor. In the r/AI_Agents thread, a developer working across four projects posted their DeepSeek dashboard: roughly 1.2 billion tokens in a month, overwhelmingly cache reads, for $9.57. Treat that as one person’s report rather than a benchmark, but the shape of it is the lesson. Their spend was low not because they used a cheap harness but because nearly all their context was served from cache.

That reframes the cost question. The harness barely moves your bill directly. What it moves is cache hit rate, through how it assembles context between turns, and token volume, through how often it re-reads files or retries a failed step. A harness that rebuilds the prompt from scratch every turn will cost multiples of one that appends, on the identical model. This is why per-task cost comparisons between tools are close to meaningless unless the model, the repository, and the task are all held constant.

Subscription tools sidestep the question by hiding it. With Copilot or Antigravity you cannot see cost per task at all, only how fast the allowance drains. That is a real advantage for budgeting and a real disadvantage for optimising.

When Is Each One the Right Call?

Every tool here wins somewhere. In order:

• Codex CLI when you live in the OpenAI stack and auto-approve shell commands. It is the only tool here whose codebase shows OS-level isolation primitives, seatbelt on macOS and Landlock plus seccomp on Linux.
• Claude Code when you want the harness to encode team process. No other tool here exposes as many built-in extension points.
• Antigravity when you want several agents working in parallel with visual verification and no per-token anxiety.
• GitHub Copilot when the work happens in pull requests and reviews rather than in an editor session, and when everyone on the team already has a seat.
• Cursor when editing speed matters most. Nothing here matches its Tab model; just plan on running your agent work in its terminal.
• Cline when you want plan-then-act discipline inside the IDE with a cheap model behind it.
• OpenCode when model freedom is the requirement and you are willing to configure.
• Reasonix when sessions run for hours and cache economics dominate your bill.
• Pi when you have strong opinions about the loop and want a foundation rather than a product.

Can You Run More Than One?

Yes, and the developers with the most experience mostly do. The r/AI_Agents thread reads less like a search for one winner than a description of a portfolio: an editor for fast edits, an IDE agent for local context, a terminal agent for multi-file work with tests. One commenter recommended keeping those three lanes explicitly separate and testing any new tool on the same three tasks, a bug fix, a small feature, and a refactor with tests, then keeping whichever produced the smallest clean diff with the fewest manual nudges.

That is a better evaluation protocol than any benchmark in this category, and it takes an afternoon. Our own four-tool comparison of Claude Code, Codex, Gemini CLI, and Cursor and the terminal-agent shootout both approached the category that way, one tool at a time against the same work.

The reason more people do not run that test is not that it is hard. It is that running three harnesses means configuring three sets of credentials.

How Do You Point All of Them at the Same Key?

Which is the practical gap underneath this entire comparison. Every tool here that lets you choose a model expects its own credentials, in its own format, in its own config file. Claude Code wants ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN. Codex wants a model_providers block in TOML with wire_api = "responses". Cline wants provider settings in the extension UI. OpenCode wants a provider entry, Reasonix a reasonix.toml stanza, Pi its own provider config. Six tools, six places, and if you pay each model vendor directly, six invoices with six separate rate limits that do not pool.

The gap is real and it is not any one tool’s fault. It is what happens when a category standardises on two wire protocols and nothing else.

Because most of these agents speak either OpenAI-compatible or Anthropic-compatible HTTP, the fix is the same shape everywhere: point them at one endpoint that serves both protocols, and change the model ID string rather than the plumbing. ofox.ai exposes both, so the same key covers Claude Code, Codex CLI, Cline, OpenCode, Reasonix, and Pi, and the spend lands in one place instead of six. Per-tool setup lives in the integration docs, and the honest limits are documented alongside: Copilot works in Chat only and only on an Individual seat, Cursor blocks Tab and Agent entirely, and Antigravity has no such setting to configure. Three of the nine cannot fully join, and pretending otherwise would not survive your first afternoon of testing.

The reason this matters beyond convenience is the evaluation protocol above. Running the same bug fix through three harnesses on the same model is only cheap when the credentials are already shared.

Verdict: Pick the Loop, Then Pick the Model

There is no best harness, but there is a best question, and most articles ask the wrong one. Pick the tool by its control loop, because that is what you live with, and pick the model separately, because on every tool that allows it developers already treat those as independent decisions. The OpenRouter data settles that empirically: the most popular model inside Claude Code is not made by Anthropic, and it is not close.

If you want one starting point: a terminal harness that accepts a base URL, pointed at a cache-friendly model, with your editor kept for editing. That configuration is what the heaviest users in this category converged on, and it costs less than a lunch per month to run.

References

• OpenRouter coding agent rankings
• OpenRouter app page: Claude Code
• OpenRouter app page: Codex
• OpenRouter app page: Cline
• OpenRouter app page: pi
• GitHub Copilot plans and pricing
• Google Antigravity
• google-gemini/gemini-cli repository
• openai/codex repository
• cline/cline repository
• esengine/DeepSeek-Reasonix repository
• pi.dev
• DeepSeek API documentation
• r/AI_Agents: What AI harness for coding?
• ofox integration docs