Muse Code vs Claude Code vs Codex CLI: the 2026 field guide

Muse Code vs Claude Code vs Codex CLI is the terminal-agent question of this week. Meta put Muse Code into beta on August 5, 2026, and for the first time in months the comparison has a genuinely new entrant rather than a point release. This guide re-scores all three from each vendor’s own current documentation, retrieved August 7, 2026 — not from a spring snapshot that has quietly gone stale.

That distinction matters more than it usually does. Our Q2 2026 matrix is the franchise predecessor to this post, and it was explicit about being a dated snapshot. It was right to be. One of its central distinctions — that Codex offered only limited in-session task decomposition while Claude Code had first-class subagents — no longer holds. OpenAI’s changelog now marks its multi-agent v2 subagent system stable, with configurable sub-agent models, reasoning levels and concurrency. Anyone still quoting the April framing is quoting a harness that has shipped dozens of releases since.

What follows is a working comparison across five axes that actually change day-to-day engineering: how each harness fans out parallel work, how each contains what the agent runs, what the published benchmark rows do and do not establish, how the three pricing stacks differ in shape rather than level, and which context-window number you are actually buying. Every figure below is labelled with the version or retrieval date it came from.

The three terminal agents are converging on a shared feature list — subagents, skills or plugins, a headless entry point — and diverging on what they optimise underneath it. Read the three cards below as statements of priority, not as feature checklists.

Muse Code’s design bet is the one worth sitting with, because it is the least common. Rather than optimising for a benchmark row, Meta optimised for what happens when a long agentic run dies halfway through. Every model call, tool run, approval and edit is appended to a local log, and that log is the session’s single source of truth. The claim that follows from it is a durability claim, not a capability claim.

Meta backs that with a case study rather than a score: Muse Spark 1.2 iteratively optimised GPU kernels — KDA and MLA on NVIDIA Hopper — over more than 1,000 tool calls and up to 24 hours inside Muse Code’s agentic environment, without importing third-party kernel libraries. A 24-hour run is exactly the workload class where restart-safety stops being a nice-to-have. We walk through the runtime mechanics in the fan-out and event-log deep dive, and the launch context in our full Muse Spark 1.2 and Muse Code launch guide.

One boundary is easy to get wrong, and most coverage has. The GitHub agent and computer-use cookbooks that ship alongside Muse Code’s documentation run on OpenCode, a third-party CLI, driving Muse Spark 1.1 through the Model API. They are demonstrations of the model, not native capabilities of the Muse Code harness. If you are scoping against those cookbooks, you are scoping a different tool.

All three harnesses spawn subagents. The interesting differences are in the ceilings, the nesting rules, and whether the ceiling is a fixed number or a function of your hardware.

The nesting rules split the field more sharply than the concurrency numbers do. Muse Code allows exactly one level: a spawned child cannot spawn children of its own. That is a deliberate simplification — it makes the event log linear and the failure modes tractable, at the cost of ruling out recursive decomposition. Claude Code goes the other way and lets subagents spawn subagents, which is powerful and correspondingly easy to run away with. We cover the budgeting side of that in Claude Code’s subagent depth and budget caps, and the Codex side in Codex’s multi-agent GA.

Comparing the ceilings directly: Claude Code’s default of 20 concurrent subagents sits 25% above the top of Muse Code’s 16-child clamp, and Muse’s clamp is itself hardware-dependent rather than fixed. That is a real difference in how much parallel work you can schedule from one session — but it is a ceiling comparison, not a throughput comparison, and neither vendor publishes what happens to per-agent quality at the top of the range.

Muse Code adds a second kind of parallelism that neither rival frames the same way: four background observer agents that run alongside the main session rather than being spawned by it. Memory recall, skill recall and goal tracking are on by default; verification is off by default. Each observer makes its own model calls, which is a cost consideration people miss — a Muse Code session bills for more than the visible conversation.

Worth noting while you are reading Meta’s material: its two properties do not currently agree on the bundled skill roster. The developer documentation lists four skills — /plan for turning a task into a grounded, decision-complete plan, /grilling for stress-testing a plan or design, /grill-with-docs for doing the same while recording decisions into project docs, and /taste as a design-quality gate for frontend work — with /goal classified as a goal-tracking background observer rather than a skill. The launch post instead names three, counting /goal among them. We follow the developer docs here, and note the disagreement rather than quietly picking a number.

On the Claude Code side, the equivalent lever is the effort ladder. Levels low, medium, high and xhigh persist across sessions once set, while max and ultracode apply to the current session only. Ultracode is worth naming precisely because it is routinely mis-described as a model or an effort tier.

Every cell below is drawn from the named vendor’s own current documentation or changelog, retrieved August 7, 2026. Where a vendor does not publish a figure, the cell says so rather than borrowing a number from somewhere else.

Two structural observations fall out of the table. The first is that Claude Code is the only one of the three whose reach extends beyond the terminal in a documented, first-party way — the JetBrains plugin, Remote Control and Channels are surfaces the other two do not currently match. The second is that Codex is the only one whose extension story is a catalogue: Agent Plugins are installed and searched, which is a distribution model rather than a configuration file. Those are different theories of how teams standardise.

Codex’s v0.147.0 also added opt-in support for the MCP 2026-07-28 protocol revision alongside the existing spec — paginated discovery, multi-round requests and non-blocking server startup. That is the kind of plumbing change that only shows up in your day when a slow MCP server stops blocking session start. The broader config surface is covered in Codex CLI’s config, profiles and sandbox modes.

Containment is where the two vendors that publish detail publish very different detail. Muse Code documents an OS-enforced sandbox and a staged approval model; Codex documents three named sandbox modes and a new automatic-approval flag. Both are worth reading before you point either at a repository you did not write.

Claude Code’s permission model is a large enough topic to have its own treatment rather than a table cell, and the documentation set we pulled for this comparison focused on orchestration, effort and pricing. For the approval-decision side, see Claude Code’s auto-mode permission model rather than inferring it from the cells above.

Meta published comparison charts alongside the Muse Code launch. The figures below are one outlet’s reading of those charts, which are published as images rather than as machine-readable text on Meta’s own site. That provenance is not a reason to ignore them; it is a reason to label them precisely every time they are quoted.

The second chart tells a different story about the same three tools. On DeepSWE 1.1, Claude Code and Codex are effectively level and Muse sits well behind both — a ranking inversion relative to Terminal-Bench, where Muse placed second.

A third chart, Meta’s own internal coding benchmark, shows Claude Code at 79.4% against Muse at 70.6% — an 8.8-point gap on Meta’s home turf, which is an unusually candid thing for a launch chart to show. Meta published a fourth chart as well; no independently reported figures for it were located, so it is left out here rather than estimated.

Here is the interpretation that matters more than any individual number. Across the two multi-harness charts, the spread from top row to bottom row is 5.1 points on Terminal-Bench 2.1 and 5.7 points on DeepSWE 1.1 — and the ordering of the middle two swaps between them. When four harnesses on Terminal-Bench and three on DeepSWE all cluster inside six points and change places depending on which suite you run, the score is not the deciding variable. The scaffolding around it is.

That is not a rhetorical hedge; it is the documented behaviour of this benchmark class. We worked through it in our guide to reading agent benchmark scores, where holding the model constant and swapping the harness moved Terminal-Bench 2.1 results by several points on its own. Meta’s own framing compounds the point: it says Muse Spark 1.2 was co-trained with the Muse Code harness and across multiple third-party harnesses, precisely so performance would generalise beyond its own CLI. A model shaped by its harness during training is a model whose scores carry harness assumptions into every comparison.

The single most common mistake in comparing these three is putting their headline numbers in the same column. Meta meters the Model API. Anthropic sells a subscription plan that bundles the harness, with a separate metered API underneath. OpenAI gates Codex access by ChatGPT plan tier. Every figure below is labelled with the surface it belongs to.

A few of those cells reward a second read. Claude Pro billed annually at $200 up front works out to roughly $17 a month, about $40 a year less than paying $20 monthly — a subscription-plan comparison, not an API one. Anthropic’s Sonnet 5 introductory API rate of $2 and $10 per million tokens becomes $3 and $15 after August 31, 2026, which is a 50% increase on both sides of the meter; if your cost model was built during the introductory window, it needs revisiting before September.

OpenAI’s dated item is easy to over-read. GPT-5.4 and GPT-5.4 mini leaving Codex on August 31, 2026 applies to users signed in with ChatGPT; the recommended replacements are GPT-5.6 Terra and GPT-5.6 Luna respectively. Both retiring models remain available through the OpenAI API and through Codex sessions authenticated with an API key. It is an account-surface sunset, not a model deprecation, and writing it the other way will send teams into an unnecessary migration.

The pricing-shape taxonomy these three feed into — seat subscriptions with usage multiples, metered APIs, plan-gated access and data-for-discount tiers — is the subject of our companion piece on how AI coding pricing shapes compare. For budgeting across a mixed stack, the shape matters more than any single rate.

This is the axis most comparisons get wrong, because two different numbers share one name. The model’s API context window is what the model can hold. The harness’s bundled context is what the CLI actually schedules into it. They are not the same figure, and for Codex CLI they are not close.

The practical consequence is that a Codex CLI session is not a 1,050,000-token session unless you have deliberately changed the harness budget. If you are planning a whole-repository pass on the assumption of the model-page number, plan against the CLI number instead. And when a vendor, a blog post or a procurement document quotes a context window for a CLI tool, the first question is always which of the two figures it is quoting.

Meta’s flat-rate structure is the quieter finding here. Some long-context pricing carries a step: past a given fill threshold, the per-token rate rises. The Meta Model API standard rate does not, which makes long agentic runs unusually easy to forecast — you multiply tokens by a single number. Paired with the event-log restart-safety, it reads as a coherent bet on long-horizon work rather than on short, sharp, benchmark-shaped tasks.

None of these tools is a general winner on the evidence available. Each has a workload shape it fits better than the others, and the most defensible position for a team of any size is to run more than one and route deliberately.

Looking forward, the axis most likely to separate these three over the next two quarters is not model quality. It is whether the harness can be made a reviewable artefact. Codex has already moved that way with profiles and a plugin catalogue; Muse Code has moved that way with an event log that is, by construction, an audit trail; Claude Code has moved that way with Routines that run without a developer machine attached. All three are converging on the same requirement from different directions — that what the agent did be inspectable after the fact by someone who was not watching at the time.

The corollary is that the next stale claim will be about orchestration primitives, not about scores. This post’s own architecture table has a shelf life measured in weeks: Codex shipped a release on the day it was written, and Muse Code is in beta. If you are building a tooling decision on any comparison in this space, build in a re-verification date. Ours is attached to every cell above. If you want that discipline applied to your own stack, our AI and digital transformation engagements start with exactly this kind of evidence-dated evaluation, and the web development team runs the same routing logic across production codebases.