Meta shipped Muse Code today — a terminal coding agent, in public beta for macOS and Linux — powered by Muse Spark 1.2, a coding-focused update co-trained specifically to pair with it.
The architecture: agents that don't forget between turns
Muse Code's actual bet is persistent background agents. Most coding harnesses spawn a fresh helper sub-agent per task — explore the repo, do the thing, discard the context, repeat next turn. Muse Code's specialized agents "remain active throughout each session, rather than being spawned for individual tasks," which means an agent that has already explored a repository doesn't re-explore it every time the developer asks for something new. They work autonomously in the background and choose when to report back to the main agent rather than being polled.
The other real piece is a local event log: every model call, tool run, approval and edit gets appended to a single source of truth. That makes the runtime replay-exact and restart-safe — after a crash, the agent resumes exactly where it stopped rather than re-deriving state or losing the session. This is the same instinct as Cursor's deterministic training kernel and Liquid's harness-proxy trajectory capture, pointed at runtime instead of training: an agent session you can audit and resume is a fundamentally different artifact than one you can only restart from scratch.
Three bundled skills sit on top of the loop: /plan turns a task into a plan the developer has to approve before execution starts, /grill stress-tests that plan before any code gets written, and /goal works toward a specified objective rather than a fixed instruction sequence. The ordering is the interesting part — plan, then adversarially pressure-test the plan, only then execute — which puts a checkpoint before the expensive part of a long-running task rather than after.
Muse Spark 1.2 was co-trained specifically to exploit this — Meta says it "exhibits its best performance and coding usability when paired" with Muse Code, not as a general-purpose model that happens to run in it. Concretely, training included rejection-sampled harness trajectories and recipe optimizations tuned for goals, compaction and sub-agents specifically, plus direct integration of the Muse Code toolset. That's a model trained against the actual harness it ships with, not a general model retrofitted into one — the same coupling Liquid described for LFM2.5's agentic RL inside real harnesses, here extended to the harness Meta itself controls.
The training data for that also has a self-improvement loop worth naming: Meta used Muse Spark 1.1 to generate challenging coding environments and instruction-following templates, then had it grade candidate solutions against those self-generated requirements — a scalable way to manufacture a training set for 1.2 without waiting on more human-labeled tasks. It's a lighter-weight cousin of the teacher-distillation approach LFM2.5 used for MOPD: the older checkpoint doesn't just generate data, it grades its successor's homework.
The gains over 1.1 are real on Meta's own numbers: Terminal-Bench 2.1 from 76.2 to 82.9, DeepSWE 1.1 from 53.0 to 59.3. On the harder independent comparison it's third — DeepSWE 1.1 puts Muse Spark 1.2 at 59.3%, behind Claude Opus 5 (65.0%) and GPT-5.6 Terra (64.8%). On Meta's own internal coding benchmark it leads Terra (70.6 vs 65.4) and Gemini 3.6 Flash (63.9) — read that gap the way this blog reads every vendor's self-graded chart: real, not neutral.
The case study Meta actually ran: 24 hours of kernel optimization
Buried past the architecture pitch is the one result in this launch that isn't a static benchmark table — a live agentic run, and it's more informative than the leaderboard numbers above precisely because it's narrower.
The task: optimize KDA and MLA GPU kernels for NVIDIA Hopper, iteratively — write, compile, profile, improve, repeat — against a provided baseline, for over 1,000 tool calls, up to 24 hours, inside Muse Code's own agentic environment. Meta charted speedup-versus-baseline against cumulative tool-call count for six models:
| Model | Final speedup vs. baseline |
|---|---|
| Claude Opus 5 | +75.4% |
| Claude Opus 4.8 | +67.1% |
| GPT-5.6 Sol | +62.9% |
| Muse Spark 1.2 | +61.1% |
| GPT-5.6 Terra | +47.7% |
| Gemini 3.6 Flash | +39.1% |
Two things worth reading off the curve rather than the endpoint. Muse Spark 1.2 gets to its plateau early — a sharp jump to roughly 60% within the first few hundred tool calls — and for a long middle stretch it actually sits ahead of GPT-5.6 Sol, before Sol closes the gap and edges narrowly past it by the final tally. And both Claude models pull away early and stay away: Opus 5 is 14 points clear of Muse Spark 1.2 at the finish, a gap this task never closes.
That's a more honest picture than the leaderboard tables above give you, in both directions. It confirms Muse Spark 1.2 is a real contender against the mid-tier of frontier coding models on a genuinely hard long-horizon task, not just on benchmarks designed to be gameable — but it's one workload, self-selected and self-run by Meta, on a domain (GPU kernel optimization) that plays to whatever this model was tuned for. Worth remembering as one data point, not a verdict.
The pricing: two tiers, and the second one is the story
Standard API pricing is $1.25 input / $4.25 output per million tokens — cheaper than GPT-5.6 Terra's $2/$12, pricier than Luna's post-cut $0.20/$1.20, roughly mid-table. Unremarkable on its own.
The contributor tier is not unremarkable: $0.10 input / $0.20 output, cached input at $0.002 — roughly 12× and 21× cheaper than standard — in exchange for explicit permission to train future Meta models on your prompts and completions.
Every lab's free and cheap tiers already do something like this implicitly; usage terms for consumer chat products have quietly authorized training on conversations for years. What's different here is that Meta named the number. A 90%+ discount for training rights isn't a checkbox buried in a ToS update — it's a price, set deliberately, that puts an explicit dollar value on the thing most products give away as a default you have to notice and opt out of. It's the clearest public statement yet of what developer usage data is actually worth to a lab building a coding model, expressed as a discount rather than as a hidden clause.
What to expect next
- The contributor-tier discount becomes the template. Once one major lab prices data rights explicitly rather than burying them, expect competitors to either match the transparency or get asked why they don't.
- Persistent background agents get copied faster than the pricing does. The architecture is the genuinely portable idea here; every harness vendor watching this launch just saw session-scoped sub-agents look dated.
- The kernel-optimization case study invites replication. It's a single self-run workload today; the natural next step for anyone skeptical of the curve is running the same task on the same models independently.
References: Meta AI Research — Introducing Muse Code and Muse Spark 1.2 · VentureBeat — Meta enters the AI coding wars · MarkTechPost — Muse Code beta coverage · BigGo Finance — the contributor tier · related coverage: The Price War Nobody Is Actually Fighting · Mixture-of-Kittens · LFM2.5-2.6B