The H2 2026 Harness War: Eight Frameworks Rewriting, Three Model Makers Entering, 110+ CLIs — How to Make Sense of It

🌏 中文版

August 2026 has too many things happening at once.

Independent frameworks are rewriting:

• OMP 2 goes from Pi fork to fully independent Rust codebase, ~41 crates
• Pi v2 promotes AgentHarness v2 API to stable, swaps to CBOR + Unix sockets underneath
• Opencode 2 replaces Bun with Node, Tauri with Electron, rebuilds the entire API
• DeepSeek Harness launches from scratch with a Cordis plugin kernel, 184K stars in 9 days
• Amp ships Orbs (ephemeral VMs), event-driven architecture
• Claude Code continues iterating with Extension API, hooks, and MCP integration

Model makers are building agents directly:

• Antigravity CLI: Google replaces Gemini CLI with a Go rewrite, closed source, 121 commands
• Muse Code: Meta's first coding agent, Muse Spark 1.2 model co-trained with the harness
• Grok Build: xAI's Rust agent, 845K LOC, Arena Mode, open-sourced three days after a privacy incident broke

Each already has its own in-depth article. This piece won't repeat individual analyses — it puts them side by side to see what each is betting on, what each gave up, and what assumptions each makes about the future of harness design.

The Numbers

As of 2026-08-22:

Eleven frameworks with architecture-level changes. Six closed-source commercial, five open-source. Five use TypeScript, three use Rust, one uses Go, two undisclosed. Backed by eleven different organizations — three of which are model makers.

Four Architectural Approaches

These frameworks fall into four distinct approaches — not a feature comparison, but different answers to "what should a harness look like."

Approach One: Rewrite the Runtime to Depend on Nothing External

Representative: OMP 2

OMP 2's core claim: a coding agent shouldn't depend on what's installed on the user's machine. It shouldn't shell out to rg, shouldn't depend on the system's bash, shouldn't assume node is on PATH. The solution: compile everything into a single binary — custom bash engine, in-process coreutils, tree-sitter AST, even embedded CPython 3.14t.

Grok Build also uses Rust, but with completely different motivations. OMP 2's ~41 crates are a ground-up modular architecture; Grok Build's 845K lines are a corporate monorepo slice that doesn't accept external contributions. Same language choice, two entirely different architectural intents.

The cost of this approach is complexity. The barrier to community participation in Rust is a tier higher than TypeScript. But OMP 2 solves a problem no other framework has addressed head-on: cross-platform consistency. The same binary behaves identically on macOS, Linux, and Windows.

Approach Two: Keep the Core Small, Upgrade Foundational Quality

Representatives: Pi v2, Claude Code

Pi v2 and Claude Code take a similar path: no major changes to core functionality, but continuous improvement to foundational quality. Pi swaps sessions from in-memory objects to a lane-based durable model, changes the wire protocol from JSON to CBOR — but still has 4 tools, still explicitly refuses MCP and sub-agents in the README.

Claude Code follows the same pattern: hooks, Extension API, MCP integration are all incremental expansions; the core agent loop and tool system haven't undergone destructive rewrites.

This approach assumes: the harness core structure is already right — what's needed is making the foundation solid, not reinventing it. The upside is stability, predictability, and no relearning required. The cost: if the core assumption is wrong, correction is expensive — because the entire ecosystem is already built on the existing structure.

Approach Three: The Harness Itself Should Be Composable

Representatives: dsh, Opencode 2 (partially), Amp (partially)

DeepSeek Harness's Cordis plugin kernel is this approach's most radical expression: model adapters, tools, agent loop, UI are all plugins, all swappable. You're not just adding features on top of a harness — you can replace every layer of the harness itself.

Opencode 2's persistent backend + HTTP API + SDK carries a similar spirit — it's not just an agent, it lets you use the agent as a building block embedded in your own system. Amp's Orbs are another variant: abstracting the execution environment itself into ephemeral VMs, letting agents run in isolation — fail and discard.

This approach assumes: nobody knows what the harness should ultimately look like, so every layer should be experimentable. The upside is maximum flexibility; the cost is learning curve and debugging difficulty.

Approach Four: Model Maker Builds the Agent

Representatives: Antigravity CLI, Muse Code, Grok Build

One of H2 2026's clearest trends: model makers are no longer just providing APIs — they're building complete coding agents.

Antigravity CLI is Google's closed-source Go rewrite, replacing the Apache 2.0 Gemini CLI. It's not just a model wrapper — 121 commands, multi-agent orchestration, native OS sandbox. This is a complete development environment.

Muse Code co-trains model and harness — Muse Spark 1.2 isn't a model trained first with an agent loop fitted after; model behavior and agent goals are optimized as one unit. Persistent sub-agents + worktree isolation are also uncommon designs.

Grok Build has 8 parallel sub-agents and Arena Mode (competing agents, pick the best). The highest concurrency among all current frameworks.

Codex CLI was rewritten from TypeScript to Rust (mid-2025), 116K stars, also on the model-maker-builds-the-agent path.

This approach assumes: model and harness should be vertically integrated. Model makers own the model, own the distribution channel, own the user relationship — if the harness is competitive advantage, why let a third party build it?

The cost: users get locked into a single model ecosystem. Antigravity CLI defaults to Gemini only (though it supports Claude and GPT), Muse Code defaults to Muse Spark only, Grok Build defaults to Grok only. Independent frameworks like Pi, dsh, and Opencode natively support multiple models; model makers' agents natively favor their own.

One Shared Direction: Session Durability

Regardless of approach, every framework currently being rewritten is doing the same thing: making sessions outlive their processes.

• OMP 2: content-addressed blob storage + append-only session transcripts
• Pi v2: lane-based v4 Session model with durable operations
• Opencode 2: persistent backend service — close the UI, reopen, session persists
• dsh: session storage is a Cordis plugin, swappable with different durability backends
• Muse Code: append-only event log, muse resume recovers from crashes
• Grok Build: each sub-agent in its own git worktree, plan/search/build pipeline

This isn't coincidence. When agent sessions evolve from "run 5 minutes to fix a bug" to "run 5 hours to build a feature," session durability becomes a requirement. The model is just a component — the harness is the system — and a system can't lose all state from a single process interruption.

A Trust Crisis

July–August 2026 saw three trust incidents in quick succession, each pointing to risks unique to coding agents:

Grok Build silently uploaded entire repos. On July 12, 2026, security researcher Cereblab published wire-level captures proving Grok Build was uploading entire Git repositories (including .env, SSH keys, commit history) to Google Cloud Storage without user knowledge. Upload traffic was 27,800 times conversation traffic. xAI open-sourced three days later, but the exfiltration code remains in the binary, disabled only by a server-side flag.

Muse Code's Contributor pricing. Meta bundles API pricing with training rights: Standard plan at $1.25/$4.25/M tokens, Contributor at $0.10/$0.20 — 20x cheaper, but your code enters Meta's training pipeline. No granular opt-out, all-or-nothing.

Antigravity CLI went from open to closed source. Google replaced its 100K-star Apache 2.0 project Gemini CLI with the closed-source Antigravity CLI, giving only a 28-day transition. Simultaneously, the free tier was cut from ~1,000 to ~20 requests/day — a 98% reduction.

These aren't isolated incidents. They point to a structural issue: coding agents have deeper access than any previous development tool. They can read the entire codebase, view Git history, and touch .env and SSH keys. This trust surface is fundamentally different from a web app or IDE plugin.

Open source is the baseline for trust, but not a sufficient condition. Grok Build was open-sourced and the exfiltration code was still in it. The real question is: are you trusting the code, or the organization's policy decisions?

110+ CLIs Everywhere

The discussion above covers frameworks with architecture-level changes. But the August 2026 coding agent CLI landscape goes far beyond — the total count exceeds 110.

Tier 1: Model-maker official CLIs. Claude Code, Antigravity CLI, Muse Code, Grok Build, Codex CLI, Kimi Code CLI. Model makers building the harness themselves, bundling their own model, using distribution channels to push adoption.

Tier 2: VC-backed independent tools. Pi, Opencode, dsh, Amp, Cline, Kiro, Devin. Company-backed, with a business model (or searching for one), mostly multi-model.

Tier 3: Community rewrites and forks. Claw Code (Claude Code Rust clean-room rewrite, 172K+ stars), OpenClaw (387K stars), Hermes Agent (235K stars), OMP. Impressive star counts, but maintenance patterns and quality vary widely — some are active community projects, others are "agent-managed museum exhibits" (high stars but lacking sustained human maintenance).

Tier 4: Small and niche tools. 100+ CLIs with under 5K stars, each solving specific problems — language-specific agents, IDE integrations, workflow automations. Most won't survive long-term, but a few may become the next Pi.

The significance of this number isn't "which should you try" — it's that demand for coding agents is real. 110+ tools existing simultaneously shows strong market pull. But consolidation hasn't happened yet.

Ecosystem Fragmentation and Crossover

These frameworks aren't in pure competition.

dsh can use Claude Code and Codex as sub-agents. It's not competing on the same layer — it's coordinating from above. A real deployment might look like: Claude Code stays in the editor, dsh runs on a server dispatching tasks. Kiro's Crew autonomous orchestrator serves a similar role.

Opencode 2 reads .claude/skills/. This means switching from Claude Code to Opencode 2 doesn't require rewriting your skills. Skills are becoming cross-tool portable assets.

Cline 2.0 extracted its SDK. IDEs can embed any agent, not just Cline's own. This decouples "where the harness runs" from "which agent you use."

OMP 2 and Pi will not reconverge. OMP 2 is no longer a Pi fork — it's a fully independent Rust codebase. The two projects' technical directions are completely different, and users must choose one or the other.

Model makers' agents don't interoperate. Antigravity CLI won't use Claude, Muse Code won't use Gemini, Grok Build won't use GPT (unless through OpenRouter). Model makers' agents are inherently walled gardens. Independent frameworks (Pi, dsh, Opencode) are inherently open.

The organization behind determines survival. Earendil, Anomaly, Stencil Labs, DeepSeek, Google, Meta, xAI, Sourcegraph, OpenAI, Cline — ten different companies, ten different commercial pressures. MIT / Apache 2.0 licensing guarantees code freedom but not maintenance continuity.

How to Choose

The decision isn't "which is best" — it's "what do you need."

What matters most to you?
│
├─ Stability and ecosystem → Claude Code
│   Closed source, Anthropic-backed, largest user base
│
├─ Readability and minimalism → Pi v2
│   4 tools, entire codebase readable, MIT
│
├─ Multi-session parallelism and SDK → Opencode 2 (beta)
│   Persistent backend, HTTP API, cross-tool skills
│
├─ Cross-platform consistency → OMP 2 (pre-release)
│   Full Rust, single binary, no system-tool dependencies
│
├─ Custom agent shapes → dsh (dev preview)
│   Cordis plugin kernel, everything swappable, Web UI
│
├─ Highest parallelism → Grok Build (public beta)
│   8 parallel sub-agents, Arena Mode, mind the privacy risks
│
├─ Google ecosystem integration → Antigravity CLI
│   Closed source, Gemini-first, 121 commands
│
└─ Lowest cost (accepting training-rights trade) → Muse Code (early beta)
    Contributor plan 20x discount, quality still catching up

If you need production use right now, choose Claude Code or Pi v2 — both are stable, just in different directions (full-featured vs. minimal).

If you're willing to take beta / pre-release risk, pick the specific capability you need most — multi-session (Opencode 2), full Rust (OMP 2), everything-is-a-plugin (dsh).

If you're in a model maker's ecosystem, that maker's agent is the natural starting point — but be clear about what you're accepting (closed source, single-model bias, potential privacy risks).

What to Watch Next

From the perspective of harness evolution, H2 2026 is a divergence period for harness methodology. Previously, everyone was on the same path — letting models use tools, adding context, building safety checks. Now the path forks:

• Whether to build the entire runtime yourself (OMP 2)
• Whether to make every harness layer swappable (dsh)
• Whether to turn the agent into a programmable service (Opencode 2)
• Whether to upgrade the foundation without changing positioning (Pi v2)
• Whether model makers should vertically integrate (Antigravity, Muse Code, Grok Build)

Beyond the approach debate, three structural questions will surface in the next six months:

Trust standards. The Grok Build privacy incident proved "open source" doesn't equal "safe." What trust mechanisms do coding agents need? Auditing, sandboxing, traffic monitoring, data retention policies — there's no industry consensus yet.

Consolidation pressure. 110+ CLIs can't all survive. Which get acquired, which stop maintenance, which find a niche — the consolidation period may begin in H1 2027.

Skill portability. .claude/skills/ is already read by multiple frameworks. If the skill format becomes a de facto standard, switching costs between frameworks drop significantly — this works against model makers' walled-garden strategies.

These approaches won't produce clear winners immediately. What matters isn't who has the most stars in August 2026, but which approach produces the most reliable production deployments by mid-2027.

Stars measure attention, not quality. A framework with 184,000 stars and one with 26,000 may end up with the latter proving more reliable — we don't know yet.

The one thing that's certain: harness design matters more than the model itself. Eight frameworks rewriting simultaneously and three model makers entering at once shows every participant in this space agrees on that premise — the disagreement is only about "then how should the harness be built" and "who should build it."

References

• Internal: OMP 2: From Pi Fork to Full Rust Rewrite (in Chinese)
• Internal: Pi v2: AgentHarness API Goes Stable (in Chinese)
• Internal: Opencode 2: Bun to Node, Tauri to Electron (in Chinese)
• Internal: DeepSeek Harness (dsh): Everything is a Plugin (in Chinese)
• Internal: Antigravity CLI: Google Replaces Gemini CLI with Go Rewrite (in Chinese)
• Internal: Muse Code: Meta's First Coding Agent (in Chinese)
• Internal: Grok Build: xAI's Privacy Incident (in Chinese)
• Internal: Amp: Sourcegraph's Frontier Agent (in Chinese)
• Internal: Codex CLI: OpenAI's Coding Agent (in Chinese)
• Internal: Claw Code: Rust Reimplementation of Claude Code (in Chinese)
• Internal: Hermes Agent: Terminal Backends (in Chinese)
• Internal: omp v1: The Batteries-Included Fork (in Chinese)
• Internal: Pi: A Minimalist Coding Harness (in Chinese)
• Internal: Opencode: Open-Source AI Terminal Coding Agent (in Chinese)
• Internal: Gemini CLI: Google's Terminal Agent (in Chinese)
• Internal: The model is just a component — the harness is the system (in Chinese)
• Internal: From Prompt to Harness: Three Evolutions of AI Engineering (in Chinese)
• OMP 2 (GitHub)
• Pi (GitHub)
• Opencode (GitHub)
• DeepSeek Harness (GitHub)
• Grok Build (GitHub)
• Codex CLI (GitHub)
• Cereblab privacy research report