Meta Open-Sources 816B Muse Spark Open: Weights Available for Download, But You Can't Run It Locally

On October 15, Meta released the open weights for Muse Spark Open, calling it "the strongest American open-weight model to date." The weights are indeed free to download, but running it on your own machine would require roughly 1TB of memory.

This article helps developers get a clear picture: what it actually is, how to use it, and where the pitfalls are.

What Is Muse Spark Open?

Muse Spark Open is the open-weight version of Meta AI's underlying model Muse Spark. It launched three days after Meta's closed-source frontier model Muse Wonder.

Core specs:

• 816 billion total parameters (MoE architecture, only 42 billion active per token)
• 1 million token context window (1,048,576 tokens)
• Native multimodal: reads text, images, audio, and video; outputs text
• Built for agentic coding: long multi-step tasks, tool calling, real bug fixes

Meta offers two checkpoint formats: full-precision BF16 (about 1.6TB) and a compressed NVFP4 version (about 530GB). Community quantizations (AMD, Intel, Unsloth) have pushed down to roughly 2-bit, reportedly runnable on a 256GB machine using llama.cpp.

MoE (Mixture of Experts) architecture is the key to understanding Muse Spark Open. In a traditional dense model, every parameter is activated on each forward pass; MoE instead splits the model into a large number of "expert" sub-networks, with a routing network deciding which experts to activate based on the current token. So although Muse Spark Open nominally has 816 billion parameters, each token only passes through a computational path of about 42 billion parameters. This makes the inference compute cost far lower than a dense model with the same total parameter count. The trade-off is memory: all expert weights must reside in VRAM or unified memory at all times, so the total parameter count directly determines the hardware threshold, while the active parameter count only affects speed. This is exactly why "1TB of memory" and "42B of compute" coexist—and why nearly all ultra-large open-source models today adopt MoE.

Quantization refers to representing model weights with lower bit-width numbers to reduce size and memory footprint. In the original text, BF16 is 16-bit floating point, NVFP4 is NVIDIA's 4-bit floating-point format, and "2-bit community quantization" compresses each weight down to about 2 bits. The lower the bit width, the smaller the model and the smaller the machine it fits into—but the greater the precision loss, often requiring calibration datasets to preserve the precision of critical layers as much as possible. Note: quantization only compresses weights; it does not change context length, so a 1 million token KV cache will still consume a large amount of additional memory.

How to Use It? Three Paths

Path One: Download the Weights (Free)

Available on Hugging Face, Amazon SageMaker AI, Google Cloud Model Garden, and Microsoft Foundry Models. Free to download, with a license permitting limited commercial use.

Path Two: Run Locally (Expensive)

Meta partnered with Apple to optimize for the MLX framework. Running it requires two interconnected 512GB M5 Ultra Mac Studios—Apple's unified memory architecture pools them into what Meta calls "a single supercomputer with terabyte-class unified memory." The 512GB Mac Studio isn't shipping yet (expected later this month), and the 256GB version already costs over $10,000.

Path Three: Hosted API (Most Practical)

Launch partners include Together AI, Baseten, Fireworks AI, Groq, Modal, Nebius, and OpenRouter. Together AI offers both serverless and dedicated infrastructure.

MLX is an open-source machine learning framework built by Apple for its own chips (the M series), optimized for the unified memory architecture so the CPU and GPU can share the same memory without repeatedly copying data. Unified Memory Architecture means the CPU, GPU, and neural engine share the same physical memory pool, so multiple Mac Studios can "pool" their memory through high-speed interconnects into one logically enormous memory space—this is the technical basis for Meta's claim of "a single terabyte-class unified memory supercomputer." By contrast, on traditional PCs, VRAM and system memory are isolated from each other, and a model must first fit into VRAM to run—which is the fundamental reason consumer GPUs struggle to host ultra-large models. MLX's support for ultra-large MoE is still evolving, so before actual deployment, it's advisable to do small-scale validation on the target hardware.

What Is It Good At?

Based on Meta's own release information and early partner reports (all vendor claims, not independently verified):

• Long-horizon agentic coding: keeps an entire codebase in context, plans, executes, observes, and self-corrects over long tasks
• Tool calling: early Ollama testing reports strong performance in multi-step and parallel tool calls, with clean structured output
• Multimodal understanding: handles documents, images, audio, and video in a single prompt—Meta demonstrated reviewing and trimming footage in DaVinci Resolve
• Narrated mode: the model explains what it's doing and why before acting—useful for agent observability

Pitfalls to Watch Out For

The hardware threshold is absurdly high. 1TB of unified memory firmly locks local inference into the "enterprise workstation" category, not the "developer laptop." The 2-bit community quantization running on a 256GB machine is interesting but has not been validated at scale.

The license is binding. The Muse model license requires prominent attribution: "Built with Muse Spark Open." Companies with annual revenue over $20 million that offer it as a service must notify Meta and sign a commercial agreement. This is not a permissive MIT-style license.

Benchmark results are mixed. Meta's benchmarks show strong performance in agent and tool use, but coding scores weaker than some leading Chinese open-source models. "Strongest American open-weight model" is a carefully worded phrase: it sidesteps global competition.

No independent benchmarks yet. All performance data in this article comes from Meta or its launch partners. Evaluate accordingly.

Who Should Pay Attention, Who Can Skip

Worth watching if you:

• Build agentic coding workflows and need an open-weight model with a 1 million context window
• Need to handle multimodal inputs (screenshots, voice notes, screen recordings) in a single model
• Already use infrastructure from Together AI, Fireworks, or Groq

Can skip if you:

• Want a model that runs on a laptop (it won't, unless you have a $20,000+ Mac Studio)
• Need a permissive commercial license without attribution requirements
• Already have a Qwen- or Kimi-class open-source model that handles your coding tasks

Key Takeaways

• Meta releases the 816B-parameter open-weight model Muse Spark Open, free to download
• 42B active parameters per token, 1 million context, multimodal input, built for agentic coding
• Local running requires about 1TB of memory (two M5 Ultra Mac Studios); API available through 7 launch partners
• License requires attribution; companies with annual revenue above $20 million must sign a commercial agreement
• Agent benchmarks strong per Meta data, coding scores weaker than Chinese open-source models—currently all vendor claims

Additional Context

Open Weights does not equal Open Source. Open weights only means the model parameters can be downloaded, but training data, training code, and the full recipe are usually not public, and the scope of use is defined separately by the license. The Muse model license is a "permissive license with conditions": commercial use is allowed, but attribution is mandatory ("Built with Muse Spark Open"), and companies with annual revenue over $20 million that offer the model as a service are additionally obligated to "notify Meta and sign a commercial agreement." Such clauses have become increasingly common in open-weight models in recent years, aiming to preserve ecosystem diffusion while retaining bargaining power and compliance tracking over ultra-large commercial users. When selecting a model, be sure to review the license clause by clause rather than assuming it's handled like MIT or Apache 2.0.

Vendor-reported benchmarks need to be treated with caution for three reasons: first, benchmark questions may appear in training data, causing "data contamination" and inflated scores; second, the prompts, tool environments, and scoring scripts used in evaluation are often set by the vendor itself, making direct cross-comparison between different reports difficult; third, a model may have been optimized for specific benchmarks and may not transfer to real tasks. A more reliable way to judge whether a model suits you is to run a small-sample A/B test on your own real tasks—using the same set of prompts and the same scoring criteria to compare candidate models side by side. Until independent third-party evaluations (such as LMArena or public agentic coding leaderboards) emerge, vendor data should only serve as a reference floor, not a conclusion.

One-line Summary

Meta releases the 816B-parameter open-weight model Muse Spark Open—strong multimodal capabilities, but local running requires 1TB of memory.

Paragraph Summary

On October 15, Meta released the open-weight model Muse Spark Open, with 816 billion total parameters (MoE architecture, 42 billion active per token), supporting a 1 million token context and multimodal inputs including text, images, audio, and video, positioned for long-horizon agentic coding and tool calling. Weights are free to download, but the local running threshold is extremely high: full-precision BF16 is about 1.6TB, NVFP4 is about 530GB, and the official recommendation is two interconnected 512GB M5 Ultra Mac Studios, with hardware costs exceeding $20,000. A more realistic option is calling hosted APIs through seven launch partners including Together AI, Fireworks, and Groq. The license requires attribution, and companies with annual revenue over $20 million must sign a commercial agreement if offering it as a service. Meta self-reports strong agent and tool use performance, but coding scores are weaker than some Chinese open-source models, and there is currently no independent third-party verification.