The Big-Tech Open Agent Harness Showdown: Codex, DeepSeek dsh, Grok Build and What They're Really Playing For

Anyone who has shipped an LLM agent eventually hits the same wall: the model is smart, but everything wrapped around it — how context gets assembled, how tools are invoked, how failures recover, how boundaries are enforced — is what actually decides outcomes. The industry has a name for that wrapper: the agent harness. In August 2026, this core component — previously locked inside each vendor's product — suddenly became open-source battlefield territory. On August 13, DeepSeek released Harness (dsh), which collected 181,149 stars in nine days. On August 19, OpenAI published "Codex as a platform," explicitly placing the Codex agent loop, app-server, and SDK as a platform layer. Add Grok Build (open-sourced in mid-July), the older Gemini CLI, and its fork Qwen Code, and the board is fully set.

This is not coincidence; it is a sequence of moves with visible order. This article tears down each of the five open harnesses, compares their architectural bets, and answers a more practical question: if you are picking one to use or to learn from in late 2026, which one.

The Board: Five Moves in Seven Months

The sequence itself is information:

Date	Vendor	Move	License	Stars (GitHub API, 2026-08-22)
2025-06-25	Google	Gemini CLI open-source from day one	Apache-2.0	106,607
2026-07-15	xAI	Grok Build open-sourced (Rust TUI)	Apache-2.0	25,850
2026-08-13	DeepSeek	Harness (dsh) developer preview	MIT	181,149
2026-08-19	OpenAI	Codex as a platform (harness components fully opened)	Apache-2.0	111,244
earlier, ongoing	Alibaba	Qwen Code (Gemini CLI fork)	Apache-2.0	27,274

Three details worth pausing on:

First, Grok Build's open-sourcing was coerced. On July 12, 2026, a wire-level analysis hit 539 points on HN, showing that the Grok Build CLI uploads the user's entire git repository to a Google Cloud bucket (International Cyber Digest). Seventy-two hours later, xAI open-sourced Grok Build under Apache-2.0; the HN thread reached 590 points with 644 comments. From telemetry scandal to open source in three days — openness has become the standard answer to a trust crisis, cheaper than a PR statement and independently verifiable.

Second, DeepSeek's 181k stars measure attention, not adoption. The dsh repository was created on 2026-08-13 and reached 181,149 stars by August 22 — roughly twenty thousand per day, overtaking what the openai/codex repository accumulated over 16 months (111,244). But stars are not production adoption; dsh's own README warns in caps: "THERE WILL BE COMPATIBILITY-BREAKING CHANGES."

Third, OpenAI drew the open-source boundary precisely. Per the official open-source components list (verified 2026-08): open are the Codex CLI, SDK, App Server (codex-rs/app-server), Codex Security CLI and its TS SDK, Skills (openai/skills), Plugins (openai/plugins), and the codex-universal cloud environment. Closed are the IDE extension and Codex cloud. In other words, the razor (the agent loop) is open; the blades (model access and managed services) still cost money — a structure we will unpack below.

OpenAI: The Harness as a Platform

The August 19 pair — Codex as a platform and Unlocking the Codex harness — together makes three arguments.

Argument one: the harness has a price tag now. On ARC-AGI-3, harness-layer optimizations alone (retained reasoning + context compaction) lifted GPT-5.6 Sol from 13.3% to 38.3% while cutting output tokens sixfold. Same model, new shell, nearly triple the score — the hardest public numbers yet for "harness differentiation." It also explains why a vendor would open-source it: as models commoditize, measurable performance differences migrate into the harness, and the harness monetizes through distribution scale.

Argument two: a three-tier integration ladder.

codex exec       scripts / CI / one-off background jobs, structured output
     ↓
Codex SDK        application code starting/resuming/streaming Codex tasks
     ↓
app-server       product-grade embedding: a documented JSON-RPC protocol
                 on a local long-lived process — threads, turns, events,
                 approval requests across the full lifecycle

The app-server tier is the interesting one: not a library but a documented client protocol. Your application creates threads, starts turns, receives event streams, and handles approval requests; Codex owns the agent loop and sandboxed execution. OpenAI also shipped a reference app called Relay — a fictional shipment-operations dashboard where the agent reads data through application-owned MCP tools and every consequential write requires human approval. The intent is blunt: don't build a Codex App with a different logo; embed the agent in the workbench your domain already uses.

Argument three: enterprise receipts. Cisco (cloud management tooling) and Thrive Holdings are building custom agents on the Codex harness; a tax-preparation pilot processed 7,000 returns and cut overall preparation time by about a third (OSFY, 2026-08-21).

One narrative the press oversimplified deserves correction: "OpenAI open-sourced Codex" has been true since April 2025, when the openai/codex repository appeared under Apache-2.0. The genuinely new thing in August 2026 is the opening of app-server and the SDK plus the platform positioning — turning what was an internal protocol for their own IDE extension into a publicly promised integration surface. If you have worked with Codex's Windows sandbox, you will notice the continuity: controlled execution environments, explicit approval boundaries.

DeepSeek dsh: "Everything Is a Plugin," Taken to Its Logical End

Where OpenAI plays an ecosystem game, dsh makes a purely architectural statement. Its README contains one core declaration: everything is a plugin — the model adapter, the tool registry, the session log, and the agent loop itself.

The engineering consequences are written in its architecture.md, and three layers repay close reading:

No privileged core. dsh sits on the Cordis kernel (design described in the paper A Programming Paradigm for Spatiotemporal Composability). Plugins contribute services, typed events, and reversible effects to a shared context; to extend dsh you mount your plugin beside the others rather than patching a core. When a plugin unloads, everything it registered unwinds automatically as effects. Runtime shape is decided by profiles (named compositions) + bundles (distribution format) + layered patches; dsh --profile web --dump-config prints the full plugin tree your machine boots, and any printed row can be replaced by your own patch.

Model-visible means logged. The session log is an append-only stream of SessionEvents: system prompts, reasoning, tool calls and results, subagent scheduling, every context injection — all persisted, with a runtime invariant that anything reaching a model request must be reconstructable from the log. Resume, fork, search, and replay all operate on the same event stream. For anyone building agent observability, this single invariant is worth more than any feature list.

Capability seams. Filesystem and subprocess providers share one execution world, so pointing both at a remote sandbox migrates Bash, PTY, and LSP tools wholesale — no provider forks. This design directly answers "how does a harness move from laptop to cloud."

Add four runtime modes — Standard (full toolkit), Code (the model writes a TypeScript program orchestrating multi-step tool calls), Minimal (shell + file editor only, built for benchmarking), Creator (runtime inspection + plugin experiments + composing new presets) — and dsh reveals itself as a research platform, not just another terminal coding agent.

The costs are printed on the label: developer preview, with breaking changes explicitly promised, and going deep requires learning Cordis, a composability framework built by the same team. How much of the nine-day 181k-star heat settles into stable production usage is the open question to track through late 2026.

Grok Build: Rust Heavy Cavalry, Openness for Trust

xai-org/grok-build is the only Rust implementation of the five (~99.6% Rust) and the only fullscreen TUI: mouse-interactive, long-task management, web search, in three modes — interactive, headless (CI), and ACP protocol (editor embedding).

Its repository is unusually honest about what it is: the README states this tree is periodically synced from the SpaceXAI monorepo, with a root-level SOURCE_REV file recording the monorepo commit it mirrors. The toolset is the classic seven (read, edit, apply-patch, glob, grep, list-dir, shell) over a plan-then-act loop; the extension surface is skills, plugins, hooks, and MCP.

Its position is also unique: the motive was repairing trust, not attacking an ecosystem. Telemetry exposé July 12, open source July 15, and a sizable fraction of those 644 HN comments debating whether open-sourcing actually proves anything. For users the outcome is decent — a 25,850-star (2026-08-22), Apache-2.0, self-auditable Rust harness — but understand that its iteration cadence follows xAI's internal monorepo, not community PRs.

Gemini CLI and Qwen Code: The First Mover and Its Fork

Gemini CLI is where the wave started: open-sourced on launch day, June 25, 2025, 1,428 points on HN (among the month's highest), shipping with a free tier (1,000 requests/day on the 601 model at launch). Fourteen months later it holds 106,607 stars and remains the reference-grade open harness — TypeScript, Apache-2.0, a multimodal toolchain.

Qwen Code's story is more interesting: a direct fork of Gemini CLI (Apache-2.0 inherited) wired to free access to Qwen-family models, positioned in a January 2026 post as an agent that "thinks like a programmer." 27,274 stars (2026-08-22). Borrowed skeleton + home-team model access gives it penetration in the Chinese developer community far above what its star count suggests. It demonstrates a secondary effect of open harnesses: the harness can be forked; the model on-ramp is the real stickiness.

ByteDance's Trae Agent is the control group: MIT, Python, modular architecture, multi-LLM support, a proper technical report (arXiv:2507.23370), 12,046 stars — and a last push dated 2026-02-05, stalled for roughly six months since. Open source is not a launch ceremony but a maintenance commitment; this is the board's plainest counter-example.

The Comparison: What Actually Differs

Why these dimensions: evaluating a harness comes down to five questions — can you ship commercially (license), how the skeleton is built (architecture), how third-party capability grows (extension mechanism), how it enters your product (integration), and whether you dare run it in production (maturity). Stars are listed only as an attention proxy.

Dimension	Codex (OpenAI)	dsh (DeepSeek)	Grok Build	Gemini CLI	Qwen Code
License	Apache-2.0	MIT (most permissive)	Apache-2.0	Apache-2.0	Apache-2.0
Language	Rust	TypeScript	Rust	TypeScript	TypeScript
Architecture	platform core + 3-tier integration	everything-is-a-plugin (Cordis)	monorepo-mirror TUI	classic agent loop	Gemini CLI fork
Extension	MCP + Skills + Plugins	plugins (incl. the loop itself)	skills/plugins/hooks/MCP	MCP + built-ins	MCP + built-ins
Product embedding	app-server (JSON-RPC protocol)	Web UI + headless	ACP protocol	limited API surface	limited API surface
Maturity	production-proven (Cisco et al.)	developer preview	5 weeks open	14 months	13 months
Model binding	OpenAI models	any (swap adapter plugin)	xAI models	Gemini	Qwen (free on-ramp)

Cross-referencing the five dimensions forces one conclusion: "open harness" is not a homogeneous category. Codex and dsh represent two orthogonal bets —

• Codex bets on the ecosystem: keep the core factory-hardened (sandbox, approvals, event stream integrated), put openness at the protocol layer (app-server) and extension layer (Skills/Plugins), wagering that more integrations means more model consumption.
• dsh bets on the architecture: pushes composability to the limit — the loop itself is replaceable — wagering that long-term, recomposable systems win; the near-term cost is zero stability promises.

For completeness, the closed players on the same board: Anthropic's Claude Code remains a closed binary (since 2026 shipped as a ~100MB native build, per community reverse-engineering), with the MIT-licensed Claude Agent SDK (7,950 stars, 2026-08-22) as its open face — similar in shape to Codex's play, except the loop itself stays closed. Meta's Muse Code (beta, 2026-08-05) is fully closed, trading a data-for-discount contributor tier (roughly 1/12 the standard price) for training data. The players who refuse to open-source are running the old playbook: data or model on-ramps.

The New Lock-In Layer: Plugin Ecosystems

One structural shift that the star counts easily bury: the center of vendor competition is moving from "my model is better" to "my extension format becomes the standard."

dsh has its dsh-plugin GitHub topic and a community plugin directory already; OpenAI simultaneously open-sourced openai/skills and openai/plugins, making skills and plugins the shared extension unit across ChatGPT and Codex; MCP is the greatest common divisor all five support. Analogous to the App Store era, the agent-era equivalent of the platform tax is not the harness itself but plugin distribution and format standards. Open-sourcing the harness makes this layer's contest look harmless — but whoever's format third-party developers treat as the default target holds the ticket to the next decade. That is how every free-razor story ends.

Direct recommendations, in three tiers:

1. Embedding an agent in a product (ops dashboards, security triage, internal tools): take the Codex app-server route. Best production evidence, documented protocol, Relay as a modifiable starting point.
2. Researching or building harnesses, or benchmarking: read dsh. Its architecture docs are the most complete open course among the five; the "model-visible means logged" invariant and the capability-seams design deserve to be copied into any agent project.
3. Getting a terminal agent fast on a budget: Qwen Code's free model on-ramp plus Gemini CLI's mature skeleton — lowest learning cost.

My scores (out of 10, with reasons):

Project	Composability	Out-of-box	Production maturity	Ecosystem	Docs
Codex	7	9	9	9	8
dsh	10	6	4	8	9
Grok Build	6	7	6	6	6
Gemini CLI	6	8	8	8	8
Qwen Code	6	8	7	7	7

dsh earns full marks for composability without controversy, but its production-maturity 4 is what its own README promises; Codex's weakness is precisely dsh's strength — the loop core is not replaceable. That asymmetry is the tension of harness competition in 2026. We saw the same trade-off when tearing down Prime Agent's harness design: no vendor has yet scored full marks simultaneously on loop-engineering discipline and system plasticity.

Conclusion

After five moves in seven months, three judgments hold up:

First, the harness has completed its identity change from engineering detail to strategic asset. The 13.3%-to-38.3% gap on ARC-AGI-3 quantifies it, and vendors willingly open-source it despite the optics of "helping competitors" precisely because its value realization depends on distribution scale.

Second, the commercial structure of an open harness is razors and blades. OpenAI's component list draws the line most explicitly: loop, protocol, SDK open; model access and cloud services paid. Not seeing this line clearly when selecting a stack means tying your architecture to someone else's blade business.

Third, the real contest lies ahead — plugin and extension format standards. The best reason to pick a harness today is not its feature list but whether third parties will still be writing for its extension format in three years. dsh's Cordis and OpenAI's Skills/Plugins are the two most ambitious candidates; Gemini CLI's MCP compatibility is the floor.

As for the question the star counts keep reigniting — whether dsh will repeat DeepSeek's model-release-style industry shock — my view: architecturally it is the only radical answer among the five, but a harness is not a model; there is no single-point performance miracle, only ecosystem compounding. Give it two quarters: watch how many breaking-change promises get honored and what grows in the dsh-plugin ecosystem. That is far more informative than the star curve.

References

1. OpenAI — Codex as a platform: build on the open agent harness (2026-08-19)
2. OpenAI — Unlocking the Codex harness: how we built the App Server (2026-08-19)
3. OpenAI — Codex Open-Source Components (verified 2026-08)
4. DeepSeek — Harness developer preview: Everything is a plugin (2026-08-13)
5. DeepSeek — deepseek-harness README and Architecture docs (verified 2026-08-22)
6. xAI — Grok Build repository (open-sourced 2026-07-15)
7. Hacker News — Grok Build is open source (590 pts / 644 comments) and the wire-level analysis thread (539 pts) (2026-07)
8. International Cyber Digest — xAI's Grok Build CLI Uploads Git Repositories to a Google Cloud Bucket (2026-07-13)
9. Google — Introducing Gemini CLI (2025-06-25)
10. QwenLM — qwen-code repository and Announcing Qwen Code (2026-01-30)
11. ByteDance — trae-agent repository (technical report arXiv:2507.23370)
12. OSFY — OpenAI Open Sources Codex Harness Framework (2026-08-21)
13. frr.dev — Claude Code Native Build: 100MB Binary (2026)
14. Anthropic — claude-agent-sdk-python (MIT, 7,950 stars, 2026-08-22)
15. GitHub API star/fork data — openai/codex, deepseek-ai/deepseek-harness, google-gemini/gemini-cli, QwenLM/qwen-code, xai-org/grok-build, bytedance/trae-agent (snapshot 2026-08-22)