Meta Muse Code & Muse Spark 1.2: Complete Guide, Verified Benchmarks & Pricing (August 2026)

By AiCybr Editorial · Published August 6, 2026

Just released: Meta shipped Muse Code (beta) and Muse Spark 1.2 on August 5, 2026. The headline 82.9% Terminal-Bench claim is Meta-reported and not yet on the official verified leaderboard. Independent Vals testing ranks it 14th on common-harness Terminal-Bench but 5th overall on the Vals Index at a remarkable $0.69 per test. The Contributor pricing tier at $0.10/$0.20 per million tokens is the most aggressive pricing from any capable coding model today.

Navigate This Guide

• What Muse Code and Muse Spark 1.2 are
• Benchmark results: the honest picture
• The Plan-Grill-Goal workflow
• How Muse Code works under the hood
• Multimodal capabilities
• Installation and getting started
• API integration and code examples
• Pricing and tiers explained
• Where to access Muse Spark 1.2
• Comparison: Muse Code vs Claude Code, Cursor, Grok Build
• Limitations and risks
• Who should use Muse Code
• Frequently asked questions
• Final verdict
• Sources

What Muse Code and Muse Spark 1.2 Are

Meta released Muse Code (public beta) and Muse Spark 1.2 on August 5, 2026. The two are distinct but designed together:

Muse Spark 1.2 is Meta’s proprietary coding-focused reasoning model. It interprets tasks, reasons about repositories, decides how to use tools, and generates or reviews code.

Muse Code is the terminal agent built around Muse Spark 1.2. It provides everything the raw model lacks: repository inspection, file editing, shell and test execution, planning workflows, parallel subagents, Git worktree isolation, persistent session state, local action logging, and crash recovery.

Meta reports the model and agent were co-trained — Muse Spark 1.2 learned inside the same agent environment it operates in at inference. This co-design explains why Meta’s integrated system score diverges from what the model achieves under a generic third-party harness.

At a Glance

Note on parameters: Meta has not disclosed parameter counts for Muse Spark 1.2, mirroring Anthropic’s approach with Claude models. The company prefers external benchmarking over headline numbers.

Benchmark Results: The Honest Picture

There are three separate benchmark views of Muse Spark 1.2. Understanding why they disagree is more valuable than picking the one that flatters the model.

Signal Summary

Meta’s Launch Benchmarks (Vendor-Reported)

These numbers compare complete systems — each model using its preferred first-party agent. They are useful for comparing products but are not controlled model-only tests.

Terminal-Bench 2.1 — Meta system comparison

DeepSWE 1.1 — Meta-reported

Independent Common-Harness Results (Vals)

Vals evaluates every model on Terminal-Bench 2.1 using Terminus 2 — the same harness for all models, eliminating first-party agent advantages.

Vals Terminal-Bench 2.1

Vals Index v1.2 (Combined Coding + Finance)

The $0.69 per test cost is Muse’s strongest independent result — the lowest among the Vals top-five models, making it highly attractive for high-volume workloads even without leading on raw accuracy.

Official Verified Terminal-Bench 2.1 Leaderboard (tbench.ai)

The official leaderboard is the most rigorous: a Terminal-Bench team member personally reruns and verifies each submission.

Source: tbench.ai/leaderboard/terminal-bench/2.1?verified=true

Why the Three Views Disagree

Agent system prompt, reasoning budget, retry policy, context retrieval, number of subagents, time limits, and sandbox configuration can each move results by several percentage points. For coding agents, the harness is part of the product.

The Accurate Interpretation

1. Muse Code materially helps performance. The model was trained with its agent; a generic harness may not reproduce the same behavior.
2. Muse is highly competitive on price-performance. 5th on Vals Index at $0.69/test is more compelling than any single launch score.
3. Quality-first leaders remain ahead under independent testing. GPT-5.6 Sol, Claude Opus 5, Kimi K3, and Claude Fable 5 lead independent evaluations.

The Plan-Grill-Goal Workflow

Muse Code is designed around a three-phase workflow addressing the two most common agent failure modes: misunderstanding requirements, and silently improvising at edge cases.

Phase 1: /plan — Structured Execution Plan

muse /plan "Add Stripe webhook handling with retry logic and idempotency keys"

/plan converts your request into an approval-oriented execution plan with a clear phase breakdown, dependency ordering, and an approval gate — Muse Code will not proceed until you explicitly approve. Many agents silently proceed on their own interpretation. Muse Code surfaces its understanding first so you catch mismatches before any code is written.

Phase 2: /grill — Stress-Test the Plan

muse /grill

After plan approval, /grill proactively challenges the plan for edge cases and missing requirements — a devil’s advocate before implementation begins.

Example outputs:

• “What happens if the webhook arrives twice within 500ms?”
• “The retry logic doesn’t handle 429 rate-limit responses from Stripe.”
• “The idempotency key scope doesn’t account for partial delivery failures.”

Phase 3: /goal — Autonomous Execution

muse /goal

After both approvals, /goal initiates execution with background context agents, parallel Git worktree fan-out for large tasks, and the append-only event log recording every action. You can interrupt at any time — resuming is replay-exact.

Recommended Full Workflow

1. Request a repository audit before any edits
2. Use /plan to define scope, files, interfaces, tests, and rollback path
3. Use /grill to challenge assumptions and edge cases
4. Approve only the revised plan
5. Use /goal for execution
6. Review the complete diff and rerun critical tests independently

How Muse Code Works Under the Hood

Co-Training With the Agent Harness

Muse Spark 1.2 was co-trained with the Muse Code harness from the start. The model learned when to inspect vs. edit, how to verify a result, when to delegate, and how to preserve progress across a long task. This co-design explains the gap between Meta’s integrated system score and the common-harness ranking.

Persistent Background Agents

Muse Code maintains four agent types simultaneously:

• Coordinator: Decomposes tasks, routes work, manages approvals
• Explorer agents: Read files, search codebases, gather context asynchronously
• Executor agents: Write code, run tests, make commits
• Verifier agents: Check output quality, run linters, validate against requirements

These agents communicate through the shared event log, which also serves as the restart-safe state store. Persistent agents preserve repository understanding across a long session — most valuable on large migrations, multi-package monorepos, and repeated test-and-fix loops.

Parallel Execution With Git Worktrees

For large tasks, Muse Code divides work among subagents in separate Git worktrees — separate filesystem snapshots of your repository, preventing simultaneous file conflicts.

Good uses: Independent backend and frontend changes; implementation and adversarial review in parallel; separate platform ports.

Poor uses: Tightly coupled edits with an unstable interface; database migrations and callers changed independently.

Important: A Git worktree isolates branches and working directories. It does not sandbox credentials, network access, or the filesystem. Do not treat it as a security sandbox.

The Append-Only Event Log

Every model call, tool invocation, file edit, and approval is written to a local append-only JSON event log in your project’s .muse/ directory. If Muse Code crashes, running muse again reads the log, reconstructs agent state, and resumes from the last checkpoint.

Multimodal Capabilities

Muse Spark is natively multimodal. The 1.2 endpoint supports text, images, video, audio, and PDF input.

High-value coding uses:

• Screenshot-to-code: Combine a screenshot with repository access to locate layout causes, modify the implementation, run the app, and inspect the result iteratively
• UI regression investigation: Correlate a visible defect with source changes using expected/failing screenshots alongside Git diffs
• PDF specification review: Compare a product spec against a repository to identify missing implementation
• Video analysis: Screen recordings expose focus loss, flickering, race conditions, and layout shifts
• Diagram-to-repository validation: Compare architecture or database diagrams against actual implementation

Important: Muse Spark is the reasoning model. Muse Image and Muse Video are separate generation models.

Installation and Getting Started

Muse Code is available on macOS and Linux only. Windows is on the roadmap. Always refer to dev.meta.ai/docs/muse-code for current instructions — this is a beta product.

# Step 1: Install
curl -fsSL https://dev.meta.ai/install.sh | bash

# Step 2: Authenticate (opens browser, new accounts get $20 free credits)
muse auth

# Step 3: Start in your project directory
cd /path/to/your/project
muse

# Step 4: Run your first task
muse /plan "Refactor the authentication middleware to use JWT instead of session cookies"

Before your first run: Use a fork, clean branch, or temporary clone with no production credentials. Do not run Muse Code against a live production repository first.

API Integration and Code Examples

Muse Spark 1.2 is available at api.meta.ai/v1, drop-in compatible with the OpenAI SDK and Anthropic SDK.

Python (OpenAI SDK)

from openai import OpenAI

client = OpenAI(
    base_url="https://api.meta.ai/v1",
    api_key="YOUR_META_API_KEY",
)

response = client.chat.completions.create(
    model="muse-spark-1.2",          # or "muse-spark-1.2-contributor"
    messages=[
        {"role": "system", "content": "You are an expert software engineer."},
        {"role": "user", "content": "Review this Python function for race conditions: ..."}
    ],
    max_tokens=4096,
)
print(response.choices[0].message.content)

TypeScript (OpenAI SDK)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.meta.ai/v1",
  apiKey: process.env.META_API_KEY,
});

const response = await client.chat.completions.create({
  model: "muse-spark-1.2",
  messages: [{ role: "user", content: "Explain the bug in this TypeScript code: ..." }],
  max_tokens: 8192,
});
console.log(response.choices[0].message.content);

Streaming

with client.chat.completions.stream(
    model="muse-spark-1.2-contributor",
    messages=[{"role": "user", "content": "Write a complete REST API for a blog..."}],
    max_tokens=16384,
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Via OpenRouter

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key="YOUR_OPENROUTER_KEY")
response = client.chat.completions.create(model="meta/muse-spark-1.2", messages=[...])

Note: OpenRouter does not offer Contributor tier pricing. Use api.meta.ai/v1 directly with muse-spark-1.2-contributor to access Contributor rates.

Pricing and Tiers Explained

Full Pricing Table

All prices per 1 million tokens. Contributor is ~12.5x cheaper for fresh input, ~75x for cached input, ~21.25x for output.

Rate Limits

Market Pricing Context

Which Tier to Use

The Contributor discount is a data contribution arrangement, not a volume discount. The decision should be made by the code owner, not only the developer running the agent.

Where to Access Muse Spark 1.2

New accounts receive $20 in free credits at dev.meta.ai.

Comparison: Muse Code vs Claude Code, Cursor, Grok Build

Feature Matrix

Honest Verdicts

Claude Code — gold standard for raw quality on hard, complex problems. Vals (84.64%) and the verified leaderboard (Fable 5 + Claude Code: 83.8%) confirm this lead. The cost is real: Opus 5 at $5/$25 per million tokens is 4× Muse Standard and 50× Muse Contributor on output.

Cursor — best for IDE-native development. Composer mode and multi-model flexibility make it highest-leverage for daily feature development. Not a terminal agent — a fundamentally different category.

Grok Build (Apache 2.0) — the transparent option. Read, fork, and modify the harness; use any model endpoint. 79.3% verified score is competitive. The choice when open-source transparency is the priority.

Muse Code wins on:

1. Cost at scale — Contributor tier is the cheapest capable agent; Vals-measured $0.69/test confirms this practically
2. Long-running task reliability — persistent agents, replay-exact logs, and git worktree parallelism differentiate it for sessions spanning hours

Limitations and Risks

• No Windows support. macOS and Linux only at launch.
• No multi-model routing. Locked into Muse Spark 1.2.
• No IDE integration. No VS Code, JetBrains, or Neovim plugin at launch.
• No MCP support. Planned but unavailable in the August beta.
• Contributor tier data privacy. Prompts and completions at $0.10/$0.20 may train future Meta models. Not acceptable for most professional or enterprise work.
• Benchmarks are vendor-reported. The 82.9% Terminal-Bench result is not on the official verified leaderboard. Vals places the model 14th out of 50 under a common harness.
• No SWE-bench Pro score. Cannot compare directly with Claude Fable 5 (80.3%) or GLM-5.2 (62.1%).
• Beta status. Expect rough edges and breaking changes.

Data Privacy by Tier

Review dev.meta.ai/legal before any production deployment.

Who Should Use Muse Code

Strong fit

• Long terminal-based tasks on non-sensitive code
• Large repositories benefiting from persistent session context
• Open-source development where Contributor pricing makes costs negligible
• High-volume subagent workloads where $0.69/test economics matter
• Visual frontend debugging using screenshot-to-code multimodal workflows

Use selectively (alongside a stronger model)

• Architecture-sensitive decisions — compare with GPT-5.6 Sol or Claude Opus 5
• Security-critical implementation — use a premium model plus independent review

Poor fit

• Source code that cannot leave your infrastructure (use Kimi K3, GLM-5.2, or DeepSeek V4 Flash)
• Windows-native workflow required
• Beta services prohibited by organizational policy
• Multi-model routing needed inside one tool (use Cursor or Grok Build)
• Contributor data use conflicts with ownership or compliance obligations

Frequently Asked Questions

Is the 82.9% Terminal-Bench score verified?

No. It is Meta-reported for the Muse Spark 1.2 + Muse Code integrated system. As of August 6, 2026, Muse Spark 1.2 is not listed on the official Terminal-Bench 2.1 verified leaderboard at tbench.ai.

Why does Vals rank it 14th on Terminal-Bench but 5th overall?

Vals runs Terminal-Bench with Terminus 2 — the same harness for every model — where Muse loses its first-party agent advantage. The Vals Index also includes SWE-bench Verified, Vibe Code Bench, and finance tasks, where Muse’s broader performance and low $0.69/test cost improve its overall position substantially.

What is the difference between muse-spark-1.2 and muse-spark-1.2-contributor?

Same underlying model. The contributor ID accesses a lower rate ($0.10/$0.20/1M tokens) in exchange for permission to use your data for future model training. It also has lower rate limits (60 RPM vs 3,000 RPM).

Is Muse Code the same as Muse Spark 1.2?

No. Muse Spark 1.2 is the model. Muse Code is the terminal agent that gives the model repository access, tools, planning, parallel subagents, worktrees, logging, and crash recovery.

Is a Git worktree a security sandbox?

No. It isolates branches and working directories. It does not sandbox credentials, network access, processes, or the filesystem.

Does Muse Code support MCP?

MCP integration is planned but not available in the August 5 beta. Claude Code has mature MCP support.

Is Muse Spark 1.2 open source or open weights?

No. It is a closed, proprietary model with no public weights — fundamentally different from Meta’s Llama family.

Should enterprises use the Contributor tier?

Not without explicit approval from legal, security, data governance, and code owners. Contributor permits Meta to use prompts and completions to improve future models.

Can I use Muse Spark 1.2 without Muse Code?

Yes. Available via api.meta.ai/v1 and OpenRouter (meta/muse-spark-1.2) — call it like any standard language model API.

Final Verdict

Muse Code is a serious new coding agent. The reason to test it is not the 82.9% launch score — that is a Meta-reported integrated-system result not yet on the official verified leaderboard.

The evidence-based case:

• 5th place on the Vals Index across 45 models (71.88%)
• $0.69 per test — lowest cost among the Vals top five
• 1M token context with 131K output
• Persistent, parallel, recoverable agent execution that competitors lack
• Contributor pricing ($0.10/$0.20/1M) that is 50× cheaper than Claude Code on output tokens

The benchmark caution:

• 14th of 50 on Vals common-harness Terminal-Bench
• Not yet verified on the official tbench.ai leaderboard
• GPT-5.6 Sol, Claude Opus 5, Kimi K3, and Fable 5 lead independent evaluations on raw accuracy

Muse Spark 1.2 is a compelling price-performance and orchestration option — not yet an automatic replacement for premium coding models.

Decision Framework

The best adoption path: run a controlled benchmark beside GPT-5.6 Sol or Claude Fable 5. Judge on accepted patches, review time, regressions, recovery success, and cost per accepted patch — not on one launch chart.

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

Sources

Meta Official

• Muse Code and Muse Spark 1.2 launch
• Muse Code documentation
• Meta Model API model catalog
• Introducing Muse Spark 1.1
• Muse Spark architecture overview
• Muse Image and Muse Video

Independent Benchmarks

• Terminal-Bench 2.1 verified leaderboard — tbench.ai
• Vals Terminal-Bench 2.1
• Vals Index v1.2
• Vals Muse Spark 1.2 model page

Third-Party Coverage

• Reuters: Meta launches Muse Code
• Economic Times: Muse Code pricing and contributor tier
• Business Insider: Muse Code launch

Competitive Products

• Claude Code — anthropic.com
• Cursor — cursor.sh
• Grok Build — x.ai
• OpenRouter: Muse Spark 1.2

Research Methodology

Research independently reviewed on August 6, 2026 using official Meta documentation at dev.meta.ai, Reuters and Economic Times launch coverage, the Vals.ai model page and Vals Index v1.2, the official Terminal-Bench 2.1 verified leaderboard at tbench.ai, and OpenRouter model listings. Vendor-reported and independently sourced benchmark scores are clearly distinguished throughout. Model access, prices, rate limits, and benchmark rankings can change — verify current details in the linked official documentation before deployment.