Muse Spark Open, decoded: why an 816-billion-parameter model only uses 42 billion at a time

What happened

Meta Superintelligence Labs published Muse Spark Open on Hugging Face on 15 October 2026. Meta describes it as the open-weights version of Muse Spark, its existing closed model. You can download the weights, run them on your own hardware and fine-tune them, under Meta's own licence (more on that below).

The headline specs, all from the official model card:

• 816 billion total parameters, about 42 billion active per token
• A mixture-of-experts design: 256 experts per expert layer, 8 used per token
• A 1-million-token context window
• Takes text, images, video and audio in; writes text out
• Weights in full precision (BF16) and a 4-bit format for NVIDIA's newest GPUs (NVFP4)

Meta pitches it for long-running agent work: coding agents that read a big codebase, plan a change, use tools, check the result and fix their own mistakes. Hugging Face's launch post calls it the most capable US open-weights model to date. That's Meta's and Hugging Face's claim, so read it as positioning rather than an independent verdict.

Why 816 billion is the wrong number to stare at

A model's parameters are the numbers it learned during training: the knobs that turn your prompt into an answer. More parameters usually means a model can store more knowledge and handle harder tasks. It also used to mean every answer got proportionally more expensive.

That's because most models are dense: every parameter does work for every token (a token is a chunk of text, roughly three-quarters of a word). Double the parameters and you roughly double the computation behind every word the model writes.

Muse Spark Open isn't dense. For each token it only runs about 42 billion of its 816 billion parameters, roughly 5%. So two different numbers matter, and they measure different things.

Mixture of experts, in plain English

Inside the model, many layers contain a set of small sub-networks called experts. In Muse Spark Open, each of those layers has 256 of them. Before a token passes through, a tiny network called the router scores all 256 and sends the token to the 8 best matches. The other 248 do nothing for that token.

The next token gets routed again, and may land on a completely different 8. Across a whole conversation, lots of experts get used. For any single token, only a few ever switch on.

Going deeper: where the 42 billion comes from

Hugging Face's technical write-up breaks the model down. It has 62 layers. Each expert layer holds 256 experts, and each expert is a small feed-forward network. The experts hold about 97% of all the parameters. The rest (attention, the embeddings that turn tokens into numbers, and the layers that turn numbers back into tokens) runs for every token.

So the 42 billion "active" parameters are that always-on machinery plus the 8 experts chosen in each expert layer. The headline 816 billion includes every expert, used or not.

The catch: fast to run, heavy to hold

Here's the part the parameter-count headlines skip. The router only uses 8 experts per token, but it can't know in advance which 8 the next token will need. So all 256 experts in every layer, all 816 billion parameters, have to sit in memory the whole time.

Mixture-of-experts makes a model cheap to compute relative to its size. It doesn't make it cheap to hold.

In concrete terms, from the model card, Meta's post and Hugging Face's tests:

• Full precision (BF16): at least 2 TB of GPU memory. Hugging Face ran it across 4 servers with 8 H200 GPUs each.
• 4-bit (NVFP4): at least 700 GB. Meta says it serves on four Blackwell Ultra GPUs or eight H200s.
• On a desk: Meta demonstrates it on two Mac Studios with M5 Ultra chips and 512 GB of memory each, linked over Thunderbolt 5.
• Heavily compressed (about 2-bit): community builds fit in roughly 300 GB of combined memory.
• Long context costs extra: Hugging Face estimates a full 1-million-token conversation needs about 266 GB just for the model's working memory of that conversation (the KV cache).

What you can actually do with it

• Try it hosted, with no hardware. Meta lists Baseten, Fireworks AI, Groq (limited preview), Modal, Nebius, OpenRouter and Together AI, plus the model catalogues in Amazon SageMaker AI, Google Cloud Model Garden and Microsoft Foundry.
• Build agents. The model card's intended uses include coding agents, tool use, multi-step reasoning, multimodal reasoning, generating synthetic training data, and acting as an AI judge that grades other models' output.
• Fine-tune it. Hugging Face shows a LoRA fine-tune (training a small add-on rather than the whole model) running on 8 servers of 8 H100s in about two hours.
• Self-host it when your data can't leave your own infrastructure, provided you can afford the memory above.

Limitations worth knowing

• The hardware bar is high. Even the smallest builds need hundreds of gigabytes of memory, so this isn't a laptop model.
• Reasoning is always on. You can set the effort from low to extra-high, but Hugging Face notes you can't switch reasoning off, which adds time and tokens to simple requests.
• Text out only. It understands images, video and audio but only writes text.
• Guardrails are on you. Meta recommends running it inside a wider system with its own safety checks, not on its own.
• Languages vary. It was trained on 100+ languages but hasn't been evaluated in all of them.
• Benchmarks are mixed. Meta's own table shows it ahead of other open models on some agent tests and behind on others. Treat any single headline score with care.

Open-weight is not open source

"Open" in AI often just means you can download the weights. Muse Spark Open ships under Meta's own Muse Model License, not a standard open-source licence like Apache 2.0 or MIT. From the licence published with the model:

• You can use, modify and fine-tune the model, and Meta claims no ownership of your outputs.
• You must display "Built with Muse Spark Open" somewhere visible, such as your product's interface, documentation, website or settings.
• If you offer AI model access as a service and your revenue from that passes $20 million in any 12-month period, you must notify Meta and sign a separate agreement first. Internal use, research, and using the model as a feature inside your own product are excluded from that rule.
• Fine-tuned and distilled models built from it count as derivatives and stay under the licence.
• An acceptable use policy applies, and the model isn't intended for people under 18.

The takeaways

1. 01Total parameters are your memory bill. Active parameters are your speed bill. Always ask which one a headline means.
2. 02Mixture-of-experts lets a model know a lot while doing only a little work per token: here, 8 of 256 experts, about 5% of the parameters.
3. 03You can try Muse Spark Open through hosted providers today. Self-hosting needs hundreds of gigabytes of GPU memory.
4. 04"Open-weight" comes with conditions here: an attribution notice, plus a separate deal for large AI services.