What Is an Agent Harness? The 2026 Field Map of AI Coding Harnesses

The word your release notes keep using

“AI agent harness” is the term your changelogs, model cards, and half of HN now assume you know. Lab eval writeups credit the harness alongside the model, and SWE-bench-style leaderboards score model-plus-scaffold pairs rather than bare models . The software around the model got promoted from implementation detail to named variable.

If you daily-drive two or three coding agents, you have met the word a dozen times without anyone defining it. This page does two jobs: pin the term down the way a practitioner would, then map the 2026 field — the US frontier labs, the Chinese CLI wave, the open-source lane, the new wave, and the adjacent surfaces that are harnesses wearing different clothes.

One warning before the map. This space ships monthly, and 2026 has been a culling year — Gemini CLI is dead, several 2025 fixtures folded, and a new cohort appeared in the vacated shelf space. Roster claims below were re-checked on August 27, 2026, and the graveyard is marked.

What an AI agent harness actually is

An AI agent harness is the software wrapped around a language model that turns it into a working agent. The harness assembles context, exposes tools and executes their calls, enforces permissions, and manages sessions. The model does the thinking; the harness does everything else — and “everything else” determines most of what you actually experience.

Ground it in the tools on your machine:

• Claude Code, Codex CLI, and the late Gemini CLI are harnesses. Claude Fable 5, GPT-5.6, and Gemini 3.1 are the models that ride inside them. Readers conflate the two daily, which is why benchmark debates so often talk past each other.
• The term arrived when models became swappable. Once BYOK and compatible endpoints let you change the engine without changing the cockpit, the wrapper needed its own name, its own reviews, and its own line on the bill.
• The synonyms: “scaffold” (benchmark papers), “agent wrapper,” “coding harness.” This site standardizes on harness; you will see “scaffold” only in quotes.
• It even has a discipline now. Tuning the wrapper — prompts, tool design, permission policy, context budgets — is called harness engineering, with a curated awesome-list collecting its papers, patterns, and tooling.

The definition earns its keep the first time you use it diagnostically. When your agent “got dumber this week,” the model usually did not change — the harness shipped a release that reworked context compaction or swapped an edit format. Models version quarterly; harnesses version weekly. Knowing which layer moved is the difference between a useful bug report and a superstition.

Agent harness vs test harness: same word, different machinery

Searchers asking “what is a harness in AI” are usually untangling three senses that share one metaphor:

• Test harness — code that exercises other code under controlled conditions: fixtures, drivers, assertions. The oldest sense, and still what most of the SERP means.
• Eval harness — benchmark machinery that runs models against standardized task suites and scores the output; lm-evaluation-harness is the canonical example.
• Agent harness — machinery that makes a model act on real systems: your repo, your shell, your APIs. The sense this page maps.

The metaphor stuck for a reason: a harness is rigging that lets something powerful pull safely, and all three senses are exactly that. For completeness, there is a fourth collision — Harness, the CI/CD company, which shipped “CLI 3.0 + Agent DLC” in July 2026. That is a product line from a vendor named Harness, not the category; keep the senses distinct or mid-2026 press coverage reads like nonsense.

The QA sense has its own agentic story — testing software that acts nondeterministically forced a rebuild of the classic harness, covered in the test harness, reinvented.

Same model, different harness, different results

Here is the claim this whole page rests on, so let’s argue it properly. On SWE-bench-style leaderboards, entries are model-plus-scaffold pairs because the same base model posts meaningfully different scores depending on the scaffolding around it . The labs tell on themselves too: Anthropic tunes its models against Claude Code’s tool set, and OpenAI trains the Codex line against its own CLI-and-cloud loop . “Model quality” as you experience it already includes harness fit.

The uncomfortable, useful fact of 2026 follows directly: the harness is a first-class variable. Same model, same task, different harness — different tool calls, different retries, different token bill, and sometimes a different verdict on whether the task got done at all. Three mechanisms do the differentiating:

• Context management — what enters the window, in what order, and when it gets compacted. A harness that maps your repo well makes the model look smarter; one that compacts clumsily makes it look amnesiac.
• Tool design — edit formats, search strategy, failure recovery. An edit tool that fails loudly and retries cleanly saves entire loops; one that mangles a diff burns tokens teaching the model to apologize.
• Permission UX — how much autonomy you actually grant in practice. An agent that must interrupt you every 90 seconds is a slower agent, whatever the benchmark says.

You can run the experiment yourself in an afternoon: same task, same model, two harnesses. Put GLM-5.2 behind Claude Code via an Anthropic-compatible endpoint, then behind OpenCode , give both the same bug, and diff the transcripts. Count tool calls, count retries, count tokens. The deltas are rarely subtle — and after that exercise you will never again read a benchmark number without asking what harness produced it.

The corollary is a reading discipline for the rest of 2026’s benchmark discourse. A vendor’s score arrives pre-fitted to that vendor’s harness; a third-party score arrives fitted to whatever scaffold the eval team wired up. Neither is wrong, but comparing them across that line is comparing engines installed in different cars and calling it a drag race. When a number matters to a decision you are making, find the scaffold name before you quote it.

Anatomy of a coding harness: the five organs

Strip the branding from any tool on the map below and you find the same body plan. Every serious harness, whatever its surface, is five organs arranged around a model:

• 1. Context engine — the system prompt, memory files (CLAUDE.md, AGENTS.md, and the conventions each tool layers on ), repo mapping, and compaction policy. This organ decides what the model even sees, which makes it the highest-leverage one.
• 2. Tool layer — built-in read/edit/run/search tools, plus MCP as the extension standard nearly every harness on this map now speaks . The protocol itself matured this summer: the 2026-07-28 MCP spec moved to a stateless request/response core with cacheable listings — plumbing changes that mostly exist so harnesses can wire tools faster.
• 3. Permission and approval model — the range from ask-every-action to full auto: allowlists, sandboxes, per-tool gates. This organ sets your real-world blast radius, and it is where harnesses differ most in philosophy.
• 4. Session state — transcripts, resume, checkpoints. The organ that determines whether last Tuesday’s work still exists, and the one most harnesses treat as an afterthought.
• 5. The surface — the body the other four live in: a terminal CLI, an IDE, or a cloud workspace. Same anatomy, different chrome.

The anatomy doubles as a debugging checklist. Agent editing the wrong file? Context engine — the repo map is stale or the memory file is misleading it. Mangled diffs and apology loops? Tool layer. An agent that either asks constantly or terrifies you? Permission model. Can’t find last week’s work? Session state. Organ-by-organ diagnosis beats “this tool is bad” every time, and it is the frame the deep dives in this cluster use.

The five organs: context engine, tool layer, permissions, session state — inside a surface, around a model.

Reading the 2026 field map

The map below runs by origin — US frontier labs, the Chinese wave, open source, the new wave — because origin predicts business model, defaults, and data terms better than any feature list. Each entry carries its surface, its model policy (locked to the vendor’s models vs bring-your-own), and its one distinguishing organ.

It also carries a graveyard, because the defining event of mid-2026 was subtraction. Gemini CLI was discontinued on June 18, 2026, breaking CI pipelines on shutdown morning and producing a suitably angry HN thread. Per the mid-2026 field map, iFlow CLI and Roo Code also shut down, Cascade hit end-of-life, and Phind is gone .

The operational lesson is worth stating before the roster: when a harness dies, it takes more than a binary with it. Sessions in its private format strand, memory-file conventions orphan, CI steps break at 6 a.m. UTC. Treat every entry below as a dependency you might have to migrate off — how to pick tools that survive is its own playbook, the great harness die-off.

The field by origin, August 2026: four living lanes and one graveyard.

US frontier-lab harnesses

• Claude Code (Anthropic) — the terminal reference point, now spanning CLI, IDE, and web surfaces. Deepest extension surface in the field: hooks, subagents, skills, MCP. Subscription-first, models locked to Anthropic’s Fable 5 era lineup . The full workflow treatment is in the Claude Code field guide.
• Codex (OpenAI) — one agent identity across Codex CLI, Codex cloud, and the IDE extension, with the field’s strongest delegation story: hand a task to the cloud loop, review the PR later. Bundled with ChatGPT plans , GPT-5.6 (Sol) inside. Daily-driver review at the Codex deep dive.
• Antigravity CLI (Google) — the Go-based replacement that arrived as Gemini CLI died, sitting beside the Antigravity IDE with Gemini 3.1 inside. Google traded the largest free CLI in the field for a fresh start; what the shutdown and migration actually looked like is the Antigravity story.
• GitHub Copilot — the repo-graph harness: agentic automation where your code already lives, plus a younger CLI . The June 1, 2026 move to usage-based billing with AI credits made it the poster child for the metering era.
• Amazon Q Developer — the AWS lane, locked to the console-and-IDE world it serves; as of mid-2026, new signups are blocked per reporting . Copilot, Q, and xAI’s Grok lane get their shared treatment in the other American harnesses.

The pattern is hard to miss once named: each harness expresses its lab’s distribution advantage. Anthropic’s terminal craft, OpenAI’s ChatGPT scale, Google’s platform reboot, GitHub’s repo graph, AWS’s console. Nobody is neutral; the harness is the funnel, which is why every one of these ships locked or curated model menus. It also explains the churn — when a lab’s distribution strategy pivots, its harness pivots with it, users notwithstanding. Gemini CLI’s users learned that on a Thursday in June.

The Chinese CLI wave

• Qwen Code (Alibaba) — the Gemini CLI fork that outlived its parent, driven by Qwen3-Coder-Next. The famously aggressive free OAuth tier ended April 15, 2026, per reporting , pushing users onto API pricing that is still cheap.
• Kimi Code CLI (Moonshot AI) — the terminal harness for the K line, currently Kimi K3 — the 2.8T-parameter MoE that posted ~93.4% on SWE-bench Verified and became the first open model to lead a frontend-code arena.
• Z.ai GLM Coding Plan — the interesting non-harness: Z.ai mostly sells a cheap subscription engineered to plug GLM-5.2 into harnesses you already use, rather than shipping a cockpit of its own .
• DeepSeek-TUI — a newer terminal entrant riding DeepSeek V4’s price floor, per the mid-2026 map .
• iFlow CLI — gone, per the same reporting; its free rotating-model menu did not survive the year.

The shared strategy: price aggression plus deliberate compatibility with the muscle memory Claude Code built. Meet developers inside habits they already have, then win on the bill — flat monthly plans priced in single digits against US subscriptions priced in tens, per the mid-2026 map . The questions that strategy raises — data residency, terms of service, model provenance — are real, and litigated properly in the Chinese CLI deep dive.

The open-source harnesses

• Aider — the git-native original: disciplined diff-based edits, automatic commits, benchmark-honed edit formats (aider.chat). Pure BYOK.
• Cline — the VS Code agent with the plan/act split review-minded teams like. Its fork lineage thinned this year: Roo Code shut down per mid-2026 reporting , while Kilo CLI carries the line forward.
• OpenCode — the provider-agnostic terminal TUI; the closest FOSS shape to a vendor flagship, with model freedom as the point.
• Goose (Block) — MCP-first and extensible, where extensions simply are MCP servers; moved to the Linux Foundation per mid-2026 reporting .
• OpenHands — the ex-OpenDevin autonomy platform: sandboxed runtime, headless and cloud modes, research pedigree.

Notice what the graveyard does not contain: an independent open-source harness with an active community. Roo Code died as a project, but its code lives on in the Kilo line — a fork outlives a vendor pivot, which is the quiet structural advantage of this lane. The die-off punished tools whose existence depended on one company’s strategy staying constant.

The lane matters beyond ideology for two more reasons. BYOK economics: raw API rates with no plan markup, which cuts both ways once agent loops start multiplying tokens — the token-plan math covers when a flat plan quietly beats it. And portability: swap models daily, keep the workflow. The cost is stated once and honestly: you are the integration team. Full reviews live in the open-source harness roundup.

The new wave: what 2026 minted

The die-off cleared shelf space, and the cohort that filled it was born with post-Claude-Code assumptions — MCP support, permission gates, and multi-model plumbing on day one:

• Amp (Sourcegraph) — the most prominent of the new paid CLIs per the mid-2026 map , leaning on Sourcegraph’s code-graph heritage.
• Crush (Charm) — the charmbracelet entry: characteristically excellent terminal craft applied to the agent loop.
• OpenClaw — a fast-moving independent entrant, per reporting .
• Ecodex — the contrarian: calibration gates that make the agent state its confidence and block actions it cannot justify — the “epistemic accountability” pitch, per the mid-2026 map .
• Also circling: Hermes Agent, Kilo CLI, Pi, and Mistral’s Vibe CLI — the coding lane of the Le Chat–to–Vibe rebrand, per reporting .

Read the cohort together and a pattern emerges: nobody is trying to out-generalize Claude Code anymore. The new wave differentiates on a single organ — Amp on context via the code graph, Crush on surface craft, Ecodex on the permission model — and assumes the decoupling era’s plumbing for the rest. Which of these earn a slot on your machine, and which repeat the mistakes the graveyard already made, is the subject of the new-wave harness review.

Adjacent surfaces: agentic IDEs and cloud workspaces

Agentic IDEs. Cursor remains the biggest editor-shaped harness; Devin Desktop is the former Windsurf after Cognition’s rebrand, its Cascade agent line at end-of-life per mid-2026 reporting ; Google’s Antigravity IDE pairs with its CLI. Look inside any of them and you find the same five organs in an editor shell — the boundary blurs, the anatomy holds.

Cloud workspaces and cowork tools. Codex cloud, Claude Code on the web, Devin, and Manus are harnesses running on someone else’s machine behind a browser: same organs, plus a sandbox you do not administer. The delegation-first way of working they enable is mapped in cowork tools and autonomous workspaces.

The boundary rule, since the chrome keeps changing: if it assembles context, runs tools, and gates permissions around a model, it is a harness. Terminal, editor, or browser tab is a costume decision.

The decoupling era: any model in any harness

The mechanism is mundane and the consequence is not. Per mid-2026 reporting, every serious CLI harness accepts at least one of the two de facto wire formats — OpenAI-compatible or Anthropic-Messages endpoints — and open-model API pricing fell roughly 80% year over year. A base-URL override is now a routing decision:

# DeepSeek V4 driving an OpenAI-compatible BYOK harness
export OPENAI_API_BASE="https://api.deepseek.com/v1"
export OPENAI_API_KEY="sk-..."

# GLM-5.2 behind an Anthropic-Messages-compatible harness
export ANTHROPIC_BASE_URL="https://<provider-anthropic-endpoint>"
export ANTHROPIC_AUTH_TOKEN="$GLM_CODING_PLAN_KEY"

What follows from one env var:

• Harness and model are separate purchase decisions with separate bills — you can love the cockpit and shop the engine.
• A Chinese model inside a US harness is a routine 2026 setup, not a hack; the terms-of-service and residency caveats are real and covered in the Chinese CLI deep dive.
• The open-weight lane rides the same rails: local or hosted open models driving any BYOK harness — which weights can actually hold the engine slot is the subject of open-weight models for agents.
• The resisters are telling. Codex and Copilot keep their model menus closed or curated — bundling defends subscription revenue, which is precisely why the labs treat the harness as a moat.

The aggregate effect is a quiet unbundling of loyalty. You can be a Claude Code loyalist and a DeepSeek price shopper in the same afternoon, routing the refactor to the flagship and the grind to the floor. Harness choice is becoming a workflow decision; model choice is becoming a per-task procurement decision. The vendors know it, which is the whole subtext of the moat question at the end of this page.

How to evaluate an AI agent harness: the six-line rubric

Run any candidate — including everything named above — through six probes:

Dimension	Probe	Red flag
Context handling	Does a two-hour session degrade gracefully, and can you see what is in the window?	Silent truncation; no memory-file support
Tool ecosystem	How long to wire up your bug tracker — MCP or native?	No MCP, no extension surface
Permission granularity	Can you allow running tests but block deploys?	One global autonomy slider
Session management	Find last Tuesday’s session in under a minute	History is a scrollback buffer
Cost transparency	Attribute yesterday’s spend to specific sessions	Spend visible only on the vendor’s dashboard
Portability	What survives a switch — config, skills, transcripts?	Proprietary everything

The rubric is designed to run in one afternoon per candidate: one repo you know well, one bug you have already fixed, one hour. Give the harness the bug, watch which files it reads, interrupt it once, resume it, then try to find the session afterward and attribute what it cost. Six probes, no benchmark required, and the results transfer because the repo and the bug were yours.

Weight them honestly: context handling and permission granularity dominate the daily experience; portability dominates the year-two regret. The graveyard above is one long argument for taking the sixth row seriously.

The fleet reality: nobody runs just one

Follow the map to its practical conclusion and you land on the modal 2026 setup: a premium primary (Claude Code or Codex), a cheap grind lane (a Chinese coding plan or a free tier), and an experiment slot for whatever the new wave shipped this month. The survey you just read is not a menu to choose one item from — it is most readers’ actual desktop.

The rotation drivers are the usual four: rate-limit windows that end mid-task, provider outages, price arbitrage between lanes, and second opinions from a different model family. All rational. All additive — nobody who adopts a second harness goes back to one.

And the tax nobody meters: sessions scattered across N history formats, the same config duplicated N times, spend spread across N dashboards that disagree on units. Every harness on this map manages its own sessions; none of them manages the fleet. That is a management problem in its own right — the full treatment is running multiple agents without the chaos.

Product note: Automater Lite is the operating layer above every harness on this map — a local-first archive consolidating sessions from 10+ CLIs (Claude Code, Codex, Gemini, Qwen Code, Copilot, and friends) with full-text search, amber/green fleet health, per-provider token metering, and cross-CLI skills sync — free, on automater.ai.

Where the harness category goes next

Three currents, one product cycle out — foresight, not futurism.

Convergence. Every serious vendor now ships or is building the CLI + IDE + cloud trio . When every cockpit has the same three bodies, differentiation moves down into the organs — context engines, sandboxes, review surfaces — which is exactly the territory harness engineering is professionalizing. Expect the interesting release notes of the next cycle to read like anatomy reports.

Portability pressure. AGENTS.md keeps spreading as cross-harness configuration , which erodes one kind of lock-in while a new one forms: skills, custom commands, and tuned workflows. Transcripts and memory files are becoming the asset; whoever holds your tuned workflows holds you. The die-off taught this cohort of users to keep that asset portable.

And the open question, posed without an answer: is the harness a moat — labs bundling cockpit to engine to defend subscription revenue — or a commodity, with open source commoditizing the loop while models differentiate? The 2026 evidence points both directions at once: the labs keep investing like it is a moat, the decoupling era keeps behaving like it is a commodity. That tension is usually what a genuinely contested market looks like, and it is why this map gets redrawn monthly.

FAQ: AI agent harnesses

What is an agent harness in AI?

An agent harness is the software wrapped around a language model that turns it into a working agent — assembling context, exposing and executing tools, enforcing permissions, and managing sessions. Claude Code is a harness; Claude Fable 5 is the model inside it. The model thinks; the harness does everything else.

Is an agent harness the same as a test harness?

No. A test harness exercises code under controlled conditions; an eval harness benchmarks models against task suites; an agent harness makes a model act on real systems like your repo and shell. Same rigging metaphor, different machinery — and QA for agents has its own reinvented harness discipline.

What is the difference between a harness and an agent framework?

Frameworks — LangGraph and kin — are libraries you build agents with: you write the loop, wire the tools, own the code. A harness is a finished agent you operate: install it, point it at a repo, grant permissions. Builders reach for frameworks; daily drivers live in harnesses.

Can I use one company’s model inside another company’s harness?

Often, yes. BYOK harnesses and compatible endpoints make it a base-URL override — GLM-5.2 or DeepSeek V4 inside an Anthropic-Messages or OpenAI-compatible harness is routine in 2026. Check the terms on both sides first: some vendor plans restrict third-party harness use.

Which AI coding harness is best?

Wrong question — harnesses differ by organ, and your constraints pick the winner. Run the six-line rubric (context, tools, permissions, sessions, cost, portability) against your shortlist, then read the deep dives: Claude Code, Codex, Antigravity, the other US harnesses, the Chinese CLIs, and the open-source lane.

Sources

• awesome-harness-engineering — curated harness engineering resources (GitHub)
• dev.to — Coding CLIs in mid-2026: the engineer’s map and what changed in 30 days
• TechTimes — Gemini CLI Shutdown Takes Effect, CI/CD Pipelines Break, Go-Based Antigravity CLI Arrives (June 18, 2026)
• Hacker News — Gemini CLI shutdown discussion
• GitHub Blog — GitHub Copilot is moving to usage-based billing
• Model Context Protocol — the 2026-07-28 specification release
• Harness — Shipped in July 2026: CLI 3.0 + Agent DLC
• Morph — The Best Open-Source Coding Models of 2026
• Crush — Charm’s terminal agent (GitHub)
• Aider — AI pair programming in your terminal