Meta Just Dropped Its Own Coding Agent: What Muse Spark 1.2 and Muse Code Actually Do

Meta shipped Muse Code on August 5, 2026, a terminal coding agent in public beta for macOS and Linux, running on a new model called Muse Spark 1.2 with a 1,048,576-token context window. It's the first coding product out of Meta Superintelligence Labs, and it scores 82.9% on Terminal-Bench 2.1, second to Claude Opus 5's 86.7%. Meta published that chart anyway, which tells you something.

Here's what's actually in the box, what the numbers say, and the pricing detail nobody should skip past.

What is Muse Spark 1.2?

Muse Spark 1.2 is a coding-focused update to Muse Spark 1.1, which landed back in July. Meta says it poured a lot more training compute into coding specifically and widened the variety of environments the model trained in, including whole-repository generation, large end-to-end projects, and auto-research.

The headline specs:

That million-token window matters more than usual here. Meta's pitch is that a long coding task should fit in one session start to finish, without the agent constantly re-reading files it already looked at.

What does Muse Code actually do?

This is the more interesting half. Muse Code isn't a chat box with syntax highlighting. It's a terminal agent meant to take a task from "here's the bug" to "here's the validated fix," across a repo big enough that no human wants to explain it first.

Three design choices stand out.

Background agents that stick around. Most agent harnesses spawn a sub-agent, get an answer, kill it, and spawn another one for the next question. Muse Code keeps a simple main agent loop plus persistent async background agents that stay alive for the whole session. They carry out next steps on their own and decide when to report back. The point is to stop re-gathering the same information over and over, which is where a lot of agent token spend quietly goes.

A crash-safe event log. Every model call, tool run, approval, and edit gets appended to a local log. Meta describes the runtime as "replay-exact and restart-safe." Kill the process mid-refactor and it picks up exactly where it stopped. If you've ever lost 40 minutes of agent work to a dropped SSH session, you already know why this is on the feature list.

Three bundled skills.

• /plan turns a task into an approval-gated plan, so nothing gets written until you say yes
• /grill stress-tests that plan and pokes holes in it before you commit to the approach
• /goal grinds toward a stated objective and keeps going

The combination is aimed squarely at long, messy work. Meta's flagship demo was a GPU kernel optimization run on NVIDIA Hopper hardware that burned through 1,000+ tool calls over as much as 24 hours, ending with a chunk-parallel preparation kernel plus a sequential inter-chunk scan that beat the provided baseline. That's not a "write me a React component" demo. That's a bet on long-horizon autonomy, and it's the same bet xAI made with Grok Build and its parallel sub-agents.

Installing it is one line:

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

I ran that on a Linux box the morning it dropped. Install was clean, the TUI is spartan in a way that will feel familiar if you live in Claude Code or Codex, and /plan produced a sane approach on a mid-size TypeScript repo. I haven't run a 24-hour job on it, so I can't vouch for the crash-recovery claim from experience yet. Nobody outside Meta can, really. It's a week-old beta.

How does Muse Code compare to Claude Code and Codex?

Here's where Meta did something unusual. They published the benchmark table where they lose.

Claude Opus 5 at max effort wins all three, including the benchmark Meta built and named after itself. Vendors do not usually ship the chart where they come second. Credit where it's due.

Read the methodology before you read too much into the gaps, though. Meta ran each model inside its own vendor harness: Muse Code for Spark 1.2, Claude Code for Opus 5, Codex for GPT-5.6 Terra, Grok Build for Grok 4.5, Antigravity for Gemini, Kimi Code for K3, and mini-swe-agent for the older Muse Spark 1.1. That's arguably the fairest way to compare products people actually use, but it means you're benchmarking agent-plus-model pairs, not models. Meta also notes its harness may not be tuned for third-party models.

The generational jump is real regardless. Muse Spark 1.2 is up 6.7 points on Terminal-Bench and 6.3 on DeepSWE over 1.1, which shipped about a month earlier. Meta is iterating fast, and Opus 5's own pricing pressure is clearly part of why.

The pricing has a catch worth reading twice

Standard tier: $1.25 per million input tokens, $0.15 cached, $4.25 output. That undercuts most frontier coding models already.

Contributor tier: $0.10 input, $0.002 cached, $0.20 output. That's 12.5x cheaper on input, 21x on output, and 75x on cached input. Depending on the shape of your agent steps, the swing between tiers can approach 100x on a real workload.

So what does the discount cost? Meta may use your traffic to improve its models. You're also capped at 60 requests per minute.

Think about what a terminal coding agent reads. Not a prompt. Your whole repo. Source, internal API surfaces, comments where someone explained the actual business logic, test fixtures with realistic-looking data. Choosing the contributor tier isn't a billing decision, it's a data-handling decision, and it should probably involve someone other than whoever holds the credit card. For a side project, take the 100x discount and don't think about it again. For work code under an NDA, that conversation goes differently.

Meta deserves points for making the tradeoff explicit rather than burying it in a terms-of-service diff. But the framing of "contributor" is doing a lot of gentle work there.

The co-training angle: real, or marketing?

Meta keeps stressing that Muse Spark 1.2 and Muse Code were co-trained, not bolted together after the fact. The training included harness trajectories (recordings of the agent using its own tools), rejection sampling, and recipe optimizations targeting planning, context compaction, and subagent coordination.

The claim is that this produces better tool use, fewer wasted retries, and less babysitting than wrapping a general model in someone else's framework.

I think it's directionally true and partly unfalsifiable. Anthropic and OpenAI have been doing versions of this for a while, and the co-training story is convenient when your model happens to look best inside your own harness. What I'd want, and what nobody has yet, is a month of independent reports on how often Muse Code stalls, loops, or quietly does the wrong thing on a real codebase. Benchmarks measure the good day.

Should you switch?

No. Not yet, and probably not because of this launch.

If you already have a coding agent that works for you, Muse Code isn't offering enough to justify rebuilding your workflow around a week-old beta with no Windows build, no GUI, and no IDE integration. The benchmark deltas are small enough that harness tuning could explain half of them.

What it's genuinely worth doing:

1. Install it on a scratch repo. It's one curl command and costs almost nothing on the contributor tier if the code isn't sensitive.
2. Try /grill specifically. Plan stress-testing before execution is the most novel thing here, and it's the kind of feature other agents will copy if it works.
3. Compare on one real task, not a toy one. Long-horizon work is the whole claim.
4. Decide the tier question deliberately. Don't let the 100x savings make it for you.

The bigger story isn't Meta's scorecard. It's that a fourth serious player now ships a co-trained model-and-agent pair, weeks after Grok Build and alongside constant iteration in Claude Code and Google's Gemini line. Four vendors racing on the same product shape, all pricing aggressively, all publishing benchmarks. Developers win that fight by default.

Check back in a month. That's when we'll know whether the event log actually saves anyone's afternoon.

Official Announcements

Meta's full write-up is on the Meta AI Research blog, and the evaluation methodology is worth a read if you care how those benchmark rows were produced.