transition2.aiStart a project

News · Models, Tooling & Developer Practice · Software Factories & AI-Assisted Engineering · AI for SaaS & Software Companies

Muse Spark Open: Meta releases open weights for an 816B multimodal model

Meta's Muse Spark Open is an 816B-total, 42B-active multimodal model with 1M context, under a license with attribution and large-reseller conditions.

Eric MacDougall ·

Diagram of a self-hosting path for open weights in four labelled boxes from left to right: download weights, inference engine, private evaluation, and production guardrails, with a license review box sitting above the first step.

Meta released the weights for Muse Spark Open on October 15, 2026. It is a natively multimodal mixture-of-experts model with 816B total parameters, 42B of them active per token, and a 1M token context window, according to Meta's announcement. Meta calls it the most capable US open-weight model to date. The weights are published on Hugging Face and in cloud model catalogs under the Muse Model License, which Meta describes as having limited commercial terms. For teams building agent stacks, the release widens the choice between calling a hosted API and running a capable model inside their own environment, with the license as the first thing to check.

What happened

On October 15, 2026, Meta published Introducing Muse Spark Open. The key facts from the announcement and the Hugging Face model listing:

  • Size and architecture: 816B total parameters with 42B active, a mixture-of-experts design. In a mixture-of-experts model only a subset of the network runs for each token, which is why the active count is much smaller than the total.
  • Modalities: Meta describes the model as natively multimodal.
  • Context: 1M tokens.
  • Distribution: hosted APIs at Baseten, Fireworks AI, Groq, Modal, Nebius, OpenRouter and Together AI; weight downloads on Amazon SageMaker AI, Google Cloud Model Garden, Hugging Face and Microsoft Foundry Models.
  • Weights and hardware: BF16 and NVFP4 versions. The model card says self-hosting needs at least 700GB of GPU memory for NVFP4 and 2TB for BF16.
  • Inference engines: Meta lists SGLang, vLLM, TensorRT-LLM, Hugging Face Transformers, Apple MLX, llama.cpp and Unsloth.
  • Safety: the model card says this open-weights version has extra safety post-training so it is more robust as a standalone model without system guardrails. It still recommends human-in-the-loop confirmation for irreversible actions in agentic deployments.

The license text is on the model card. In summary, it grants broad rights to use, modify, fine-tune, distill, distribute and sell the software, subject to these conditions:

  • Use must comply with Meta's Usage Policy, which is part of the license.
  • Each product or service that uses the model or a derivative must prominently display "Built with Muse Spark Open". The license defines derivatives to include models trained or distilled using the model's outputs.
  • A licensee that offers models to third parties as a service through an API, and whose group gross revenue exceeds US$20 million in any 12-month period, must notify Meta and sign a separate agreement before offering Muse Spark Open that way. The clause does not apply to internal use, research, other commercial use, or using the model to power features of the licensee's own product.
  • The model card says the model is not intended for people under 18.

This is the desk's summary, not legal advice. Read the license itself before relying on it.

Meta also says the model can run on two Apple M5 Ultra Mac Studios using MLX. Its post says each machine's GPU can use up to 512GB of unified memory, with 1.2TB/s of memory bandwidth. That is a vendor claim. Meta does not state the throughput of that setup, so measure it before planning around it.

Why it matters

Open weights at this scale change the shape of a common decision: whether an agent stack should call a hosted model or run one in-house.

Data control becomes a real option for a capable multimodal model. When the weights can run inside a company's own cloud account or data center, prompts, documents and images do not have to leave that boundary. For workflows that handle sensitive records, that can matter more than small differences in benchmark scores.

Open weights are not unlimited rights. The Muse Model License is permissive for most internal and product use, but it adds an attribution duty that follows derivatives, including distilled models, and a separate-agreement trigger for large model-as-a-service providers. A team that fine-tunes the model, ships it inside a product, or serves it to customers needs to know which of those conditions applies.

Total size still drives hardware. The 42B active figure shapes how much compute each token needs, but all 816B parameters still have to be stored and loaded somewhere. The model card's floor is 700GB of GPU memory at NVFP4 and 2TB at BF16, far beyond a single consumer GPU. Meta's two-machine desktop claim is notable precisely because the model is so large.

Long context and multimodality raise the evaluation bar. A 1M token window and native image handling open up use cases such as reviewing large codebases or document sets that mix text and figures. They also mean evaluation has to cover those modes, not only short text prompts.

For broader context, see the Transition2 Models, Tooling and Developer Practice hub and the Software Factories hub.

A self-hosting checklist

Teams weighing Muse Spark Open against a hosted model can work through the decision in a fixed order:

  1. License review. Read the Muse Model License in full. Record where the "Built with Muse Spark Open" notice will appear, and whether any planned use counts as model-as-a-service under the US$20 million revenue trigger.
  2. Hardware sizing. Choose a target precision, then size memory from the model card's floor (700GB at NVFP4, 2TB at BF16) plus the context lengths actually needed. Long contexts add substantial memory for attention state.
  3. Inference engine. Confirm that the serving software in use supports this mixture-of-experts architecture and its multimodal inputs.
  4. Private evaluation. Build a held-out set from real tasks, including multimodal and long-context cases, and run it against both the self-hosted model and the current hosted option.
  5. Measure throughput and latency. Record tokens per second and time to first token under realistic concurrency, since these determine whether self-hosting meets user expectations.
  6. Production guardrails. Put the same input validation, output filtering, logging and access controls in front of a self-hosted model as in front of any external API.

Each step produces evidence. A decision to self-host should rest on that evidence, not on the fact that weights are available.

What it means for businesses

Read the Muse Model License before building a product on Muse Spark Open. Most internal and product uses are allowed, but every product needs the "Built with Muse Spark Open" notice, and a group with more than US$20 million in revenue that wants to resell model access needs a separate agreement with Meta. Involve legal review early, especially if the model will be fine-tuned, distilled, embedded in a customer-facing product, or offered to third parties. Treat self-hosting as an operational commitment: it brings data control, but it also brings responsibility for capacity, uptime, patching and monitoring that a hosted API would otherwise carry. Compare the two routes on the same evaluation set and on measured latency and throughput before committing.

What it means for AI users

A model that runs in a company's own environment or a private cloud can keep sensitive material inside that boundary, which can be a real gain for data control. It does not automatically make the system more accurate or safer. The same checks apply: know what data the tool sees, how outputs are reviewed, and who is responsible when it is wrong. If a tool says it runs on open weights, that describes where the model lives, not how well it has been tested for a given task.

What it means for developers

Plan memory carefully. The 816B total parameter count sets the storage floor, and the footprint varies widely with precision, so choose a precision deliberately and test quality at that precision rather than assuming parity with the reference weights. Measure the two-Mac-Studio MLX setup yourself before treating it as a deployment target. Build an evaluation harness that covers images and long inputs, since those are the capabilities that distinguish this release. Keep the serving layer behind the same guardrails used for hosted models, and log tokens consumed and latency per request so that the self-hosting decision can be revisited with real usage data.

Sources

  1. Introducing Muse Spark Open (accessed 2026-11-06)
  2. Hugging Face Muse Spark Open (accessed 2026-11-06)

← All posts