Muse Spark Open: An 816B Model for Local AI

Imagine opening a half-finished iOS project on a Monday morning: a failing test, several unfamiliar files, and a screen recording that shows the bug only after a few taps. A coding assistant that returns one code fragment is useful. A model that traces the failure, edits several files, runs the build, studies the result, and keeps working through the problem belongs to a different category.

That is the kind of long-running work Meta is targeting with Muse Spark Open. Released on October 15, 2026, the open-weight model combines coding, tool use, long-context reasoning, and multimodal input. It can be accessed through hosted inference providers, or deployed on private hardware, including a remarkably large two-machine Apple Silicon setup. (research.meta.ai)

Open weights does not mean a free-for-all

Open weights are the numerical parameters a model learns during training. Downloading them gives you more control than a typical application programming interface, or API, where you send a prompt to a remote service and receive an answer. With the weights in your own environment, prompts and source code can remain inside your infrastructure, and you can choose the serving software, hardware, and customization process.

The distinction matters because open-weight is not automatically the same as open source. Meta has released the model parameters, but not every part of the training recipe, dataset, or surrounding product stack. Muse Spark Open uses the Muse Model License, which includes conditions such as displaying the phrase “Built with Muse Spark Open” in products or documentation. A company offering the model as a service also faces additional requirements after passing a specified revenue threshold. The license deserves a careful read before a commercial launch. (huggingface.co)

Why 816 billion parameters does not mean 816 billion every time

Muse Spark Open is a sparse mixture-of-experts model. A mixture-of-experts system contains many specialized neural-network sections, called experts, and a routing mechanism chooses which ones handle each piece of input. Picture a large workshop with hundreds of specialists: a dispatcher sends each request to the few people best suited to it instead of waking the entire staff for every job.

The model contains 816 billion parameters in total, but about 42 billion are active for a given token. A token is a small piece of text, such as a word fragment or punctuation mark. Meta’s documentation describes 256 experts with eight selected per token. This reduces the computation required for each step, although serving still requires loading the full collection of weights into memory. That is why the model can be computationally selective and still demand enormous hardware.

Its context window reaches 1,048,576 tokens, commonly described as one million tokens. The context window is the amount of material the model can consider in one request and conversation. That is enough room for a substantial codebase, design documents, logs, and test output, but it does not guarantee perfect recall. A long prompt can still contain ambiguity, repeated information, or details the model misinterprets. Muse Spark Open accepts text, images, audio, and video as input while producing text as output. (dev.meta.ai)

Can you run Muse Spark Open locally?

The desktop announcement comes with an important footnote: this is not a model for an ordinary laptop. Meta documents a BF16 checkpoint, where BF16 is a 16-bit numerical format commonly used for neural-network weights, at roughly 1.65 terabytes. Its NVFP4 version uses four-bit storage for most weights and is about 537 gigabytes before accounting for runtime overhead, memory for the conversation, and other working data.

Apple’s route uses two Mac Studios with M5 Ultra and up to 512 gigabytes of unified memory each. Unified memory is shared by the processor and graphics hardware, so the machines can hold a large model without dividing memory into completely separate pools. Meta also documents a four-machine configuration using 256-gigabyte systems. In practice, this is a compact workstation cluster, not a casual local-AI experiment.

Other deployment paths target data-center hardware. Meta’s documentation includes configurations for NVIDIA Blackwell systems, AMD accelerators, and Intel platforms, alongside runtimes such as SGLang, vLLM, Transformers, and TensorRT-LLM. Most developers will reach Muse Spark Open through a hosted provider rather than buying enough hardware to serve hundreds of billions of parameters.

What an agentic workflow looks like

An agentic workflow is a loop in which a model plans a task, calls a tool, observes the result, adjusts its plan, and continues. The model is not merely completing the next sentence. It is participating in a controlled process that may include a terminal, a code repository, a browser, a document editor, or a media application.

A local server might begin with a command like this:

vllm serve meta-models/Muse-Spark-Open-816B-A42B

vLLM is software for serving models and answering requests from other applications. This command does not give the model permission to edit files or execute shell commands. An agent layer still needs to define which tools are available, which directories are writable, when a human must approve an action, and how failed operations are rolled back.

Meta reports testing workflows that included modifying and building an open-source iOS application, as well as reviewing video in DaVinci Resolve to identify strong moments and create vertical crops. Those examples matter because they show the intended shape of the system: code, visual information, and external tools working in one longer loop rather than separate prompts handled in isolation. (research.meta.ai)

Read the benchmark table with some caution

Meta’s evaluations span software engineering, tool use, knowledge, reasoning, and multimodal tasks. The model card says its published comparisons use high or extra-high reasoning effort, and different competitors may be tested with different settings or harnesses. A benchmark score can show that a model is promising; it cannot predict exactly how well it will behave in your repository or production workflow.

For a practical evaluation, measure the things that affect your work: whether patches pass tests, how often the model calls tools, how much human correction is needed, how long a task takes, and whether it leaves the project in a recoverable state. A model that scores well but makes expensive, hard-to-review changes may be less useful than a slightly weaker model with disciplined tool behavior. (huggingface.co)

Safety belongs outside the model, too

Muse Spark Open includes additional safety post-training because open weights can be deployed without a provider’s surrounding guardrails. Meta’s model card still recommends system-level protections suited to the particular application, especially when the model can use tools or act on a user’s behalf.

That means running an agent in a sandbox, giving it the smallest possible permissions, keeping credentials out of its context, restricting network access, requiring approval before destructive actions, and recording every tool call. Local execution can improve data control, but it does not make an agent safe by itself. A model with access to a terminal can cause damage faster on a private workstation than on a carefully restricted hosted service.

The practical takeaway

Muse Spark Open is not a tiny model that makes frontier-scale AI disappear into a laptop. Its significance is the range of deployment choices: hosted APIs for most teams, data-center serving for organizations with serious infrastructure, and a local Apple Silicon path for developers willing to build a high-memory workstation cluster.

The model’s combination of a million-token context window, multimodal perception, sparse expert routing, and coding-focused agent behavior makes it an intriguing foundation for repository-scale software work. The hard part has moved beyond generating code. It now includes supplying the right tools, setting firm boundaries, measuring real task success, and deciding when the model should stop and wait for a human.