The model is the engine. The harness is the car.
Every “AI coding agent” you've heard of (Claude Code, Cursor, Devin) is the same handful of frontier models wrapped in different scaffolding. This guide covers what that scaffolding does, the three interfaces the market has built it into, and why the wrapper now matters more than which engine sits inside it.
Direct API call, chatbot, deep research, agentic harness: these are points on the same two scales. Each axis is a discrete ladder: rows measure how far the loop runs before a human is needed again, columns measure what the loop's tool schema permits. Where two tiers share a row or column, they share that trait exactly. Click a point.
Rows measure how far the loop runs before a human is needed again. Columns measure what it's allowed to touch. The two axes move independently: chatbot and deep research share a column because both read and neither writes, and the dashed nodes mark cells that products already occupy: a chat session with a send-email connector, a harness told to stop after one pull request.
A harness is what turns the “agentic harness” cell into a product. It's the same underlying loop as deep research, aimed at a real environment instead of a stack of search results, and left running longer. An autonomous agent shares that same column and takes the row one step further: its trigger, a schedule or an event, was authored once by a human and then fires without one.
Workflows sit in the no-loop, read-write cell, and a third property separates them from everything else on the grid: who chooses the control flow. Anthropic's engineering guidance defines a workflow as a system where a human writes the code path and the model fills in specific steps, and an agent as a system where the model decides its own next step at runtime. A workflow can call a model, use tools, and touch real systems; a human chose the route before it ran.
| Term | What it is | Loops on its own? | Touches real systems? | Stops when |
|---|---|---|---|---|
| Direct API call | One request, one response | No | No | The response is generated |
| Chatbot | A back-and-forth conversation you drive turn by turn | No, you send each turn yourself | Sometimes: a web search by default; read-write once connectors are attached | You stop sending messages |
| Deep research | The model runs its own search-and-read loop for one request | Yes, but only within that one task | Reads external sources, doesn't write anywhere | The report is compiled |
| Agentic harness | The model runs an open-ended loop against a real environment | Yes, until the task is done or it's stopped | Yes: files, commands, deployments | The task passes its checks, or a limit is hit |
| Autonomous agent | A harness whose trigger, a schedule or an event, was authored once and then fires without a human | Yes: the trigger was set once, then each run starts without you | Yes: files, commands, deployments | The task passes its checks, or a limit is hit |
| Workflow | Fixed code calls the model at specific steps; a human chose the path in advance | No: a human wrote the path; the model fills in steps | Can, wherever the human wired it to | The predefined path finishes |
A harness is software that runs a model in a loop: call the model, execute what it asks for, feed the result back, repeat. The dashed boxes below are you: the diagram marks where you enter the loop. Toggle it to see what changes when the loop exists at all.
You write the task in plain language. Everything downstream traces back to how much you specified up front; a vague prompt gets more decisions made for you.
Before anything risky (running a command, editing outside the project folder, calling an external service) most harnesses pause and ask: allow once, allow for the rest of this session, or deny. This is the permission system in practice.
Once the loop stops, you read the diff, the test output, or the opened pull request before it ships. The harness surfaces the result; you decide whether the work is good enough to merge.
The three cards below are MECE on interface surface: every surface a harness ships sits in exactly one. Products often ship several surfaces (Claude Code runs as a CLI, an IDE extension, and a desktop app), so the table further down lists each product's primary surface and puts the others in the note column. License and company are separate columns, because “who made it” and “where it runs” are independent questions.
Runs as a process in your terminal with direct read/write access to your actual files and shell. The model gets tool definitions for file editing and command execution; the harness code parses each request and runs it against your real working directory.
Lives inside the editor and leans on deep codebase indexing; it needs to know your whole project, beyond the file you have open, to suggest well.
Runs the whole loop on a remote sandboxed machine, decoupled from your laptop. You hand off a task and it plans, executes, tests, and opens a pull request for review; or, for some products, starts on its own from a schedule or an event.
| Frameworks & SDKs | A layer underneath all three tiers. LangGraph, the OpenHands SDK, and CrewAI ship no default interface at all; you use one to build a CLI tool, an IDE plugin, or a cloud service yourself. Same relationship to this chart that Workflows have to the Spec 01 grid: a different kind of thing from the tiers. | |||
Four companies now sell into more than one row of the table below, which is why “company” and “interface tier” stay separate columns. Microsoft/GitHub is the clearest case: Copilot CLI, Copilot's IDE agent mode, and the Copilot cloud agent are three distinct products under one brand. Cognition sells Devin across four surfaces since June 2026: Devin Desktop (IDE), Devin Cloud, Devin CLI, and Devin Review. Google sells Antigravity CLI (terminal) and Jules (cloud) side by side. Anthropic ships Claude Code as a CLI, IDE extensions, and a desktop app. Each product row lists its primary surface.
| Product | Company | Primary surface | License | Note |
|---|---|---|---|---|
| Claude Code | Anthropic | CLI | Proprietary | Also ships as IDE extensions and a desktop app |
| Codex CLI | OpenAI | CLI | Open source | Sandbox ships with network access off by default |
| Aider | Independent | CLI | Open source | Git-native, auto-commits |
| opencode | anomalyco | CLI | Open source | Roughly 200k GitHub stars; also ships a desktop app and IDE extension |
| Antigravity CLI | CLI | Closed source | Replaced Gemini CLI for consumer tiers, June 2026 | |
| GitHub Copilot CLI | Microsoft (GitHub) | CLI | Proprietary | Autopilot mode runs a task to completion without per-step approval |
| Cursor | SpaceX (SpaceXAI) | IDE | Proprietary | Acquired from Anysphere for $60B; closed Aug 14, 2026 |
| GitHub Copilot | Microsoft (GitHub) | IDE | Proprietary | Agent mode in VS Code, JetBrains |
| Cline | Independent | IDE | Open source | – |
| Devin Desktop | Cognition | IDE | Proprietary | Formerly Windsurf; rebranded June 2, 2026. Hosts third-party agents via ACP |
| Devin | Cognition | Cloud / async | Proprietary | Billed in Agent Compute Units |
| Jules | Cloud / async | Proprietary | Scheduled, self-triggered runs since Dec 2025; GA May 2026 | |
| GitHub Copilot cloud agent | Microsoft (GitHub) | Cloud / async | Proprietary | Automations run on a schedule or repository event (June 2026) |
| OpenHands | All Hands AI | Cloud / async | Open-core | Also fully self-hostable |
| Manus | Butterfly Effect | Cloud / async | Proprietary | Meta's Dec 2025 acquisition was ordered unwound by China's NDRC in Apr 2026; independent again as of Aug 2026. General-purpose agent |
| LangGraph | LangChain | – | Open source | A library with no default interface |
| OpenHands SDK | All Hands AI | – | Open source | A library with no default interface |
| CrewAI | CrewAI Inc. | – | Open source | A library with no default interface |
MCP is the protocol running inside the Tool call box from Spec 02, the mechanism that lets a harness reach the Read-only and Read-write columns from Spec 01, and it now runs across all three interface tiers from Spec 03.
Before MCP, every harness had to hand-build its own connection to every external service: a custom Slack integration here, a custom GitHub integration there. MCP standardizes that connection into one protocol, and it's the mechanism behind the tool execution and permissions bullets in Spec 02: the harness still decides whether a call needs your sign-off, and MCP is what makes the call itself possible in the first place.
A server exposes what it can do (a Slack workspace, a codebase, a database) in a shared format. Whether a given MCP tool lands in the read-only or read-write column from Spec 01 depends entirely on the server. MCP standardizes how a tool is discovered and called; the server decides how risky that tool is to run.
Adoption now spans all three tiers from Spec 03: Claude Code and opencode (CLI), Cline and Cursor (IDE), and GitHub's Copilot cloud agent and Jules (cloud) all support MCP servers. The tiers differ in trust model. Local harnesses accept any server you configure; cloud platforms curate, and Jules exposes MCP through a vetted partner program.
Two related standards sit beside MCP. ACP (Agent Client Protocol) standardizes how editors host coding agents: Devin Desktop, JetBrains, and VS Code implement it, so Claude Code, Codex, or opencode can run inside another vendor's editor. A2A lets agents negotiate directly with each other; CrewAI has implemented it for peer-to-peer coordination without a central orchestrator.
The scoreboards are noisier than they look, and the harness itself is a bigger lever than most buyers assume. The three cards below make the same point from three angles: the number you see depends on the scaffold that produced it.
The original standard. Frontier models now score in the low-to-mid 90s, and the set is flagged for contamination: newer models' training data overlaps the test set. Kept mainly for historical comparison.
Scale AI's contamination-resistant successor, built from copyleft and private codebases. On the standardized public set (731 tasks, one shared scaffold) GPT-5.4 leads at 59.1% as of August 2026. Vendor-reported runs on the same benchmark reach 80%, so any quoted score needs its split and scaffold named.
The spread between 59.1% under Scale's standardized scaffold and 80% with vendor-chosen scaffolds is produced by harness and data split alone, holding the model class constant. Terminal-Bench 2.0 scores autonomous, multi-step execution end to end, and is emerging as the more relevant test.