Shared Harness, Differentiated Surfaces

Sources#

• Codex from 0 to 10M Users: Building ChatGPT Work - Akshay Nathan, OpenAI
• Coding Agents and Technical Debt

Summary#

The architectural question every vendor building both a coding agent and a knowledge-work agent has to answer: one harness with different front ends, or two products? OpenAI answered one. Akshay Nathan (OpenAI, leads product engineering for the productivity team) states it flatly on Latent Space, July 2026:

"So the harness is the same. The harness is shared… On the UX side, there's opinionated takes that we have when you're in Codex mode… and some stuff around the sandbox, but the underlying harness and capabilities should be the same."

Anthropic answered two: Claude Code for work whose output is code, Cowork for work whose output isn't, with Cat Wu's rule stated as a user-facing decision procedure ("if the output is anything that's not code, I'll use Cowork for it").

Evidence note. practitioner-opinion — a product executive describing his own product on a podcast, with no measurements. Every adoption and quality figure below is attributed inline and should be read as vendor-claim embedded in a practitioner-opinion source.

What actually differs between the two surfaces#

Nathan names three differentiators, and only three:

Axis	Codex mode	ChatGPT Work mode
Git state	The "dynamic island" assumes you're in a git repo; file edits and diffs are surfaced	Git state hidden; the same retirement-calculator task shows the artifact, not the diffs
Chain-of-thought display	Diff-forward — "so that you get exposed to the diffs out of the box"	Abstracted away
Sandboxing defaults	Developer-appropriate defaults	Different defaults "on the safety side… making sure that we have the right defaults in one state versus the other"

Everything else — plugins, computer use, artifacts, memory, sub-agents, scheduled tasks, the persistent computer environment — is shared, and Nathan states the invariant as a product principle: "everything that you can do in the Codex portion of the product on desktop, you can do in ChatGPT Work and vice versa." Plugins in particular are "unified across this product and ChatGPT and the cloud."

The convergence worth noticing: this is Cherny's residue#

The three differentiators are permissions/sandboxing, and UI. That list is almost verbatim the answer Boris Cherny gives, from the other lab, when asked what is left of the Claude Code harness after Anthropic deleted >80% of its system prompt:

"If you look at the code that's in the Claude Code harness today, almost all of it is about safety and permissions and static analysis and there's a bunch of UI code."

Two vendors, arriving from opposite directions — Anthropic by ablating a harness down to its residue, OpenAI by forking one surface into two and finding out what had to differ — land on the same short list. That is independent corroboration for Harness Shrinkage as Models Improve of a kind the wiki did not previously have: the shrinkage thesis is Anthropic-sourced almost end to end, and this is a non-Anthropic account whose product architecture only makes sense if the thesis is roughly right. If capability still lived in per-surface prompt scaffolding, "same harness, different UX" would not be shippable.

A second, smaller data point in the same direction: routing between the classic ChatGPT harness and Work mode is a model decision, not harness logic. Asked whether it's a router, Nathan says "this is the decision that the model is making… it sees that you're trying to do something that would be better served in Work mode." A dispatch rule that would have been scaffolding is behavior.

The divergence: split by output type, or by nothing at all#

Nathan explicitly considered and rejected the Anthropic shape:

"One direction we could have gone with this is keeping the experiences completely separate… different apps or even in the same app, completely different experiences."

His reason is not technical, it is a bet about users: roles are blurring, so any product boundary drawn on "who you are" is drawn on sand. "Trying to draw a hard boundary based on who you are is gonna be tough. And we should enable users to choose, but we shouldn't box them in." Anthropic's boundary is drawn on what the output is rather than who you are, which dodges part of that objection — but it still asks the user to choose a surface before they know what the task will produce, which is precisely the choice Nathan's principle refuses to make them make.

Neither side has evidence. Weight this as two product bets, not a settled question — and note the dates: the wiki's Cowork material is from May 2026 and Nathan's from July 2026, so some of the gap may be lag rather than philosophy. What is not lag is the stated principle: Nathan's "we don't want a user to get stuck in a tab or an experience where they don't get the power of the product" is a commitment, not a roadmap item.

The one-harness bet also has a corollary Anthropic's split doesn't need: the developer surface has to survive the merge as a brand rather than a codebase. Nathan is emphatic that Codex stays — "developers have been a core market for us for so long… this doesn't take away from that at all" — and argues the merge raises Codex's ceiling: "now you can move seamlessly between writing a diff to creating an artifact or doing a search."

The cost of the merge: an abstraction tax on power users#

A shared harness serving a mass-market audience creates a pressure the two-product shape doesn't: every affordance a developer wants is a knob a knowledge worker has to not-see. The transcript is unusually candid about where that tax is currently being paid.

• Sub-agent visibility. Sub-agent transcripts are hidden by default. Nathan calls it a deliberate trade-off: "there's another iteration of this where you can see exactly what they're doing, which could converge on overwhelming with information. So this is the deliberate trade-off that we made for now." Compare Claude Code, which exposes sub-agents as user-authored files in .claude/agents/ with per-agent model selection — the same primitive, configured rather than abstracted, because the audience is different.
• Too many model options. "There's 32 options." Nathan: "One could argue that there might be too many right now, and we're working on simplifying it."
• Ultra moved behind advanced settings. Post-launch, OpenAI made Ultra (the multi-agent mode) opt-in and buried it, "'cause that's who it is for. It's for power users who understand what's gonna happen because it also, depending on your use case, can use more of your limits."

The general shape: capability is shared, legibility is rationed per surface. That is the same model-facing/human-facing asymmetry HTML as the New Markdown identifies — except here the human-facing harness isn't just growing, it is being differentially dosed by audience, which is a harder design problem than either shrinking or growing it.

A third vendor, and the same architecture sold as a buy recommendation#

OpenHands' July 2026 GitHub analysis (Coding Agents and Technical Debt, case-study) reaches the same architecture from the repository side rather than the product side, and finds it is not a two-vendor pattern but the default shape of the category: "'A coding agent' sounds like one program. In practice, it is a platform." OpenHands ships the split as four public repos — app/server 404K lines, Software Agent SDK (the runtime) 333K, Agent Canvas UI 246K, CLI 67K — and reports the same division inside its competitors' single repos: Codex holds "the CLI, dozens of core runtime crates, an app server, MCP support, and Python and TypeScript SDKs"; OpenCode's packages/ holds core, server, cli, desktop, tui, web, two SDKs, and a plugin system.

The twist is who the architecture is being sold to. OpenAI built one harness and forked its own surfaces; OpenHands' argument is that an enterprise should rent the runtime and own only its surface — "your team owns the product-specific layer while upstream keeps maintaining the runtime underneath it… that means the 2,036 annual SDK PRs keep happening upstream instead of becoming your backlog." Same boundary, drawn between two companies instead of two product modes. The price of drawing it wrong (a fork ~4,600 PRs behind after a year) and the vendor-interest caveats are at Harness Build-vs-Buy.

Connections#

• Agent Harness Engineering — the harness/UX division of labor stated as a product architecture: what a second vendor found it had to keep per-surface when it stopped keeping anything else
• Harness Shrinkage as Models Improve — the thesis this independently corroborates; the three surface differentiators are Cherny's safety/permissions/UI residue reached from the opposite direction
• Cost-per-Task Over Cost-per-Token — the model-selection face of the same design tension: Anthropic publishes a rule for expert users (start strong, dial effort down), OpenAI ships an opinionated default and hides the knobs behind a slider
• HTML as the New Markdown — the human-facing half; a shared harness makes legibility, not capability, the thing that varies per surface
• Conversation-to-Delegation Shift — the usage trend that motivated the merge: OpenAI reports knowledge workers at ~20% of Codex's base and growing >3× as fast as developers
• Parallel Agent Orchestration — sub-agents and Ultra as the concurrency primitive this architecture has to expose (or hide) per audience
• Claude Code Best Practices — the configure-don't-abstract pole on sub-agents (.claude/agents/ files, per-agent model selection), and the page carrying the open question this source partially answers
• Role Averaging, Not Role Elimination — the premise of the merge: if roles average, a product boundary drawn on role is drawn on sand
• Harness Build-vs-Buy — the same runtime/surfaces boundary drawn between companies: OpenHands' four-repo split, the price of forking across it (~4,600 PRs/year), and the ladder that ends at "build on the SDK"
• Codex — the harness in question; the entity-level account of the merge
• OpenHands — the third vendor whose four public repos make the platform split legible in line counts
• Cowork — the Anthropic-side counterfactual: split by output type instead
• Claude Code — the developer surface on the other side of that split
• OpenAI — vendor
• Boris Cherny — the harness-residue quote this page's convergence rests on

Open Questions#

• Does one harness with UX-layer differentiation stay viable as audience breadth grows, or does the abstraction tax (hidden sub-agents, 32 model options, Ultra buried in advanced settings) eventually force a re-split?
• Anthropic ships two products split by output type while OpenAI ships one merged surface — is that a durable architectural disagreement, or is Anthropic's split a May-2026 artifact that later sources show closing?

Sources#

• Codex from 0 to 10M Users: Building ChatGPT Work - Akshay Nathan, OpenAI — Latent Space, 2026-07-28 (practitioner-opinion): Akshay Nathan on the shared harness, the three UX differentiators, the merge rationale, and the sub-agent/Ultra visibility trade-offs
• Coding Agents and Technical Debt — Rajiv Shah, OpenHands, 2026-07-28 (case-study, vendor-interested): "a coding agent is never one codebase" with per-repo line counts, and the same runtime/surface boundary recommended as a rent-don't-fork decision