Muse Spark: The Complete Guide for Developers

Muse Spark is Meta's frontier language model, built by Meta Superintelligence Labs and reachable two ways: through Muse Code, a terminal coding agent, or through the Meta Model API, an OpenAI-SDK-compatible HTTP endpoint. It takes a 1M-token context window with text, image, audio, video and document input, and it is sold in two tiers whose prices differ by roughly 15x depending on whether you let Meta train on your traffic.

This guide covers setup for both paths, the pricing decision that trips teams up, how to control reasoning cost, and an honest read on what the model is and is not good at as of September 2026. It assumes you can use a terminal but not that you have used an AI coding agent before.

What Muse Spark is (and what it is not)

Muse Spark is the model. Muse Code is the agent that drives it. People conflate the two constantly, and it matters because they are billed and installed differently.

The current release is Muse Spark 1.3, shipped 2 September 2026 — the fourth frontier release out of Meta Superintelligence Labs since April, which is an unusually fast cadence. Meta describes 1.3 as improving agentic and coding work specifically: compared with 1.2 it uses roughly 20% fewer tool calls and 25% fewer tokens on coding tasks, and it is tuned to ask clarifying questions when a prompt is ambiguous, ask for help when stuck, and confirm before consequential actions. Meta also claims better resistance to adversarial inputs and prompt injection, and better calibration on irreversible actions.

It ships in two reasoning variants. xhigh is the fast one and was fully available at launch. max is the top reasoning mode and was still gated behind additional safety testing when 1.3 went out, so most of what you can use today is xhigh.

What it is not: an open-weights model. Mark Zuckerberg has promised open weights for the Spark line "coming soon" — and Meta did open the weights for the 30B Muse Glimmer in August — but a similar promise was attached to Muse Spark 1.2 and did not land before 1.3 replaced it. Plan around the API, not the promise. If you specifically need weights you can run locally, Muse Glimmer is the model to look at, not Spark.

Two ways in: Muse Code or the Model API

Choose by what you are building, not by capability — both paths reach the same model with the same context window.

Muse Code and the Meta Model API are two front doors to the same model. The version number is not the choice that matters — the tier suffix is.

Use Muse Code if the work is "change this repository": refactors, test writing, bug hunts, migrations. Use the Model API if you are putting the model inside something you ship. Plenty of teams end up using both, and they bill separately.

Setting up the Meta Model API

The API is deliberately boring to adopt, which is its main selling point. Generate a key at dev.meta.ai, set it as MODEL_API_KEY, and point an SDK you already use at Meta's base URL.

Meta exposes two compatible surfaces: the OpenAI SDK (both Chat Completions and Responses formats) and the Anthropic SDK (Messages format). In practice this means an existing integration usually becomes a two-line change:

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.meta.ai/v1",
    api_key=os.environ["MODEL_API_KEY"],
)

resp = client.responses.create(
    model="muse-spark-1.3",
    input="Explain a tool-call loop in one sentence.",
)

Model IDs currently available on the API:

muse-spark-1.3 and muse-spark-1.3-contributor — current frontier
muse-spark-1.2 and muse-spark-1.2-contributor — previous release
muse-spark-1.1 — older, still served
muse-voice-transcribe-1.0 — speech to text, $3.00 per 1,000 minutes
Muse Image — image generation, about $0.01 per image

Beyond plain completions you get parallel tool calling, structured output, and a built-in server-side web search tool you enable by passing {"type": "web_search"} as a tool — worth knowing before you build your own search plumbing. Multimodal input is genuinely single-call: images, audio, video and documents can go into one request rather than a preprocessing pipeline.

Setting up Muse Code

Muse Code is in beta for macOS and Linux only — there is no Windows build, so on Windows you need WSL. Install needs nothing but curl and bash:

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

muse login runs a browser device-code flow against your Meta developer account. For CI and headless use, skip the login and set MODEL_API_KEY instead. There is also an npm route (npm install -g @meta-ai/muse-code) if you would rather not pipe a script into bash — a reasonable instinct, and one worth acting on if your security policy says so.

Then, inside a repository:

muse                 # interactive session in the current repo
muse exec "..."      # one-shot, headless — for CI
muse replay          # step through a past session's event log

Two project files are worth creating on day one. MUSE_CODE.md in your repo root holds standing instructions — build commands, conventions, things the agent keeps getting wrong. .museignore keeps the agent out of paths it should not read or touch, which matters more than it sounds: it is also the first line of defence for secrets and vendored code.

Inside a session, the commands that change outcomes most:

/plan — produce an approval-gated plan before any edits. Use this by default on unfamiliar code.
/grill — stress-test the plan before you accept it.
/goal — work toward a stated objective rather than a single instruction.
/model — switch the backing model, e.g. to muse-spark-1.3.
/effort — change reasoning depth. This directly changes your bill; see below.

On pricing, Muse Code has both subscriptions and pay-as-you-go. Subscriptions run $5/month (Everyday), $15/month (High, ~3x the usage) and $50/month (Power, ~10x). Pay-as-you-go bills the same token rates as the API. For most individuals the $5 tier is the right starting point, and it is deliberately priced under the competition.

Contributor or standard: the decision that actually matters

This is the part of Muse Spark that is genuinely different from its rivals, and the part most likely to cause a problem at work.

Every Muse Spark version exists twice. The plain model ID is the standard tier: Meta states it is never used to improve Meta's products. Append -contributor and you get the same model, the same 1M context and the same agent capabilities, for about a tenth to a fifth of the price — in exchange for Meta being permitted to use your prompts and outputs to improve its products.

Per 1M tokens	Contributor	Standard
Input	$0.10	$1.25
Cached input	$0.002	$0.15
Output	$0.20	$4.25
Used to train Meta models	Yes	No

Note the cached-input line: standard gives you an 88% cache discount, which is substantial on its own if you are re-sending a large system prompt or codebase. Do not compare tiers on the input rate alone.

Meta's own published example: 200M input and 50M output tokens in a month. The gap is real money at team scale, which is exactly why the question deserves a deliberate answer rather than a default.

The temptation is obvious. The trap is that this is not really a budget question:

The contributor discount is bought with training rights over whatever you send. That makes tier selection a permissions decision owned by whoever owns the code, not a cost decision owned by the engineer running the agent.

If you are an agency or a consultancy, the relevant document is your client agreement, and most client agreements predate generative AI and say nothing at all about model training. Silence there is not permission — client code is normally confidential information, and granting a third party training rights over it is a decision the client gets to make, not the engineer who liked the price. The practical rule: tier selection belongs to whoever owns the code.

Two mitigations are worth knowing. The contributor tier supports a per-repo sharing opt-out, so you can carve out specific repositories without abandoning the discount everywhere. And Meta has begun accepting zero-data-retention requests for organisations through its sales team, which sits on top of the standard tier — relevant if your compliance posture needs more than "not used for training."

Controlling reasoning effort, and your bill

Muse Spark reasons on every request and you cannot turn reasoning off. What you can do is set how much of it happens, via reasoning_effort, which accepts values from minimal through xhigh.

This is the single biggest lever on cost, because reasoning tokens are billed as output tokens — the expensive kind. They show up in the response under usage.completion_tokens_details.reasoning_tokens, and if your spend is surprising you, that field is the first place to look.

One asymmetry to plan around: on /v1/chat/completions the reasoning text is not returned to you at all, though you still pay for it. On /v1/responses you can ask for reasoning summaries via reasoning.summary. If you want any visibility into why the model did something, use the Responses endpoint.

Sensible defaults: minimal for classification, extraction, formatting and other mechanical work; mid-range for ordinary generation; xhigh reserved for genuinely hard debugging and multi-step planning. Running everything at xhigh is the most common way to turn a cheap model into an expensive one.

What it is good at, and where it is not

Meta's marketing leads on coding, and on coding the claim broadly holds. The wider picture is more mixed, and worth seeing as a shape rather than a list of numbers.

Coding and long-context retrieval are where Muse Spark 1.3 leads; agentic task benchmarks are where Claude Opus 5 still edges it. Rows marked n/r were not reported for that model. Data: Meta, Artificial Analysis.

Coding: 75.4 on DeepSWE v1.1 against 74.0 for Claude Opus 5 and 73.0 for GPT-5.6 Sol, and a wider 59.4 to 52.7 lead on SWEAtlas CodeBase QnA. Real, but the DeepSWE margin is roughly one point — close enough that it should not by itself decide your stack.

Long context: this is the standout. Muse Spark 1.3 holds 98.5 on MRCR at 256K–512K and 98.1 at 512K–1M. GPT-5.6 Sol manages 91.5 and then collapses to 73.8 at the top end. If your workload genuinely involves hundreds of thousands of tokens of retrieval, this is the strongest argument for the model.

Agentic tasks: Opus 5 in max mode is still ahead, consistently but narrowly — JobBench 65.7 to 64.9, OSWorld 2.0 68.3 to 66.9, DeepSearchQA 90.4 to 89.4, and GDPVal-AA v2 by 70 Elo (1,824 to 1,754). Third-party scoring from Artificial Analysis put the xhigh variant at Intelligence Index 61, sixth of 636 models tracked, at about 182 tokens per second.

Read together: Meta buys a coding lead and gives most of it back on agent work, while owning long-context retrieval outright. Which means the honest reason to pick Muse Spark today is usually price or context length, not raw capability.

Working with the million-token context

The context window is 1,048,576 tokens, and unusually the retrieval quality holds up near the top of it. That changes what is worth attempting: whole-repository reasoning, long document sets and multi-hour sessions in a single thread become viable rather than theoretical.

Three things to keep in mind anyway. First, a large context is not free — you pay per input token, so cache aggressively; the standard tier's 88% cached-input discount is designed for exactly the pattern where a big stable prefix is re-sent many times. Second, Meta says 1.3 is specifically tuned to sustain longer-horizon work and to generate its own context from messy or conflicting sources when given an open-ended objective, so it rewards being handed a goal rather than a rigid script. Third, filling the window because you can is still usually worse than curating what goes in.

Five mistakes to avoid

Defaulting to the contributor tier because it is cheaper. Check who owns the code first. This is the one that causes actual trouble.
Running everything at xhigh. Reasoning tokens bill as output. Match effort to task.
Comparing tiers on the input rate only. The cached-input rate and the 88% standard-tier cache discount often matter more in practice.
Assuming open weights are imminent. They have been promised twice. Build against the API.
Expecting parity everywhere because coding benchmarks lead. Agentic performance still trails Opus 5, and consumer surfaces lag the API — EU users reported Meta.ai still serving Muse Spark 1.1 after 1.3 was live for developers.

Frequently asked questions

Is Muse Spark free? No. Muse Code starts at $5/month, and API access is pay-as-you-go from $0.10 per million input tokens on the contributor tier.

Does it work on Windows? The API does, from anywhere. Muse Code is macOS and Linux only in beta, so use WSL.

Can I use it with the OpenAI or Anthropic SDK I already have? Yes — both. Change the base URL to https://api.meta.ai/v1 and the model ID.

Is my code used for training? Only on -contributor model IDs. Standard IDs are not used to improve Meta's products, and zero data retention is available to organisations on request.

Which version should I call? muse-spark-1.3. Pin the version explicitly rather than relying on a default, so a future release does not silently change your behaviour or your bill.

How does it compare to Claude or GPT? Ahead on coding benchmarks and clearly ahead on long-context retrieval; behind Claude Opus 5 on agentic tasks. See our full benchmark breakdown.

The bottom line

Muse Spark is a credible frontier model with two unusual properties: the best long-context retrieval currently measurable, and a pricing structure that puts an explicit number on your data. The setup is genuinely easy — if you have an OpenAI SDK integration, you are ten minutes from running it.

The decision that deserves real thought is not which model to call but which tier. Get that one right before you optimise anything else, because it is the only choice here you cannot quietly reverse after the fact.