What Is Muse Code? Meta’s Terminal Agent, and Why It Ships With Its Own Model

Muse Code is a terminal coding agent, released in public beta on August 5, 2026 for macOS and Linux, installed with `curl -fsSL https://dev.meta.ai/install.sh | bash`. It runs Meta Muse Spark 1.2 — and only that model. We took apart its benchmark claims separately in our Muse Code review; this piece explains what the thing actually is and how it works.

Start with what makes it unusual. Most coding agents are a wrapper around whichever model you point them at. Muse Code isn’t: Meta trained the agent and the model together, on trajectories sampled from the agent’s own harness. The two are a matched pair, and every claim either of them makes has to be read in that light.

An agent, not a model

Worth stating plainly because the naming invites confusion: Muse Code is software you install; Muse Spark 1.2 is a model you call over an API. You can use the model without the agent — through Meta’s own API or a routing platform that carries it — but you cannot currently use the agent with a different model.

That distinction matters for evaluation. When Meta reports a Terminal-Bench score, that score belongs to a *combination* of a model, a harness and an effort setting. Swap any one of the three and the number changes.

The architecture, and what’s genuinely new about it

Three design decisions separate Muse Code from a conventional agent loop.

Persistent subagents. Rather than spawning a fresh process for each step, Muse Code keeps a set of subagents alive across a session — a coordinator, an explorer, an executor and a verifier. They hold state, which means the explorer doesn’t re-derive the repository structure every time the executor needs it, and the verifier retains the context of what was supposed to happen.

Git worktrees for parallelism. Work that runs concurrently runs in isolated worktrees, so two subagents editing the same repository don’t collide. This is a mundane-sounding choice that solves the most common practical failure of parallel coding agents.

An append-only event log. Every model call, tool run, approval and edit is appended to a local log. The runtime is therefore replay-exact and restart-safe: if the process dies at hour six of an eight-hour run, it resumes rather than restarting. For long jobs this is the difference between an agent you can trust overnight and one you have to babysit.

Bundled with it are three skills: `/plan` produces an approval-gated plan before anything is written, `/grill` stress-tests that plan against edge cases, and `/goal` runs to completion. The `/grill` step is the unusual one — an explicit adversarial pass over the plan before implementation, rather than after.

The benchmark claim, and the arithmetic underneath it

Meta reports Muse Code with Muse Spark 1.2 at 82.9% on Terminal-Bench 2.1, a claimed 6.7 points above the previous model generation, alongside 59.3% on DeepSWE v1.1 and 70.6% on an internal coding benchmark. All vendor-run, each competing system paired to its own agent product, none independently reproduced. Meta’s own methodology note concedes its setup may not be tuned for third-party models, and its chart shows Claude Opus 5 ahead at 86.7%.

Now the arithmetic. 82.9 minus 6.7 is 76.2 — which is precisely the figure on the official Terminal-Bench 2.1 leaderboard for mini-SWE-agent paired with Muse Spark 1.1, xhigh, submitted by Princeton on July 9, 2026, sitting at rank 8 with a run cost of $198.05.

Meta never published the harness behind its baseline, so this is an inference and not a proven claim. But if that row is the baseline, the “+6.7 generational improvement” is measuring Princeton’s deliberately minimal scaffold against Meta’s own co-trained agent — a model upgrade and a harness upgrade reported as one number.

For context, the official board’s top rows are Claude Code with Claude Fable 5 at 83.8% ($552.67), Codex with GPT-5.5 at 83.1% ($2,059.19), and Terminus 2 with Claude Fable 5 at 80.4%. Neither Muse Code nor Muse Spark 1.2 appears on it.

And a broader caution: three separate scales exist under the name “Terminal-Bench 2.1.” The official board tops out near 83.8%, Meta’s deck shows 86.7%, and Artificial Analysis’ own implementation runs near 89.5%. Comparing a score from one to a score from another is meaningless.

What it costs to run

Muse Code bills through the model, so the pricing is Muse Spark 1.2’s:

Standard tier — $1.25 per million input tokens, $0.15 cached, $4.25 output, roughly 3,000 requests per minute, and Meta states your prompts are not used for training.
Contributor tier — $0.10 / $0.002 / $0.20, capped at 60 requests per minute, in exchange for granting Meta training rights over your prompts and completions.

For an agent specifically, the contributor tier deserves careful thought twice over. Sixty requests per minute is 2% of the standard budget, and a coding agent running four persistent subagents in parallel will hit that fast. And the data being licensed is not abstract — for a terminal agent operating in your repository, “prompts and completions” means your source code.

Where it falls short today

Being honest about a beta:

No Windows support. macOS and Linux only.
Single-model lock-in. You cannot point Muse Code at a different model, which means you cannot separate “is the agent good” from “is the model good.”
No IDE plugins, and no MCP support as of this writing, which limits how it connects to the rest of a toolchain.
Beta surface. Commands and behaviour can change under you.
Co-training cuts both ways. The model’s headline scores were earned inside this harness. Running Muse Spark 1.2 in your own agent framework should be expected to regress somewhat toward the mean — which is exactly what Vals AI’s neutral common harness shows, placing the model #14 of 50 on Terminal-Bench 2.1.

Using the model without the agent

If what you want is the model rather than the terminal experience — because you have your own harness, or you’re on Windows, or you need MCP — Muse Spark 1.2 is available on its own through Meta’s API and through routing platforms. On OrcaRouter it sits behind the same OpenAI-compatible key as 200-plus other models at 0% markup, which makes the useful experiment easy: run your existing agent framework against Muse Spark 1.2 and against whatever you use today, on the same tasks, and see how much of Meta’s benchmark advantage survives outside Meta’s harness.

Worth knowing before you do: it’s slow. OrcaRouter’s seven-day production telemetry puts Muse Spark 1.2 at p50 7.73 seconds to first token against 1.93 seconds for the previous version, and Vals’ independent runs averaged around 610 seconds per test. That’s fine for an agent working through a long task and poor for anything interactive.

The takeaway

Muse Code is a genuinely interesting piece of engineering — persistent subagents, worktree isolation and a replay-exact event log solve real problems that most agent frameworks handle badly. It is also a beta, macOS-and-Linux-only, locked to one model, and benchmarked entirely by the company that built it, with a headline generational gain that may partly belong to the harness rather than the model. Try it if you’re on a supported platform and your work is long-running. Just don’t treat 82.9% as a fact about the model, because under a neutral harness the same model places fourteenth.

Sourcing note: architecture, install instructions, pricing, rate limits and the 82.9% / 59.3% / 70.6% figures are Meta’s own published claims, unreproduced by third parties. The 76.2%, 83.8%, 83.1% and 80.4% rows are from the official Terminal-Bench 2.1 leaderboard; the #14 of 50 rank is from Vals AI; first-token latency is OrcaRouter’s own seven-day production telemetry. The 82.9 − 6.7 = 76.2 observation is our inference, not a Meta statement. Checked August 7, 2026.