What Is Muse Code? Meta's Terminal Coding Agent, Explained

§ 01What Muse Code is#

The setup is one shell command on macOS or Linux, after which the agent runs as muse inside any repository. Meta describes it as handling complex software-engineering work across large repositories: planning changes, writing code, validating results, and coordinating multi-file work end to end.

Two structural facts frame everything else. First, it is a terminal product - Meta documents no Muse IDE, and no official editor extension as the primary surface. Second, the intelligence is hosted: Muse Code is a local harness around Meta’s Muse Spark 1.2 service, not local weights. You need a Meta developer account, and the product is explicitly beta.

§ 02The architecture: subagents, worktrees, event log#

The most distinctive design choice is that subagents are persistent. Rather than spawning a helper per task and discarding it, Muse Code maintains specialized background agents throughout a session that gather information, pursue next steps, and report back to the primary agent.

For parallel work, Meta documents fan-out into git worktrees: a parent agent distributes tasks to write-capable subagents, each working in its own isolated worktree so concurrent edits cannot collide, while the parent monitors, steers, or stops them. Meta’s own guidance is candid about the limits - fan-out suits independently verifiable tasks; sequential work and small edits belong in the main thread.

The third bet is the event log. Muse Code records model calls, tool runs, approvals, and edits in an append-only local log, which makes sessions restart-safe (an interrupted run resumes from recorded state) and replay-exact. Meta even documents turning recorded events into deterministic CI replay fixtures - a genuinely novel idea for testing agent behavior.

§ 03Approvals and the sandbox#

Muse Code layers its guardrails. The bundled /plan skill reads the project, produces a plan and validation strategy, and stops for approval before implementing. A /goal mechanism pins a durable objective across turns and gates completion on an audit of the acceptance criteria. Compound shell commands get staged approvals: safe stages run, dangerous or unparseable stages hold for review, and persistent command grants are scoped to one workspace, with deny rules taking precedence.

Underneath sits an OS-level sandbox, on by default: writes allowed in the workspace and temp roots, the rest of the filesystem read-only, network egress restricted. Notably, it probes its own enforcement before trusting itself and refuses to execute if containment is not actually working. The escape hatch is a --yolo flag that disables the sandbox entirely - useful to know exists, mostly as the thing not to run on a machine you care about.

§ 04Pricing and access: what is actually verifiable#

Here the record thins out, and it is worth being precise about why. Meta’s detailed developer documentation - including the billing and rate-limit pages - sits behind a developer login. The public pages confirm the beta, the installer, and that Muse Spark 1.2 is available through both Muse Code and the Meta Model API, which Meta calls “direct, self-serve and affordable.” What no public page confirms: a flat subscription price, inclusion in any consumer Meta plan, launch credits, or exact per-token rates.

Third-party pages quote specific token prices, including a discounted contributor tier. Treat those as unverified until you can see them in the authenticated console. The practical read: expect developer-account, usage-style billing rather than a consumer subscription, and check the console before pointing Muse Code at a large repository - agent harnesses consume tokens continuously, and unpriced continuous consumption is not a plan.

§ 05How it compares#

The closest comparison is Claude Code: the same product shape with different bets. Anthropic is betting on classified autonomy - a safety classifier replacing routine approval prompts. Meta is betting on structure - persistence, parallelism, and replayability inside the session. Cursor remains the breadth play. For the wider field, our monthly harness ranking covers how these trade-offs stack up in practice.

§ 06Session persistence is not business persistence#

Muse Code’s event log solves a real problem: a crashed session resumes exactly where it stopped, on that machine, in that repository. It is the best version of within-session persistence any major harness has shipped.

It is also worth being clear about what it does not cover. The log replays a session; it does not carry understanding across days, tasks, and people. An agent doing business work needs the second kind: memory of decisions made last week, handovers between working sessions, a task board that outlives any one run. That is the layer CellCog builds as architecture - AI employees whose memory is enforced rather than advisory, covered in depth in how AI employee memory works.

§ 07The honest caveats#

Muse Code is a beta, and Meta’s own cookbook repeatedly warns that real model behavior varies from its demonstrations. The sandbox is only a boundary while it is on - --yolo removes it. Skills like /plan and /grilling run only when explicitly invoked, so the guardrails are opt-in habits as much as defaults. Fan-out helps only genuinely separable tasks. And the unknowns list is real: pricing, context limits, data retention, whether repository content trains models under each tier, enterprise controls, and model choice are all unverifiable from public pages today. For a beta from a company Meta’s size, most of these will resolve quickly; until they do, this page marks them as open rather than guessing.

§ 08Update, August 31, 2026: out of beta, with four additions#

Meta took Muse Code out of beta on August 31, 2026, announced on its developers blog. As predicted above, the unknowns started resolving quickly. What shipped with the graduation:

• Inter-session messaging. Parallel sessions can now pass messages to each other - a warning when one session’s change affects another, or an answer to a question a sibling is blocked on. Transport is a Unix socket between local processes, nothing crosses the network, and the agent itself discovers peers and sends through two built-in tools.
• Workflow. The subagent story graduates from fan-out to orchestration: say “use a workflow” and a large task becomes a coordinated team of parallel agents you watch and steer from one control room (/workflows shows live progress with stop, restart, and cancel). Completed workflows can be saved and reused. The ultra effort level triggers workflows automatically.
• Rewind. Double Esc rolls the conversation back to an earlier point, with the event log supplying only safe rewind points and a confirmation gate before any work is undone - the append-only log paying off in a second way.
• SDK (developer preview). The engine behind the CLI is now a TypeScript library speaking the Muse Session Protocol (MSP), an open protocol over standard I/O with no server and no network: spawn a local host, stream answers, decide permission requests from your own code, reload sessions with state intact.

On the pricing thread this page has been tracking: subscription plans now exist - Meta announced three monthly tiers offering “more affordable Meta Model API usage than pay-as-you-go pricing.” The public announcement still names no prices, so the specific rates remain login-walled; the shape, though, is now confirmed as developer subscriptions rather than inclusion in a consumer Meta plan. This page updates when the tier prices become publicly verifiable.

One reading worth adding: inter-session messaging and Workflow are Meta building agent-to-agent coordination inside a single developer’s machine - agents discovering each other, passing messages, and dividing work. That is the same direction the whole field is moving, one machine at a time, and it is the strongest confirmation yet of the bet this page identified in August: Meta’s play is structure, not just a model.