Muse Code and Muse Spark 1.2: Meta's First Real Coding Agent, Fully Explained

Key Takeaways

• Muse Code is Meta's first purpose-built coding agent, installable on macOS and Linux, running on the new Muse Spark 1.2 model.

• Muse Spark 1.2 is a coding-focused update to 1.1 — same context window, same standard price, but co-trained with the Muse Code harness itself.

• On Meta's own benchmarks, Muse Spark 1.2 edges out GPT-5.6 Terra and Grok 4.5 on Terminal-Bench 2.1, but trails Claude Opus 5 on every published coding metric.

• The real story of this launch is pricing: a "contributor" API tier cuts costs by 12.5x–92%, in exchange for letting Meta train on submitted prompts and completions.

• One day after this launch, on August 10, 2026, Meta open-weighted a smaller model (Muse Glimmer) and signaled that open weights for Muse Spark 1.2 itself may follow "soon."

• Muse Code is beta software — evaluate it as a promising but early entrant, not a like-for-like replacement for Claude Code or Codex yet.

On August 5, 2026, Meta Superintelligence Labs released Muse Code, a beta terminal coding agent for macOS and Linux, powered by Muse Spark 1.2, a coding-focused update to July's Muse Spark 1.1. The pairing marks Meta's first real entry into the agentic coding market already occupied by Anthropic's Claude Code, OpenAI's Codex, and Google's Antigravity. Muse Spark 1.2 is available through the Meta Model API in two pricing tiers — a standard rate and a heavily discounted "contributor" tier — and posts meaningful gains over 1.1 on agentic coding benchmarks, though it still trails Claude Opus 5 on Meta's own published scores.

What Are Muse Code and Muse Spark 1.2?

Muse Code and Muse Spark 1.2 are two connected products from Meta Superintelligence Labs:

• Muse Spark 1.2 is the underlying large language model — a coding-specialized upgrade to Muse Spark 1.1 with expanded training on complex debugging, codebase understanding, and long-horizon developer workflows.

• Muse Code is the terminal-based agent harness built to run on top of Muse Spark 1.2. It installs directly in a command line, plans multi-step engineering work, edits code across large repositories, runs tools, and verifies its own output.

Meta designed the two together rather than adapting a general-purpose model for coding after the fact. According to Meta's official announcement, Muse Spark 1.2 was co-trained inside the Muse Code runtime itself, using rejection-sampled agent trajectories and recipe tuning for goal-tracking, context compaction, and sub-agent coordination — so the model's behavior and the harness's design were optimized together rather than bolted on separately.

What Is Muse Code? Key Features

Muse Code is currently in beta and installs on macOS and Linux with a single terminal command from dev.meta.ai. It targets whole-repository engineering tasks rather than single-function autocompletion. Its core design choices include:

Persistent Async Background Agents

Instead of spinning up a fresh sub-agent for every small task, Muse Code runs specialized background agents that stay active for the full session. These agents gather information proactively, carry out follow-up steps on their own, and only report back to the main agent when needed — reducing redundant work and cutting down on how often a developer has to steer the agent manually during long, multi-step jobs. Meta reports having built six features for a game simultaneously with no collisions between sub-agents, each isolated in its own git worktree.

Replay-Exact, Restart-Safe Runtime

Muse Code keeps a local, append-only event log recording every model call, tool execution, approval, and file edit. Because the log is a single source of truth, a session can resume exactly where it left off after a crash or interruption — a meaningful reliability feature for tasks that run for hours.

Bundled Skills

Three default skills ship with the agent:

• /plan — converts a task into an approval-gated execution plan before any code changes happen.

• /grill — stress-tests that plan for weaknesses before execution begins.

• /goal — keeps the agent working toward a specified objective across many steps.

Video Link: Meta

Multimodal Task Input

Meta's own demo shows Muse Code taking a fly-through video of a house as an .mp4 input and generating a complete vacation-rental marketing and booking webpage from it, illustrating that the harness can consume more than just text prompts and existing code.

Getting Started with Muse Code

Muse Code installs with a single terminal command, confirmed directly from Meta's launch post:

bash

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

Once installed, a practical first session looks like this:

1. Run /plan on a real task — point Muse Code at an actual repository issue or feature request first, rather than a toy prompt, so the approval-gated plan reflects real codebase constraints.

2. Use /grill before approving — let the agent stress-test its own plan for edge cases before any code changes are made.

3. Set a scope with /goal — for multi-step work, define the objective explicitly so background agents stay aligned across a long session.

4. Choose your API tier before running high-volume jobs — standard vs. contributor pricing (see below) matters more once you move past a single test session, since the two tiers differ by a double-digit multiple in cost.

Since Muse Code is in beta on macOS and Linux only, Windows users currently need WSL or a Linux VM to try it.

Muse Spark 1.2 vs Muse Spark 1.1: What's Actually Different?

Muse Spark 1.2 is explicitly framed by Meta as a coding-focused update rather than a full generational leap, and the differences are concentrated in three areas: training focus, harness integration, and measured coding performance.

A few caveats are worth noting for anyone comparing the two generations directly. Meta paired each model version with a different agent harness for its coding evaluations — 1.1 ran inside the generic mini-SWE agent, while 1.2 ran inside the purpose-built Muse Code. That means the reported gains reflect the combined improvement of the model, the harness, the system prompt, and the compaction and sub-agent logic together, not the underlying model in isolation. Meta's own evaluation methodology document states this explicitly, noting that agentic evaluations for third-party models are best-effort reproductions and may not reflect those competitors at their strongest configuration.

What stays constant between the two versions is the roughly 1-million-token context window and the standard API price. What changes is coding-specific capability, plus the addition of a genuinely new product — Muse Code — that 1.1 never had.

Muse Spark 1.2 Benchmarks: How It Performs

Meta evaluated Muse Spark 1.2 against Muse Spark 1.1, Grok 4.5, Claude Opus 5, GPT-5.6 Terra, Gemini 3.6 Flash, and Kimi K3 — each running inside its own preferred agent product (Muse Code, Grok Build, Claude Code, Codex, Antigravity, and Kimi Code, respectively) at each model's maximum reasoning setting.

Coding

General Agents:

Reading these results in context matters more than the headline numbers alone. On Terminal-Bench 2.1 — a benchmark of real command-line software engineering tasks — Muse Spark 1.2 edges out both GPT-5.6 Terra and Grok 4.5 by roughly a point, but trails Claude Opus 5 by close to four points. On DeepSWE 1.1, it lands in third place behind Opus 5 and GPT-5.6 Terra. On Meta's own internal coding benchmark — the one test Meta itself designed — Muse Spark 1.2 still finishes nearly nine points behind Claude Opus 5, which VentureBeat's independent analysis of the launch has flagged as an unusually candid result for a company presenting its own model.

It's also worth noting who is missing from Meta's comparison set: GPT-5.6 Sol, OpenAI's flagship model (as opposed to the cost-balanced Terra variant), and Anthropic's Claude Fable 5 do not appear in Meta's published charts, which several outlets have pointed out limits how far the "beats GPT-5.6" framing can be generalized.

Case Study: Autonomous GPU Kernel Optimization

One of the more distinctive tests Meta ran involved letting Muse Spark 1.2, operating inside Muse Code, iteratively optimize GPU kernels across more than 1,000 tool calls over sessions lasting up to 24 hours. The model wrote, compiled, profiled, and progressively improved kernel implementations for two workloads on NVIDIA Hopper GPUs:

KDA (Kernel Data Attention): benchmarked against the FLA Triton reference implementation, with models barred from importing third-party kernel libraries directly. Muse Spark 1.2 combined a chunk-parallel preparation kernel with a sequential inter-chunk scan, plus KDA-specific tricks like re-centring the gated cumulative decay at the chunk midpoint.

MLA (Multi-Head Latent Attention): benchmarked against a PyTorch reference at batch size 1, 64 attention heads, sequence length 8,192, and latent dimension 512. The model built a two-kernel Triton pipeline that reused the shared key-value latent for both the K and V roles.

In both cases, Meta reports the agent achieved substantial, sustained speedups over the provided baselines as the tool-call count climbed — a demonstration aimed squarely at showing long-horizon, self-correcting agentic behavior rather than one-shot code generation.

Muse Spark 1.2 API: Access, Models, and Capabilities

Muse Spark 1.2 is available today through the Meta Model API with expanded global access beyond the US-only rollout that accompanied Muse Spark 1.1's public preview. The API uses an OpenAI-compatible request format, which means existing SDK integrations built for other providers typically need only a base URL and model name change to route traffic to Muse Spark 1.2.

Key technical specifications reported for the API:

• Context window: approximately 1,048,576 tokens (roughly 1 million tokens).

• Input modalities: text, images, video, audio, and PDF documents.

• Output modality: text only.

• Capabilities: structured output, parallel function calling, and configurable reasoning effort (Meta ran its own evaluations at "xhigh" reasoning effort).

• Agent compatibility: designed to work as either a lead planning/delegating agent or a subagent executing in parallel, and is compatible with multiple third-party coding harnesses in addition to Muse Code.

Two model identifiers are published for the same underlying weights — muse-spark-1.2 for the standard tier and muse-spark-1.2-contributor for the discounted, data-sharing tier described below. The earlier muse-spark-1.1 identifier remains listed separately for developers still on the previous generation.

Muse Spark 1.2 Pricing: Standard vs. Contributor Tier

The most talked-about part of the launch isn't a benchmark chart — it's the pricing structure. Meta offers Muse Spark 1.2 through two tiers on the exact same model checkpoint, differing only in whether Meta may use a developer's prompts and completions to help train future Meta models.

That works out to roughly a 12.5x discount on input tokens, a 21x discount on output tokens, and a 75x discount on cached input tokens for developers who opt into the contributor tier. Standard-tier pricing is unchanged from Muse Spark 1.1's July launch.

To put the savings in concrete terms: a workload of 100 million input tokens and 10 million output tokens costs approximately $167.50 on the standard tier versus roughly $12.00 on the contributor tier — a saving of more than 92%. For a smaller, single agentic turn — say a 40,000-token diff review that produces 6,000 tokens of feedback — standard pricing runs about $0.076, while the contributor rate brings that down to roughly $0.005.

The trade-off is data privacy, not model capability: Meta's documentation frames the contributor tier as the same checkpoint with the same context window and features, just governed by a different data-use agreement. Teams handling proprietary or client codebases will generally want to stay on the standard tier for that reason, while developers working on open-source, throwaway, or non-sensitive projects may find the contributor discount compelling, particularly for high-volume agentic loops that lean heavily on output and cached-context tokens.

Reported rate limits also differ meaningfully between tiers: the standard tier supports substantially higher requests-per-minute and tokens-per-minute ceilings than the contributor tier, so very high-throughput production use cases may need to plan around those caps regardless of which pricing tier is chosen. Developers should confirm current limits directly against Meta's official API documentation, since rate limits and regional availability are the kind of detail most likely to change after launch.

Recent Update: Open Weights May Be Coming

This is worth flagging explicitly because it changes the picture just days after launch: on August 10, 2026 — five days after Muse Code shipped — Meta open-weighted a smaller, 30-billion-parameter model called Muse Glimmer, distilled from Muse Spark and released under Apache 2.0. Alongside that release, both Mark Zuckerberg and Meta AI chief Alexandr Wang said on X that open weights for Muse Spark 1.2 itself — the model actually powering Muse Code — are coming "soon". No date has been confirmed, and this is a stated intention rather than a shipped release, so treat it as directional rather than settled. If it happens, it would put Muse Spark 1.2 in the same self-hostable category as Alibaba's Qwen and Moonshot's Kimi models, rather than the closed-API-only category it currently occupies.

Why This Launch Matters

Meta has spent the last two years primarily known for open-weight Llama releases. Muse Spark, launched in April 2026, marked a shift toward proprietary models; Muse Spark 1.1 in July added Meta's first paid developer API; and now Muse Spark 1.2 with Muse Code represents Meta's first purpose-built coding agent product, arriving roughly a year after Anthropic's Claude Code and OpenAI's Codex established the category. The launch places Meta in direct competition with Claude Code, Codex, xAI's Grok Build, Google's Antigravity, and Moonshot's Kimi Code — a crowded field where cost-per-completed-task, not just raw benchmark leadership, increasingly determines which tool developers actually keep using.

Meta's own benchmark charts show Claude Opus 5 ahead on every published coding metric, which makes the contributor-tier pricing — not headline intelligence scores — the more differentiating part of this release for cost-sensitive teams running large agentic workloads.

Should You Use Muse Code?

Muse Code is a reasonable fit if you:

• Run high-volume, non-sensitive or open-source agentic coding workloads where the contributor tier's 90%+ discount meaningfully changes your economics.

• Want to experiment with persistent, parallel sub-agents and worktree isolation for large, multi-feature jobs.

• Are already building on Meta's model ecosystem and want first-party tooling rather than a third-party harness.

• Are comfortable running beta software and reporting bugs rather than relying on a mature, battle-tested tool.

You'll likely want to stick with Claude Code, Codex, or another established option if you:

• Need the strongest raw coding performance available — Claude Opus 5 leads Muse Spark 1.2 on every benchmark Meta itself published.

• Work primarily on Windows without WSL, since Muse Code currently supports only macOS and Linux.

• Handle proprietary or client codebases and want the cost benefits of a discounted tier — the contributor discount specifically requires giving up that data privacy.

• Want a tool with a longer production track record; Muse Code is beta, and its replay-safe runtime and worktree isolation haven't yet been stress-tested at the scale Claude Code and Codex have.

Limitations to Keep in Mind

• Benchmark comparisons aren't fully apples-to-apples. Each model ran inside its own preferred harness, so reported gains reflect the model, harness, prompt, and compaction logic combined — not the underlying model in isolation.

• Two relevant competitors are absent from Meta's charts: GPT-5.6 Sol (OpenAI's flagship, not the cost-balanced Terra variant) and Anthropic's Claude Fable 5 are not included, which limits how broadly the published comparisons generalize.

• Beta status and platform support: macOS and Linux only, no Windows support yet, and beta software should be expected to have rough edges.

• Output is text-only despite accepting text, image, video, audio, and PDF input — Muse Spark 1.2 cannot generate non-text output directly.

• Contributor-tier rate limits are lower than the standard tier, which may matter for high-throughput production pipelines regardless of the cost savings.

Conclusion

Muse Code and Muse Spark 1.2 represent Meta's first serious, purpose-built answer to the agentic coding tools already offered by Anthropic, OpenAI, xAI, and Google. The model itself is an incremental, coding-focused upgrade rather than a ground-up rebuild — same context window, same standard pricing, and still behind Claude Opus 5 on every coding benchmark Meta chose to publish. What's genuinely new is Muse Code as a product, and the aggressively discounted contributor pricing tier, which could make Muse Spark 1.2 an attractive option for cost-sensitive, high-volume agentic workloads where developers are comfortable trading data privacy for a substantial per-token discount. For the latest specifications, rate limits, and regional availability, check Meta's official Muse Code and Muse Spark 1.2 announcement directly, as pricing and access details for newly launched AI products tend to evolve quickly.

FAQs

What is Muse Code?

Muse Code is Meta's beta terminal coding agent, powered by Muse Spark 1.2, that plans, writes, and validates code changes across entire repositories using persistent background agents and a replay-safe execution log.

What is Muse Spark 1.2?

Muse Spark 1.2 is Meta Superintelligence Labs' coding-focused update to Muse Spark 1.1, with expanded training compute on coding tasks and co-training alongside the Muse Code agent harness.

How is Muse Spark 1.2 different from Muse Spark 1.1?

Muse Spark 1.2 keeps the same roughly 1-million-token context window and standard pricing as 1.1, but adds significantly more coding-focused training, was co-trained with the new Muse Code harness, and scores several points higher on Terminal-Bench 2.1 and DeepSWE 1.1 when evaluated inside its own agent.

How much does the Muse Spark 1.2 API cost?

Standard pricing is $1.25 per million input tokens and $4.25 per million output tokens. A discounted "contributor" tier costs $0.10 per million input tokens and $0.20 per million output tokens, in exchange for allowing Meta to use submitted prompts and completions to improve future models.

Is Muse Spark 1.2 better than Claude or GPT models at coding?

Not according to Meta's own published benchmarks. Claude Opus 5 outperforms Muse Spark 1.2 on Terminal-Bench 2.1, DeepSWE 1.1, and Meta's internal coding benchmark, though Muse Spark 1.2 does edge out GPT-5.6 Terra and Grok 4.5 on Terminal-Bench 2.1.

Where can I access Muse Spark 1.2?

Through the Meta Model API (model IDs muse-spark-1.2 and muse-spark-1.2-contributor) and through the Muse Code terminal agent, installable on macOS and Linux via curl -fsSL https://dev.meta.ai/install.sh | bash.

Will Muse Spark 1.2 become open-weight?

It isn't yet, but as of August 10, 2026, Meta executives have publicly signaled that open weights for Muse Spark 1.2 are coming "soon," alongside the open-weight release of the smaller Muse Glimmer model. No confirmed date exists yet.