The New Agent Harnesses, Compared (2024–2026)

A survey of the agent harnesses that defined 2024–2026. For each one: identity, its design thesis — the explicit bet it makes about how a coding agent should be built — architecture, differentiators, and concrete numbers. At the end: a master table and the synthesis of the design axes.

Most data comes from primary sources (GitHub, READMEs, docs, blogs, papers). Where a figure is inferred or from a tertiary source it's marked with ⚠️.

The contenders at a glance

1. Claude Code (Anthropic)

Thesis: "less is more" — a thin harness around a strong model. Start with the simplest thing that works and let the frontier model's general intelligence do the heavy lifting, instead of encoding lots of specialized logic. The agent is essentially a simple loop: prompt → tool calls → execute → append results → repeat until the model stops calling tools. Tools are file-based (not abstract AST/IDE operations): the agent reads/writes/edits real files and uses a shell, trusting the model to operate on plain text.

Architecture in brief:

• Tools: Read, Write, Edit/MultiEdit, Bash, Glob, Grep, Task (subagent), WebFetch, WebSearch, TodoWrite, + slash commands.
• Permissions: allow/deny/ask rules per tool; modes (default, acceptEdits, plan mode = read-only, bypassPermissions); hooks on lifecycle events to gate/transform actions.
• Context: auto-compact near the limit + /compact; ~200K window (1M beta on some Sonnets). A study (arXiv 2604.14228) describes it as while-loop + 7 permission modes + an ML classifier + a 5-layer compaction pipeline.
• Memory: CLAUDE.md (project, user, enterprise scopes), loaded at session start.
• Subagents: Task spawns subagents in their own context window that return a summary — parallelism without inflating the main context.
• Extensibility: MCP, plugins/marketplaces, Agent Skills (folder with SKILL.md), hooks, custom slash commands.

Numbers. 200K standard / 1M beta window. The March 2026 leak revealed ~512K lines of TS / ~1,900 files. Anthropic's key long-running result (Nov 2025): the initializer + coding agent pattern with a JSON feature list + git + Puppeteer MCP.

2. OpenAI Codex

Thesis: an open-source harness with a clean, documented protocol so any frontend (CLI, IDE, GUI) drives the same agent core. The app-server exposes a JSON-RPC protocol built on 4 primitives: threads (session), turns (a user request + the agent's work), events (streamed progress/output), and approvals (the agent asks before sensitive actions). First-class: sandboxing as a security primitive, retained reasoning + compaction for long tasks, and AGENTS.md as the standard instructions/memory file.

Architecture in brief:

• Tools: apply_patch (unified-diff patch format), shell/exec, web search.
• Permissions: approval policies (untrusted / on-failure / on-request / never) combined with sandbox modes (read-only, workspace-write, danger-full-access); OS-level sandboxing via Seatbelt (macOS) and Landlock/seccomp (Linux).
• Context: automatic compaction with retained reasoning (keeps a summary of the reasoning chain instead of discarding it).
• Memory: AGENTS.md (project + global) — now an industry-wide convention.

Numbers. On ARC-AGI-3: "retained reasoning + context compaction" lifted GPT-5.6 Sol from 13.3% → 38.3% while cutting tokens 6× — the harness design moves the score. Its "harness engineering" post documents a team that shipped ~1M lines / 1,500 PRs / 3.5 PRs per engineer per day for 5 months with zero human-written code.

3. Pi (Mario Zechner)

Thesis: a minimal, opinionated, self-extensible harness where the author keeps total control over what enters the model's context. Explicit motivations: context engineering is primordial (existing harnesses "inject things behind your back"), total observability of every model interaction, clean documented session formats, and the principle "if I don't need it, it doesn't get built." It's explicitly contrarian to Claude Code: "it became a spaceship with 80% of functionality I don't use".

Architecture in brief:

• Loop: message → tool calls → results → repeat, with no max-steps knob. Message queuing, a transport abstraction, and events for everything.
• pi-ai: a unified LLM API speaking only 4 wire APIs (OpenAI Completions, OpenAI Responses, Anthropic Messages, Google Generative AI) + any OpenAI-compatible endpoint. Cross-provider handoff is first-class (Claude → GPT → Gemini mid-session).
• TUI: "append-to-scrollback" (vs. full-screen viewport) to preserve native terminal scroll/search; differential rendering; flicker-free.
• Coding agent: minimal system prompt (system prompt + tool definitions <1000 tokens vs. thousands in Claude Code/Codex). 4 default tools: read, write, edit, bash. YOLO by default — the author argues other agents' safety measures are "largely security theater".
• Deliberate omissions (with rationale): no MCP (servers dump all tool descriptions into context every session: Playwright MCP = 21 tools/13.7k tokens — "7–9% of your context window lost"), no sub-agents (spawn pi via bash/tmux), no plan mode (write PLAN.md), no built-in todos ("they confuse models", use TODO.md).

In formula form, Pi's bet is that the effective context budget is what matters, not the advertised window: if the system prompt, tool definitions and injected conventions consume $C_{\text{fixed}}$ tokens on every turn, the model only ever reasons over $C_{\text{window}} - C_{\text{fixed}}$. Every harness that "injects things behind your back" grows $C_{\text{fixed}}$ — which is exactly the tax Pi refuses to pay.

• Sessions: JSONL files with tree structure (each entry id + parentId), enabling in-place branching (/tree, /fork, /clone) in a single file.

Numbers. Ran Terminal-Bench 2.0 with pi + Claude Opus 4.5; the snapshot (≈Dec 2025) shows Codex CLI #1 at 60.4% and Terminus 2 (Stanford's minimal tmux-only agent) at 54.2% — highlighted as evidence that "a minimalist approach can do just as well".

4. OpenCode (SST / Anomaly)

Thesis: "the open source AI coding agent." The philosophical opposite of Pi: full-featured, provider-agnostic, multi-surface. The architectural bet is a client/server design where the TUI is just a client of a headless server, so the same engine drives terminal, desktop, IDE, web and Slack — and can be driven programmatically.

Architecture in brief:

• Client/server loop: opencode starts TUI + server (HTTP headless on port 4096) with an OpenAPI 3.1 spec at /doc for SDK generation.
• Agents (distinctive feature): primary agents (Tab to switch): build (default) and plan (read-only); subagents via @mention: general (multi-step, parallel), explore (fast read-only search), scout (external docs research); plus a hidden compaction agent.
• Providers: Vercel AI SDK + models.dev → 75+ providers + local models (ironically, the exact SDK Zechner criticized in Pi).
• Context: a formal Context Epoch model — a baseline system context rendered once per epoch, kept immutable as a cache baseline until compaction; dynamic changes enter as Mid-Conversation System Messages at safe turn boundaries.
• LSP: ~35 built-in LSP servers (off by default; docs candidly note LSP "isn't always a net positive").
• Permissions: allow/ask/deny per action with wildcards and --auto; a containers package for isolation.

Numbers. 75+ providers; ~35 LSP servers; 2 primary + 3 subagents; ~201k stars (the most popular OSS coding agent); ~650k monthly users.

Pi vs. OpenCode, directly:

5. DeepSeek dsh

Thesis: "everything is a plugin." The model adapter, tool registry, session log, sandbox, skills, storage, the agent loop, scheduling and even the UI are all plugins. "There is no privileged core to patch: you extend dsh by mounting a plugin alongside the others, and registrations are effects that undo when your plugin unloads." The kernel (Cordis) only does plugin load/unload and dependency resolution — it carries no agent capability. Composition happens in configuration, not code: a running dsh is a tree of plugins composed at boot from ordered layers (profiles → bundles → patches). And "everything the model sees is logged": an append-only SessionEvent log is the single source of truth, with a runtime invariant asserting that anything reaching a model request is reconstructible from the log.

Notable details: subagents can be backed by Codex or Claude Code as external providers; run modes include PTC/Code Mode (the model writes a TypeScript program composing multi-step tool calls) and Minimal (persistent bash + str_replace_editor, for benchmarking models). No public benchmarks yet ⚠️.

6. Qwen Code (Alibaba)

Thesis: Claude Code parity, open-source and multi-protocol. A fork of Google Gemini CLI v0.8.2 that diverged into independent development: "If you know Claude Code, you already know Qwen Code — and then some." Multi-protocol (OpenAI, Anthropic, Gemini, Qwen APIs + Ollama/vLLM), IDE plugins, desktop, daemon, SDKs (TS/Python/Java), IM bots. It self-dogfoods: the agent uses its own models to file issues, submit PRs, review code and run tests.

Numbers. ~4,750 files / ~2,700 source .ts(x) files, 14 packages. Measured token savings: dynamic tool discovery ~46%; fork-subagent prompt-cache sharing "80%+". I/O hot path cut 110 → 10 syscalls per prompt (−91%). ⚠️ Many figures come from a third-party comparison report, not first-party.

7. Aider

Thesis: git-native, deterministic, local-first pair programming where the model thinks and the harness is a thin, reliable wrapper whose job is to keep edits reviewable and reversible.

The signature move: a repo map — a concise outline of the whole repo's key classes/functions with types and call signatures, built from the AST (tree-sitter) and ranked by PageRank-like relevance so the most relevant symbols fit the window. It's the main mechanism to "understand a large codebase" without RAG/vector DB. Every AI change is auto-committed with a Conventional-Commit message (generated by a cheap model); /undo is a git revert. Git IS the memory/rollback/audit. No MCP, no subagents, no cloud sandbox — deliberately.

Numbers. ~6.8M PyPI installs; ~15B tokens/week; badge "singularity": ~88% of its own new code written by Aider.

8. Cline / Roo Code

Thesis: a full autonomous agent inside the IDE (VS Code webview) with human-in-the-loop approval as the central trust model, and MCP as the universal extension point. Roo's bet was modes (specialized agent personas: Code / Architect / Ask / Debug / Custom) plus an Orchestrator mode that delegates to the others — "a team of agents, not one".

Notable: git-based checkpoints for rollback; Cline now also ships a headless CLI (for CI) and a Kanban app (parallel agents, each in its own git worktree). ⚠️ Roo Code's extension was shut down on 2026-05-15 (community fork: ZooCode).

9. Gemini CLI (Google)

Thesis: "the most direct path from your prompt to our model" — a terminal-first, free-tier agent that is effectively the reference OSS implementation of Google's own agent design (and a distribution channel for Gemini). Plan Mode (read-only) is the default approval mode — plan-then-execute first-class. Hierarchical GEMINI.md memory files, auto-memory, history compression, subagents the main agent "hires", OS-level sandboxing, and model routing with fallback. ⚠️ In sunset: free/Google One users migrate to Antigravity CLI on 2026-06-18.

10. Goose (Block → AAIF)

Thesis: a general-purpose, native, MCP-everything agent that is embeddable. An agent SDK + CLI where MCP extensions are the primary capability mechanism; governed by the Agentic AI Foundation.

11–12. The async cloud agents: Amp and Jules

The other pole of the field: agents that run without you. Sourcegraph Amp runs Orbs — async cloud agents, event-driven, multiplayer. Google Jules is an async cloud agent that produces a PR (a VM per task). Both bet that the unit of work is a delegated task, not a terminal session.

13. mini-SWE-agent

Radical minimalism as research baseline: a ~100-line Python agent with one tool (bash), model-agnostic via LiteLLM. It scores >74% on SWE-bench Verified and is used by Meta, NVIDIA, IBM, Stanford and Princeton. The field's punchline in one project: minimal harness + strong model ≈ maximalist harness + weak model.

14. dcode (LangChain "Deep Agents")

"Batteries-included but forkable", framework-native on LangGraph: planning + file memory + subagents, with the pitch "own your agent".

The design axes (synthesis)

flowchart LR
    subgraph POLES["The two philosophical poles (2024–2026)"]
        direction LR
        MIN["MINIMALISM<br/>'if I don't need it,<br/>it doesn't get built'"] --- MAX["MAXIMALISM<br/>multi-surface,<br/>batteries-included"]
    end
    MIN --> PI["Pi<br/>4 tools · minimal prompt · YOLO"]
    MIN --> MINI["mini-SWE-agent<br/>~100 lines · 1 tool (bash)"]
    MIN --> AIDER["Aider<br/>git = the harness · repo map"]
    MAX --> OC["OpenCode<br/>75+ providers · client/server"]
    MAX --> QWEN["Qwen Code<br/>parity + multi-protocol · 6 surfaces"]
    MAX --> GEM["Gemini CLI<br/>plan-mode default · extensions"]
    MIN -. negotiates .- MIDDLE["MIDDLE GROUND<br/>Claude Code · Codex · dsh · Cline/Roo"]
    MAX -. negotiates .- MIDDLE

Axis 1 — Minimalism vs. richness (the central axis). One pole: Pi (total subtraction, "if I don't need it, it doesn't get built"), mini-SWE-agent (100 lines), Aider (thin wrapper + git). The other: OpenCode (75+ providers, ~35 LSP servers, 5 agents), Gemini CLI, Qwen Code (total addition, multi-surface). The whole field negotiates somewhere between the two.

Axis 2 — Git-centric vs. MCP-centric. Aider/mini-SWE-agent/Pi bet on git + bash as the universal substrate (rollback, memory, isolation for free). Cline/OpenCode/Codex/dsh bet on MCP as the extension standard. They're not mutually exclusive — but the default substrate reveals the philosophy.

Axis 3 — Where does the agent live? TUI (Pi, Claude Code, Gemini CLI, OpenCode) vs. IDE (Cline/Roo) vs. async cloud (Jules, Amp) vs. embeddable SDK (Goose, dsh, Codex protocol). The async-cloud bet is the fastest-growing: delegated tasks, not terminal sessions.

Axis 4 — Sandboxing approaches. OS-level primitives (Codex: Landlock/Seatbelt; Gemini CLI; dsh: bwrap/Landlock/Seatbelt/ACL) vs. approval gates (Cline, Claude Code modes) vs. containers (OpenCode containers, mini-SWE-agent Docker/contree) vs. none + trust (Pi, Aider-via-git).

Axis 5 — Context management. Repo map / PageRank (Aider) vs. compaction pipelines (Claude Code 5-layer; Qwen multi-tier + reactive) vs. Context Epoch (OpenCode) vs. append-only log as single source of truth (dsh) vs. subagent context isolation (Claude Code, OpenCode).

Axis 6 — Human-in-the-loop as trust model. YOLO (Pi, mini-SWE-agent) → per-action approval (Cline) → policy modes (Claude Code 7 modes + ML classifier) → OS sandbox + approval (Codex) → async delegation with review gates (Jules, Amp).

Axis 7 — Distribution / business bet. OSS reference (Gemini CLI, Goose, mini-SWE-agent, Codex, Aider) → OSS as product funnel (OpenCode + gateway, Qwen + models, Cline SDK, dcode → LangSmith) → closed platform (Claude Code, Amp, Jules) → foundation-governed (Goose/AAIF).

In one line each

• Minimal, git-native, local: Aider, mini-SWE-agent, Pi.
• Rich terminal reference (Google): Gemini CLI.
• IDE + MCP + modes: Cline / Roo Code.
• Native, MCP-everything, embeddable, general: Goose.
• Framework-native, "own your agent", batteries-included: dcode / Deep Agents.
• Async cloud agent → PR / remote Orbs: Jules, Amp.
• Maximalist multi-surface open: OpenCode.
• Radical composition, "everything is a plugin": DeepSeek dsh.
• Claude Code parity, open + multi-protocol: Qwen Code.
• Open protocol-first harness + OS sandbox: Codex.
• Reference minimal thin harness + MCP/skills: Claude Code.

The through-line (2024 → 2026)

The industry moved from "build the smartest scaffold" to "the model is the agent; the harness must be thin, safe, and replaceable" (mini-SWE-agent, Aider, Pi) — while simultaneously competing to offer work to async, sandboxed, remote agents that run without you (Jules, Amp, Cline-Kanban). MCP became the de-facto capability standard; git / remote VMs became the competing answers to security and rollback. The two philosophical poles are Pi (total subtraction) and OpenCode / Gemini CLI (total addition) — and the entire field is, to some degree, negotiating between the two.

Compiled 2026-08-24. Caveats: (1) dsh launch dates inferred from repo creation. (2) Several Qwen Code figures are tertiary. (3) The Claude Code leak (512K lines) and valuations come from secondary reporting. (4) Gemini CLI/Cline-Roo status reflects 2026 events (sunset/shutdown) that may change. (5) Where no first-party benchmark exists, it's marked as a gap.