Muse Spark Open: A Developer's Practical Guide

On 15 October 2026, Meta’s Superintelligence Labs released Muse Spark Open — the open-weight version of its Muse Spark model, the same lineage as the Muse coding assistant. It’s an 816-billion-parameter mixture-of-experts (MoE) model with 42 billion parameters active per token, a 1-million-token context window, and native multimodal input (text, images, video, audio). Meta calls it “the most capable US open-weight model to date.”

The weights are free to download, hosted APIs went live on day one, and Meta demoed it running on two Mac Studio machines linked with Apple’s MLX framework. That sounds like the best open model you can use this week. It is — with several caveats, some of which live in the license text. This guide is about what you can actually do with Muse Spark Open, concretely, before the weekend.

Table of Contents

Read the license first, not last

Muse Spark Open is open-weight, not open-source. It ships under Meta’s own Muse Model License, which Meta describes as carrying “limited commercial terms.” It’s a custom contract, not MIT or Apache. Three conditions matter for developers:

Attribution is mandatory. Any product or service using the model — or a derivative, including models fine-tuned or distilled on its outputs — must prominently display “Built with Muse Spark Open” in its interface, documentation, website, or settings.
The $20M model-as-a-service clause. If you (plus your affiliates) sell model access as a service and your aggregate gross revenue exceeds $20 million in any consecutive 12 months, you must notify Meta and sign a separate agreement before serving Muse Spark Open or its derivatives. Internal use, research, and embedding it as a feature in your own product are exempt — the gate applies to reselling inference.
Usage policy restrictions. The attached usage policy bars military/warfare, nuclear, and critical-infrastructure uses, and the model isn’t intended for under-18s.

For an indie developer shipping an internal coding agent, none of this is a blocker — but budget the attribution line and read the full license on the Hugging Face model page before building something commercial on top of it. The Hugging Face download is gated behind an access form asking for your legal name, date of birth, and company details, so it’s not quite click-and-download.

What the model actually is

The architecture, per Meta’s model card and Hugging Face’s technical writeup: 816B total parameters across 62 layers, 256 experts per MoE layer with 8 routed per token — the experts hold roughly 97% of the parameters. Grouped-query attention (128 query heads, 16 KV heads), hidden dimension 8192, a 202,048-token vocabulary, and a separate 1.8B-parameter perception encoder for images plus a new audio encoder that converts sound into 12.5 tokens per second.

It’s a reasoning model — reasoning can’t be switched off, only dialed down. You set reasoning_effort to low, medium, high, or xhigh (xhigh is the default), which means you can’t run it as a fast no-reasoning chat model the way you can with some other open models. Meta added extra safety post-training to the open version since it runs without Meta’s own guardrails, and it cleared Meta’s internal Superintelligence Scaling Framework thresholds for release. This is the full-size sibling of Muse Glimmer, a 30B dense model Meta released in August under Apache 2.0 that’s actually aimed at single consumer GPUs.

The honest benchmark picture

Meta’s “most capable US open-weight” claim rests on Meta’s own comparison table, run at maximum reasoning effort — and the word doing the most work there is “US”. Read honestly:

Tool use and agentic work: genuinely strong. MCP-Atlas (picking the right calls from 220 tools across 36 live servers) scores 89.2, the best in Meta’s table. JobBench (office-style multi-step tasks) scores 61.8 — more than double Inkling’s 31.1, and a hair above GLM 5.3’s 61.4.
Pure coding: mid-pack among large open models. Terminal-Bench 2.1 is 76.4 — behind Kimi K3 (85.0), GLM 5.3 (83.9), and Qwen3.8 (82.0). DeepSWE 1.1: 60 vs Kimi K3’s 68. Artificial Analysis Intelligence Index: 39, behind GLM 5.3 (45), Kimi K3 (44), and Qwen3.8 (40). Independent AA testing has since landed at the same 39, so the index number has independent confirmation.
Safety: standout. StrongREJECT v2 (jailbreak resistance, lower is better) scores 0.5 against 62.9–86.4 for rivals, and Meta reports it refused 99.2% of jailbreak attempts on its internal cyber benchmark — unsurprising priorities for a company releasing weights anyone can download, but still notable.

The takeaway: if your agent spends most of its time calling tools — reading code, running commands, hitting APIs — Muse Spark Open is a leading open option on the vendor-reported numbers. If the job is raw coding skill per the benchmarks, the Chinese open models still score higher. Meta’s own AI chief, Alexandr Wang, told CNBC: “These aren’t the most capable models that we’ve developed or released.”

Three routes to actually use it this week

Route 1: A hosted API (the practical route for almost everyone)

This is the only route that makes sense for most developers: no hardware, pay-as-you-go. Muse Spark Open went live with seven hosted-inference partners on day one — Baseten, Fireworks AI, Groq, Modal, Nebius, OpenRouter, and Together AI — plus raw weights through Hugging Face, Amazon SageMaker JumpStart, Google Cloud Model Garden, and Microsoft Foundry Models.

Pricing is remarkably consistent: OpenRouter lists $1.25 per million input tokens, $4.25 per million output tokens, and $0.15 for cached input — the same price as the closed Muse Spark 1.3, and far below the closed Muse Wonder ($4 input / $20 output). Together AI matches that rate; other providers set their own prices and limits, so compare before committing. Caveats to know:

Groq is limited preview, with the context capped at 131,072 tokens instead of 1M. Groq advertises 350+ tokens/sec per user, though — serious speed for agent loops.
OpenRouter routes across five providers (Modal, Together, Nebius, Fireworks, Baseten) with automatic failover.
AA measured about $0.84 per task for Muse Spark Open versus roughly $2 for Kimi K3/GLM 5.3 — mostly because it emits far fewer reasoning tokens.

All the hosted endpoints speak the OpenAI-compatible API, so swapping it in is a base-URL and model-slug change:

from openai import OpenAI

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

resp = client.chat.completions.create(
    model="meta/muse-spark-open",
    messages=[
        {"role": "user", "content": "Refactor this function to handle retries with exponential backoff:\n\n" + code},
    ],
)
print(resp.choices[0].message.content)

Put the model behind an interface in your harness anyway — models arrive almost daily now, and the best model for your agent this month probably won’t be the best one next month. Pin a provider or exclude one with OpenRouter’s provider routing if failover worries you.

Route 2: Two Mac Studios as one machine (impressive, expensive, real)

Meta worked with Apple to run Muse Spark Open through the MLX framework across two linked Mac Studios with M5 Ultra chips and 512 GB of unified memory each — about a terabyte of memory between them, connected over Thunderbolt 5. On that setup, Meta’s Muse Code agent shipped real bug fixes and features for the open-source Mastodon iOS app Ice Cubes, and drove DaVinci Resolve to review raw footage and crop the best shots for vertical video.

Why it works: the MoE design means only ~42B parameters are read per token, and the M5 Ultra’s 1.2 TB/s of memory bandwidth is fast enough to fetch that slice each step. Note the practical catches: the 512 GB Mac Studio configuration hadn’t shipped at the time of writing (Apple said late October, with no published price), and even four 256 GB machines have been estimated at around $38,000. This is workstation territory — a genuinely interesting proof that frontier-scale models can run on hardware you own, but not a setup most developers can justify this week.

Route 3: Self-host with vLLM/SGLang — or a GGUF quant on a big workstation

Meta supports vLLM, SGLang, TensorRT-LLM, Transformers, MLX, llama.cpp, and Unsloth, across NVIDIA, AMD, Intel, and Apple hardware. The open build even ships custom auto-tunable Helion GPU kernels inside SGLang that Meta says deliver 1.03–3.95x kernel-level speedups on NVIDIA and AMD GPUs. Memory requirements per the model card: at least 700 GB of GPU memory for the NVFP4 checkpoint (~537 GB download, serves on a 4-GPU Blackwell node or 8 H200s), or about 2 TB for the BF16 checkpoint (~1.5 TB download, 8 B300-class GPUs). SageMaker JumpStart ships both variants (meta-models/Muse-Spark-Open-816B-A42B and the NVFP4 build).

Serving the NVFP4 weights with vLLM looks like this (check vLLM’s docs for the current reasoning/tool-call parser flags for this model family):

hf download meta-models/Muse-Spark-Open-816B-A42B-NVFP4 --local-dir ./muse-spark-open-nvfp4

vllm serve meta-models/Muse-Spark-Open-816B-A42B-NVFP4 \
    --tensor-parallel-size 4 \
    --enable-expert-parallel \
    --max-model-len 1048576

The floor for “run it yourself” comes from community quantization: Unsloth’s GGUF builds get the model down to roughly 300 GB of combined RAM+VRAM via llama.cpp — an aggressive ~2-bit quant on a very large-memory workstation, with quality loss at that compression not yet properly measured. Hugging Face’s own post showed a 2-bit version running at 18 tok/s on a single 512 GB M3 Ultra Mac. Still far beyond a normal machine — an 8 GB gaming GPU setup is roughly a quarter of the way there — but it’s the only local route that doesn’t involve a server rack or two unreleased Macs.

What a 1M-token context actually buys you

The 1-million-token context window is the model’s most developer-relevant feature, and it’s where agentic coding actually changes shape. A million tokens is roughly an entire medium-sized monorepo — code, tests, docs, and the error logs — in a single prompt. That means multi-file refactors where the model can hold the caller, the callee, the tests, and the migration notes simultaneously, and long debugging sessions where the whole conversation history and every intermediate tool output stay in context instead of getting summarized away.

Two things to keep in mind. First, a full million-token KV cache takes roughly 266 GB in BF16, so long contexts add to the memory bill on top of the weights. Second, 1M context doesn’t mean 1M useful context — retrieval quality degrades for some models as you pack the window, and that behavior hasn’t been independently characterized for this release yet. Start with large-but-reasonable windows (a few hundred thousand tokens) and widen them once you see how your specific tasks behave.

When to skip it

Muse Spark Open is the wrong choice if: you wanted a model for your laptop (look at Muse Glimmer or a Qwen/Kimi-class small model instead); you need a permissive open-source license without attribution strings; you resell model access at scale above the $20M threshold without wanting a separate Meta agreement; or raw coding-benchmark scores are your top criterion — Kimi K3 and GLM 5.3 lead there on the published numbers. It’s the right choice if you want an open-weight model with a 1M-token window and multimodal input for tool-heavy agentic work, from a US lab, this week, for about a dollar per million input tokens.

Muse Spark Open: A Developer’s Practical Guide