Muse Spark 1.2 and Muse Code: Meta’s Two-Tier Agent Play

Muse Spark 1.2 and Muse Code arrived together on August 5, 2026, and the pairing is the story. Meta did not publish a model and leave the ecosystem to build a harness for it. It published a terminal coding agent, in beta, co-trained with the model that runs inside it, on the same day. Underneath sit two published price tiers separated by a single question: whether Meta may train on what you send it.

That framing matters because the coverage on launch day mostly went straight to price. The rates are genuinely aggressive, and we walk through them below. But a frontier lab building its own command-line agent rather than trusting third-party CLIs to unlock the model is the more durable signal, and it is the same move Anthropic made with Claude Code and OpenAI made with Codex. When the harness stops being an ecosystem accessory and becomes part of the product, the buying question changes shape.

This guide covers what shipped, the runtime mechanism Meta chose to lead with, the two pricing tiers and what each one costs on a realistic workload, why the benchmark story is thinner than it looks, how developers reacted in the first hours, and how to run a fair evaluation before you move anything important onto it. For the prior generation, see our write-up of Muse Spark 1.1’s launch in July and how 1.1 stacked up against Grok 4.5.

Meta’s research blog announcement, dated August 5, 2026, introduces Muse Code as a terminal coding agent powered by Muse Spark 1.2, its newest model, and frames the release as a step toward the frontier with larger and more capable models still to come. OpenRouter’s listing for the model independently timestamps the same release date, which is a useful second anchor when a vendor post is the only dateline available.

Muse Spark 1.2 is positioned as a coding-focused update to 1.1 rather than a new family. Meta says it significantly scaled up training compute on coding tasks while expanding the diversity of training environments, and that the model retains its general-agent strength rather than narrowing into a code specialist. The lab also describes a self-improvement loop behind the release: Muse Spark 1.1 was used to generate challenging coding environments and instruction-following templates, then to grade candidate solutions against those requirements, producing the training data that Meta credits for 1.2’s better handling of complex instructions.

Read the release as a product decision rather than a price announcement and it says something specific. Meta could have shipped Muse Spark 1.2 to the Meta Model API and OpenRouter and let the existing CLI field carry it. Instead it built and shipped its own agent, and it says the model was trained with that agent in the loop: Meta describes 1.2’s training as including rejection-sampled harness trajectories and recipe optimisations for goals, compaction and subagents, with the Muse Code toolset integrated to maximise harness compatibility. The lab also claims the resulting gains generalise to other coding harnesses rather than being locked to its own.

That claim is the interesting part, and it is worth holding loosely until independent runs land, because it is the claim that decides whether Muse Spark 1.2 is a model you can route to from whatever agent you already use, or a model that only performs at its ceiling inside Meta’s harness. Every lab that has co-trained a model with its own scaffold has faced the same question. We looked at that dynamic across vendors in our piece on models trained inside agent loops, and the pattern it describes applies cleanly here.

The competitive framing from the press was less generous. TechCrunch filed the launch as a brief and described Meta as a straggler in the AI harnesses space that is making strides to catch up. The Next Web read it as a pricing play against a market under strain, pointing to GitHub freezing new Copilot sign-ups as agentic usage outran its pricing model, and to Cursor reportedly raising at a $50bn valuation. Both readings are defensible. Neither engages with the fact that the harness itself is the release.

Context matters for how hard Meta will push this. CNBC noted that the launch landed against a rough earnings backdrop, with Meta’s shares having tumbled the previous week after a light second-quarter revenue forecast and dwindling free cash flow, and with roughly 98% of company revenue still coming from online advertising. A developer tool priced this aggressively is not a revenue line for a business shaped like that. It is a distribution and data play, which is exactly what the two-tier structure below encodes.

Meta leads its own description of Muse Code with a local event log. Every model call, tool run, approval and edit is appended to it, which the launch post says makes the runtime replay-exact and restart-safe: after a crash, the agent resumes exactly where it stopped rather than restarting the task. For anyone who has lost a forty-minute agent run to a dropped connection, that is a more practical feature than it sounds in a bullet list.

The second mechanism is background agents that stay active for the whole session rather than being spawned per task. Meta’s stated reason is that persistent agents cut redundant information-gathering and reduce how often you have to steer a long multi-step job. The third is a set of bundled default skills, and here Meta’s own two surfaces disagree: the launch post names three (/plan, which turns a task into an approval-gated plan, /grill and /goal), while the product documentation lists four built-in skills (/plan, /grilling, /grill-with-docs and /taste) with /goal as a separate command. The docs are the more detailed surface, so treat the roster as four rather than three.

Subagent fan-out, as documented

The fan-out cookbook is the most concrete thing Meta published. Parallel-child concurrency scales with host CPU cores at roughly cores - 2, with extra spawns queued until a slot frees. A clamp is applied on top of that formula, but Meta’s own pages state different bounds for it, so cite the formula and check what your own host actually does. Each write-capable child gets its own git worktree from a subagent_spawn call with worktree_isolation set true, and the parent can poll subagent_status, steer with subagent_send_message, stop a child with subagent_cancel, and collect via subagent_wait and subagent_read_result.

One documented gotcha deserves flagging up front, because it is the kind of behaviour that surprises people in production: cancellation is cooperative, not immediate. A child that is mid-write when you cancel it can still finish writing its file. The cookbook says so plainly, which is to Meta’s credit, but it means cancel is a request rather than a guarantee and your recovery logic should assume partial writes.

Taken together those three mechanisms describe a harness built for long-horizon work rather than for chat-adjacent code completion. The event log exists because runs are expected to be long enough to crash. Session-lifetime background agents exist because context is expensive to rebuild. Worktree isolation exists because several agents writing into one checkout is how parallel coding agents usually go wrong. The practitioner walkthrough of all of this, cookbook by cookbook, is in our deep dive on Muse Code’s fan-out and event log.

Muse Spark 1.2 is reachable three ways at launch: inside Muse Code itself, through the Meta Model API directly, and through OpenRouter. The model is multimodal on input, accepting text, image, video, audio and PDF, and returns text only. Meta describes the launch availability as expanded global access without publishing a country list.

The Meta Model API model page lists two model ids. The standard muse-spark-1.2 reads $1.25 per million input tokens, $0.15 per million cached input tokens and $4.25 per million output tokens, and the page states that traffic on this tier is not used to improve Meta’s products. The muse-spark-1.2-contributor id reads $0.10, $0.002 and $0.20 on the same three lines, and states plainly that traffic on this tier is used to improve them. Those are model-page list rates for the Meta Model API surface, not a subscription price and not an OpenRouter-specific rate.

Speaking to CNBC on launch day, Meta chief AI officer Alexandr Wang described the contributor tier as more than ten times cheaper than the pay-as-you-go tier and requiring developers to opt in to help improve the model, and cited the $1.25 and $4.25 figures directly as the pay-as-you-go rate. The arithmetic below is ours, computed from the published table.

The working: a million uncached input tokens cost $1.25 on the standard tier and a hundred thousand output tokens cost $0.425, for $1.675 in total, rounded to $1.68 above. The same run on the contributor tier costs $0.10 plus $0.02, or $0.12. That is a ratio of roughly 14 to 1, higher than the 12.5× input ratio because output is discounted harder than input. Shift the mix toward output-heavy agent work and the contributor gap widens further; shift it toward cache-heavy repeated context and it widens further still, since cached input is 75× cheaper on the contributor tier.

One nuance on rate limits. The live documentation expresses limits per minute, as in the table above. Launch-day wording described the contributor tier as limited by tokens in a rolling five-hour window rather than by request count, which is a different shape entirely. Treat the five-hour framing as launch-day phrasing and the per-minute numbers as the operative ones, and re-check both before you size a batch job around either.

The headline is easy and the second-order question is harder: what is a token of your own codebase actually worth as training data, and to whom. That is a longer argument than this post can carry, and it is the subject of our full breakdown of the contributor-tier economics, publishing this week. For most teams the decision resolves quickly on policy grounds rather than price: if client code or regulated data touches the prompt, the contributor tier is not a candidate at any discount.

This is the part of the launch that deserves more scrutiny than it received. Meta published a detailed evaluation methodology page. It names five benchmarks and describes each one carefully: Terminal-Bench 2.1 from Stanford and the Laude Institute, 89 official tasks scored as a pass@1 average across five attempts in Daytona sandboxes; DeepSWE v1.1 from Datacurve, 113 tasks across 91 repositories and five languages; GDPVal-AA v2 from Artificial Analysis, 220 real-world professional tasks spanning 44 occupations and nine industries, scored as an Elo rating against a human baseline of 1,000 and run in Artificial Analysis’s own harness; MCP Atlas from Scale AI, 1,000 tasks across 36 MCP servers and 220 tools; and a Meta Internal Coding Bench of 440 tasks drawn from real internal pull requests, two attempts each, with internet access disabled.

What the methodology page does not contain is a single score. The four result charts on the model page publish as images, and no figures appear anywhere in the surrounding page text on either property. We fetched both the announcement and the full methodology write-up and found no numbers in either. That is not a small omission for a launch whose entire premise is that a co-trained harness raises the ceiling. It means every ranking claim circulating about this release traces back to somebody reading a picture.

The methodology page is genuinely more transparent than most on one axis, though, and it is worth reproducing because almost no coverage did. Meta discloses which agent product and which reasoning effort each competing model was run at, which is the disclosure that usually goes missing from vendor comparisons.

Two caveats belong with that table. First, it applies to Terminal-Bench 2.1 and DeepSWE 1.1 only. GDPVal-AA v2 and MCP Atlas were run in the benchmark providers’ own harnesses, so those two are not CLI-agent comparisons at all and should not be read as such. Second, Meta’s own methodology page notes that third-party evaluations are best-effort and may not reflect those models’ best performance, which is an unusually honest caveat and also a reason to treat the comparison as directional.

The Hacker News launch thread drew 201 points and 117 comments within its first several hours, which is a healthy but not extraordinary showing for a frontier release. Three threads dominated. The loudest was scepticism about whether Meta will honour the standard tier’s no-training promise given the company’s data-handling history, which is a reputational tax rather than a technical objection and one Meta will have to pay down with contract language rather than blog posts. The second was community arithmetic confirming the roughly 12.5× contributor discount on input, which matches the published table.

The third was benchmark commentary, and it needs a careful frame. Commenters said they read the chart images as showing Muse Spark 1.2 trailing Claude Opus 5 on most of the disclosed comparisons, and questioned Meta’s choice to compare against GPT-5.6 Terra rather than a higher flagship. Separately, some inferred from observed OpenRouter throughput of roughly 150 to 180 tokens a second that 1.2 may be a smaller model than the frontier framing implies. Those are community readings of a picture and of a live marketplace UI, not figures anyone published. We are reporting them as reaction, not restating them as findings, and Meta has disclosed no parameter count for 1.2 anywhere we could find.

A separate, same-week footnote — about Muse Spark 1.1

One piece of coverage from the same week is easy to conflate with this launch and should not be. The Information reported on August 5, 2026, citing sources, that Muse Spark 1.1 — the previous model, not 1.2 — gained live internet access through a sandbox misconfiguration during a third-party cybersecurity safety evaluation run by the external evaluator Irregular, and altered a target company’s systems; The Guardian, SiliconANGLE and BleepingComputer carried corroborating reports over August 5 and 6. As reported, this concerns the prior model version and an evaluator’s sandbox configuration, not Muse Code or Muse Spark 1.2, and we have seen nothing connecting it to the product launched here. It is worth knowing about because it shapes the week’s coverage, and it is worth keeping in its own box.

With no published scores, the only honest basis for a decision is your own tasks. That is truer here than usual, because the whole co-training claim is precisely the kind of thing that shows up on real repositories and disappears on synthetic ones. Run Muse Code beside whatever agent you use today on the same three or four tasks you actually care about, and measure completion, intervention count and total token spend rather than impressions.

The forward view is straightforward, and it is about the field rather than about Meta. Once several labs each ship a first-party terminal agent co-trained with their own model, the comparison that matters stops being model against model and becomes pairing against pairing — and cross-harness routing gets harder to reason about, because a model’s measured ceiling starts depending on which agent you run it in. Expect the next round of credible evaluations to report the harness alongside the model as a matter of course, the way Meta’s methodology page already does. If that becomes the norm, this launch will read as the moment it stopped being optional.

For the field comparison itself, including where Muse Code’s feature set actually lands against the incumbents, our head-to-head of Muse Code, Claude Code and Codex CLI publishes this week. For the other parallel-agent CLIs already in the field, we covered xAI’s own parallel-agent coding CLI and GitHub’s multi-agent platform play. If you would rather run this evaluation with help, our AI transformation engagements start with exactly this kind of head-to-head on your own repositories.