Muse Code: Meta's Terminal Coding Agent, Explained (2026 Guide)

Meta shipped its first dedicated coding agent on August 5, 2026. Muse Code is a terminal-native agent in the same category as Claude Code and OpenAI's Codex CLI, built by Meta Superintelligence Labs and running on Muse Spark 1.2, a coding-focused model Meta says it co-trained with the agent itself.

This guide is built from Meta's own documentation and the shipped binary rather than the launch-day press cycle — which matters, because a lot of the early coverage is wrong on specifics. We verified the install domain, the command surface, the config paths, and the safety defaults directly. Where Meta has not published something, we say so instead of guessing.

What is Muse Code?

Muse Code is a single statically-linked binary called muse that you run inside a project directory. It plans a change, edits files, runs shell commands, and checks its own work — the now-familiar agentic loop — but with a few design decisions that genuinely differ from its competitors.

The version live at the time of writing is 0.1.0-R708.1, published on the muse-stable channel. It is explicitly a beta.

Three things define it:

• It is local-first. The agent, the subagents, and the session logs all run on your machine. Only the model is hosted. The "persistent background agents" in the marketing are session-scoped and local — widely misread as Meta-hosted infrastructure.
• It is locked down by default. Approval prompts and an OS-enforced sandbox are both on from the first run, and the sandbox refuses to start if it cannot enforce its boundary. Network access defaults to proxy-only. That is a stricter out-of-the-box posture than most of the field.
• It is priced aggressively. Two SKUs, a 12–21x gap between them, and the cheap one is paid for with your source code.

How do you install Muse Code?

One command, macOS or Linux:

curl -fsSL https://dev.meta.ai/install.sh | bash

A warning worth repeating, because several published guides get it wrong: the domain is dev.meta.ai, not dev.ai. The latter is a different site entirely and does not serve the installer.

The installer needs only curl, mktemp and bash. There is no Node.js, Python or Homebrew dependency — the binary is statically linked. It installs a self-updating launcher to ~/.local/bin/muse and appends that directory to your shell profile.

Supported platforms are macOS and Linux on x86_64 and arm64. Native Windows is not supported and the installer hard-fails on it; WSL2 is the route in. Verify with:

muse --version
# Muse Code 0.1.0 (0.1.0-R708.1)

For the full walkthrough — auth, CI keys, headless runs and the flags that matter — see our step-by-step Muse Code install guide.

What is Muse Spark 1.2?

Muse Spark 1.2 is a coding-focused point release of Muse Spark 1.1, not a new base model. Meta describes it as co-trained with Muse Code using rejection-sampled harness trajectories, plus a self-improvement loop in which Spark 1.1 generated training environments and graded candidate solutions for 1.2.

It is closed-weights. There is no Hugging Face download, no self-hosting and no fine-tuning — a continuation of the pivot away from the open-weight Llama era that Meta began with the original Muse Spark in April 2026.

Published specifications:

• Context window: 1,048,576 tokens (1M)
• Max output: 131,072 tokens
• Default model id: muse-spark-1.2
• Reasoning effort levels: none, minimal, low, medium, high, xhigh, ultra — default high

Meta has not published the architecture. There is no parameter count, no MoE-versus-dense confirmation, and no stated knowledge cutoff.

How do subagents and worktrees work?

This is Muse Code's most substantial engineering idea. A lead session spawns child agents, hands each a bounded task, and manages the group while they run.

By default children share the lead's workspace, which means parallel writes can collide. Turn on worktree isolation and the runtime creates one git worktree per child, checked out from the lead's commit. Each child edits only inside its own worktree; the lead's working copy stays untouched, and the lead reviews or merges each child's commit afterwards.

The properties that actually constrain you:

• Concurrency scales with your machine — roughly core count minus two, clamped between 2 and 16. Extra spawns queue.
• Children run one level deep. A child cannot spawn its own children.
• Cancellation is cooperative. A cancelled child that never reaches a checkpoint keeps running; one mid-write finishes that write.
• Isolation needs a git repository. In a non-git workspace the flag is ignored silently.

You steer children from the TUI with /subagents and the /agent-* family — /agent-note, /agent-followup, /agent-interrupt, /agent-stop, /agent-resume.

If you already juggle several agent sessions, our AI Agent Task Board tracks what each one is working on across terminals.

What are the background observer agents?

Alongside the main session, Muse Code runs a team of background observers. Each watches one axis of quality and can insert a short advisory into the main agent's next turn. An observer never answers for you — it proposes, a reconciler decides, and only an accepted proposal reaches the main agent.

There are four:

• Memory recall — surfaces a relevant note from local project memory. On by default.
• Skill recall — surfaces a project skill the task should load first. On by default.
• Goal tracking — holds the agent to a declared goal and declines to close the turn until the work is done. On by default.
• Verification — checks that the agent actually ran the work it claims it finished. Off by default.

Worth budgeting for: three of the four run by default and each makes its own model calls, so they add token usage on top of the main session. You toggle them in the runtime_capabilities block of your settings file.

How does Muse Code handle project config?

Two locations. User settings live at ~/.config/muse/settings.json and must set "schema_version": 1 — omit that key and every command fails at startup with malformed settings file. That file holds model defaults, UI preferences, tool and MCP server configuration, a first-class hooks block, the runtime_capabilities toggles, and telemetry options.

Project instructions live in AGENTS.md, seeded by muse init. Meta did not invent a proprietary MUSE.md — it adopted the cross-vendor standard, and falls back to reading CLAUDE.md. If you have already written project rules for another agent, they largely carry over. Our AGENTS.md vs CLAUDE.md vs Cursor Rules comparison covers the format itself.

The interoperability goes further than the docs advertise. Muse Code scans repo-local .codex/skills and .claude/skills directories, and ships a migration command:

muse skills import --from claude
muse skills import --from codex

MCP is supported — both stdio and streamable_http transports, configured in settings.json. Several launch articles claimed MCP was unavailable in the beta. That is incorrect; it is documented and present in the shipped binary.

How safe are the defaults?

Better than most, and this is the part of Muse Code most worth copying. Two independent layers:

Approval. Set with --approval-mode. In the default on-request mode a shell command runs unless it matches the built-in dangerous set — rm -f, rm -rf, or sudo in front of either. untrusted escalates anything without a matching allow rule. never stops asking entirely.

Compound commands are reviewed stage by stage, not as one line. In a three-stage command the safe stages pass automatically and the agent holds at the dangerous one — and if you reject it, nothing runs at all, not even the earlier safe stages.

Sandbox. Shell commands run inside an OS-enforced policy — Seatbelt on macOS, a bundled bubblewrap helper on Linux. The workspace and a temp directory are writable, the rest of the filesystem is read-only, and inside the workspace the .git, .muse and .agents directories stay read-only so the agent cannot rewrite its own history, config or memory. It fails closed: if it cannot enforce the boundary, it refuses to run.

muse --yolo disables both layers at once. Meta's own guidance is to use it only in a disposable, already-isolated environment such as a CI container. That is good advice — follow it.

What does Muse Code cost?

Two tiers, and the gap between them is the whole story.

That is 12.5x on input and 21.25x on output. Meta's Chief AI Officer Alexandr Wang described the contributor tier as "more than 10 times cheaper" than pay-as-you-go, which if anything understates the output discount.

Two things the launch coverage mostly buried:

The standard tier is the better story. At $4.25 per million output tokens it undercuts Claude Opus 5 and GPT-5.6 Sol by a wide margin without surrendering any rights to your code. Everyone chased the 21x headline and skipped the tier most teams would actually buy.

Rate limits, not price, are the binding constraint on the cheap tier. 60 RPM versus 3,000 RPM is a 50x throughput cut — against a product whose flagship feature is parallel subagents. You cannot run the headline feature at the headline price.

And cheap tokens are not the same as cheap outcomes. On cost-per-solved-task rather than cost-per-token, the measured gap against frontier competitors narrows to low single digits, because a weaker model burns more turns getting there. We break the full picture down in what the contributor tier actually costs you.

Do the benchmark claims hold up?

This is where a launch guide has to be honest, and where Muse Code's story gets more complicated.

Meta loses on its own charts. Across all three coding benchmarks Meta selected and ran itself, Muse Spark 1.2 finishes second to Claude Opus 5:

Three further caveats matter:

• The comparison set was chosen favourably. Meta benchmarked against GPT-5.6 Terra, the mid-tier model, rather than Sol, the top one.
• Independent harnesses disagree sharply. Vals AI runs every model through one common harness and ranks Muse Spark 1.2 14th out of 50 on Terminal-Bench — against 2nd place on Meta's own vendor-agent setup. Artificial Analysis measures 80%, not 82.9%, and puts the 1.1 to 1.2 gain at about +2 points rather than Meta's +6.7.
• There is precedent. Meta claimed 80.0% on Terminal-Bench 2.1 for Muse Spark 1.1. Independent verification returned 76.2% ± 1.2 — a claim sitting past the upper bound of the confidence interval. Muse Spark 1.2 has no verified leaderboard entry yet.

Meta's own methodology note concedes its harness "may not reflect these models' best performance." Read the launch numbers as vendor-run and provisional. Our full benchmark breakdown works through the discrepancy in detail.

How does Muse Code compare to Claude Code and Codex?

The honest summary: Muse Code arrived unusually complete for a week-one product — MCP, hooks, skills, sandboxing and worktree parallelism are all present on day one, which is not typical. What it lacks is time. No Windows build, no IDE extension, no subscription tier, no third-party plugin ecosystem, and a single model with no fallback if it struggles on your stack.

For the detailed head-to-head, see Muse Code vs Claude Code.

What are developers actually saying?

Less than you would expect, and it is worth being honest about that. Two days after launch, total discussion across Hacker News and Reddit amounts to a few hundred comments, and only a handful of people have posted a first-hand result from running the CLI itself. Several major subreddits have no thread at all. Much of what ranks for "Muse Code review" right now is AI-generated filler.

One distinction matters and most coverage misses it: the majority of early reaction is about the Muse Spark 1.2 model, consumed through third-party tools like OpenCode, not about Meta's terminal agent. Treat "people say Muse is fast" and "people say Muse Code is good" as separate claims.

With that caveat, the recurring themes:

• Access is the loudest practical complaint. Roughly fifteen developers across Reddit and Hacker News — in Canada, the UK, Australia, Thailand and elsewhere — report that the contributor tier simply returns Model not found for them, and that US VPNs generally do not work around it. Meta's only on-record statement refers to "expanded global access" for the model. No official page documents a regional restriction on the contributor tier, so treat this as widely user-reported rather than confirmed — but budget for it before planning around contributor pricing.
• Signup friction is real. Multiple users report an identity-verification step, and sign-in options tied to Facebook or Instagram accounts, both of which land badly with this audience.
• No subscription is a conversion problem. Several would-be users specifically asked for a flat plan comparable to Claude Code's or Codex's and declined to use the API pricing without one.
• Early bugs. Reported issues include a Docker sign-in failure, a startup crash, and at least one billing dashboard showing a wildly inflated figure against actual spend. This is a beta and it behaves like one.
• Trust is the centre of gravity. Anti-Meta sentiment was top-voted in essentially every thread, and the closed-weights decision reads as a betrayal to the audience that adopted Llama. The Meta-specific concern that does not transfer to other labs is correlation with its advertising business.

The most instructive single data point: the team behind a competing agent could not get Muse Code running at all because of the sign-in bug, so they extracted its system prompt into their own harness — and reported roughly 2.7x fewer tokens, 2x faster and 2.4x cheaper results. If accurate, it suggests part of what Meta calls "co-training" is transferable prompt engineering rather than model capability.

Net read: negative on trust, mixed on quality, positive on price and speed. But the honest summary is that the product is still largely unjudged — there is not yet enough independent hands-on evidence to draw a firm conclusion, and anyone telling you otherwise two days in is guessing.

Should you use Muse Code?

Try it if you are running batch or throwaway work where token cost dominates — large-scale PR triage, mechanical refactors, log analysis, test generation across many files. The standard tier is genuinely cheap for frontier-adjacent capability, and the sandbox defaults make it safe to point at a repo.

Wait if you need Windows, an IDE surface, a predictable monthly bill, or a mature plugin ecosystem. And treat the beta label seriously: the most credible independent hands-on test so far paired a spectacular result — 222 pull requests audited in under five minutes for about ten cents — with a hard failure in which the agent spent three minutes researching a Google project that does not exist and then built its entire plan on the fabrication. Long-horizon autonomy is where it is weakest.

Do not put the contributor tier anywhere near proprietary code. The 12–21x discount is paid for with training rights over your inputs and outputs. That is a defensible trade for open-source work and an unrecoverable one for anything confidential — once code is in the weights, no deletion request unwinds it. Block it at the policy layer rather than trusting a config string.

FAQ

What is Muse Code?

Muse Code is Meta's terminal coding agent, released in beta on August 5, 2026. It runs on the Muse Spark 1.2 model, installs as a single binary on macOS and Linux, and plans, edits and verifies code changes inside your repository.

How do I install Muse Code?

Run curl -fsSL https://dev.meta.ai/install.sh | bash on macOS or Linux, then muse login. It needs only curl and bash — no Node.js or Python. Confirm with muse --version.

Does Muse Code work on Windows?

Not natively. The installer supports macOS and Linux on x86_64 and arm64 only, and hard-fails on anything else. Windows users need WSL2.

How much does Muse Code cost?

The standard tier is $1.25 per million input tokens and $4.25 per million output tokens, with cached input at $0.15. The contributor tier is $0.10 and $0.20 — but Meta trains on your inputs and outputs, and it is rate-limited to 60 requests per minute instead of 3,000.

Does Muse Code train on my code?

On the standard tier, no. On the contributor tier, yes — that is what the discount buys. Because the tier is selected by model id, the choice can be made accidentally by whoever is trying to reduce the AI bill, so enforce it as policy rather than convention.

Does Muse Code support MCP?

Yes. Both stdio and streamable HTTP transports are supported and configured in ~/.config/muse/settings.json. Reports that MCP was missing from the beta are incorrect.

Does Muse Code use AGENTS.md or its own config file?

It uses AGENTS.md, seeded by muse init, and falls back to reading CLAUDE.md. There is no MUSE.md. It also scans .codex/skills and .claude/skills, and muse skills import --from claude migrates existing skills.

Is Muse Spark 1.2 open source?

No. It is closed-weights, with no downloadable weights, self-hosting or fine-tuning — continuing Meta's move away from the open-weight Llama approach.

Is Muse Code better than Claude Code?

Not on capability, by Meta's own published benchmarks — Claude Opus 5 wins all three coding evaluations Meta selected. Muse Code competes on price and on a stricter default safety posture, not on raw model strength.

How many parallel agents can Muse Code run?

Roughly your CPU core count minus two, clamped between 2 and 16. Additional spawns queue until a slot frees. Children run one level deep and cannot spawn their own children.