Meta gave Muse Code a swarm of coding interns. The cheap tier comes with a data clause.

Meta’s first terminal coding agent arrives with the familiar promise: describe a software job, let the machine plan it, write the code, and validate the result. The less familiar part is the plumbing. Muse Code can keep background agents alive, split work across isolated Git worktrees, and replay its actions from a local event log. Its cheapest model tier also comes with permission for Meta to use interactions to improve its products. 123

The useful feature is real. So is the invoice. Muse Code is a serious orchestration layer around a coding model, not a magical employee that has learned what your repository is for.

The sales pitch is “complete software engineering tasks across large repos.” The architecture is a local terminal client, a model API, persistent agent state, worktree isolation, and a billable stream of reasoning tokens. That is still useful. It is simply less romantic.

Muse Code installs from the terminal, authenticates through a browser, and starts inside a project directory when the user runs muse. Meta positions it as a beta for macOS and Linux, with Muse Spark 1.2 available through Muse Code, the Meta Model API, and OpenRouter. 23

The interesting design is not the command. It is the persistent background work. Muse Code keeps specialized agents active during a session instead of spawning a fresh helper for every small task. Those agents decide when to report back to the main agent, which cuts down on repeated context gathering. 2

For a large job, Muse Code can fan work out to child agents in separate Git worktrees. The developer’s working copy is left untouched while the children work in parallel; the official recipe requires a Git repository and the --subagent-worktree-isolation option. The children return branches for review or merging rather than scribbling over one shared directory. 3

That distinction matters. A worktree prevents two agents from editing the same file at the same time. It does not prevent two agents from making incompatible assumptions about the product. Isolation solves the collision problem. Tests, review, and a human who understands the code still solve the meaning problem.

Muse Code also keeps a local event log. Meta says every model call, tool run, approval, steer, and edit is appended there; the same log supports replay, crash recovery, and muse resume. That is unusually concrete for an agent launch. It gives the operator something to inspect besides a green sentence claiming the task is finished. 23

The log is also a useful reminder of what the product is. Muse Code is not just a model with a chat box. It is a runtime that manages agents, tools, approvals, files, branches, and recovery. The model is the employee in the room. The runtime is the office manager keeping receipts.

Mark Zuckerberg’s launch post says Muse Code handles planning changes, writing code, and validating results across large repositories. Meta’s research post says it can coordinate multiple persistent subagents for complex tasks, and describes a kernel-optimization run that used more than 1,000 tool calls over as long as 24 hours. Those are product and research claims from Meta, not independent measurements of ordinary developer work. 12

Meta’s published Terminal-Bench 2.1 chart puts Muse Spark 1.2 at 82.9%, behind Opus 5 at 86.7% and ahead of GPT 5.6 Terra at 81.8% in the displayed comparison. The chart is Meta’s own evaluation, and its labels combine models with coding-agent harnesses. It is useful directional evidence, not a neutral product review. 2

The gap between the slogan and the mechanism is therefore not that Muse Code does nothing. It does quite a lot. The gap is that “complete software engineering” describes the length of the handoff, while the runtime still depends on a user to define the goal, approve plans where required, inspect changes, run meaningful tests, and decide whether a branch belongs in production. Meta’s own bundled /plan skill stops for approval before changing code, which is a sensible admission that delegation is not the same thing as judgment. 3

Muse Code starts with two model IDs. The contributor tier is token-rate-limited over a rolling five-hour window, is available only in select countries, and may be used to improve Meta’s products. When the user needs more tokens, Meta points them to the standard Model API tier: $0.15 per million cached input tokens, $1.25 per million input tokens, and $4.25 per million output tokens. 3

There is another meter hidden in the model. Meta says Muse Spark 1.2 is a reasoning model, and that reasoning tokens are billed as output. The developer can adjust /effort, but a long coding session is not priced like a single autocomplete. The useful question is not “What is the model’s per-token rate?” It is “How many tokens will this agent spend while it plans, retries, calls tools, and keeps background workers alive?” 3

That makes the contributor tier more revealing than the headline price. Meta is not merely discounting a model to attract developers. It is asking developers to supply product-improvement data in exchange for a lower-cost runway. The launch post does not say exactly how long contributor interactions are retained, which fields are used, or whether repository content is treated differently from prompts. The honest reading is not that Meta is secretly taking anything. It is that the public contract leaves those details open while clearly warning that product improvement is part of the bargain. 3

Terminal coding agents are already an established product shape. TechCrunch describes Muse Code as Meta’s attempt to catch up with OpenAI’s Codex and Anthropic’s Claude Code, while SiliconANGLE places it in the same market and reports Meta’s push to differentiate on affordability. 45

So the novelty is not “AI can work in a repository.” The novelty is Meta’s combination of persistent background agents, isolated worktrees, replayable local logs, a cheap contributor tier, and a higher-priced path to standard API billing. The first three are engineering choices. The last two are the business model. 23

That is the part existing coding agents have trained buyers to inspect: where the code goes, how the work is isolated, what the user can replay, and what “cheap” buys the vendor. Meta has made the mechanics unusually inspectable. It has made the data boundary unusually easy to postpone.

Muse Code is a credible beta with a real runtime, not a wrapper that renamed autocomplete. The persistent agents, worktree isolation, local event log, and one-command terminal path solve actual annoyances in long coding sessions. But Meta’s strongest differentiator is also the one that should slow down a serious team: the cheapest tier may use interactions to improve the product, while zero data retention requires a sales request, and reasoning tokens turn every long autonomous loop into a billable output stream. Try it on an open-source repository or disposable project if you want to test the orchestration. Keep proprietary code off the contributor lane until Meta tells you, in writing, what is retained and for how long. Muse Code may be a coding intern swarm. The cheap tier still wants a copy of the homework.