Muse Spark Open: How to Run Meta’s Open AI Model on Mac Studio

Meta released Muse Spark Open on October 15, 2026. It is one of the largest open-weight models you can download, with 816 billion total parameters and about 42 billion active per token, so no single Mac can hold it. Meta and Apple have documented a supported way to run it on Apple silicon using MLX, Apple’s open-source machine learning framework, spread across several Mac Studios.

This guide explains whether your hardware qualifies, what the official setup requires, and how to launch and test a local OpenAI-compatible server. The commands come from Meta’s Mac deployment documentation and Apple’s MLX research post.

Can You Run Muse Spark Open on Mac Studio?

• Supported hardware: Two Mac Studios with M5 Ultra and 512 GB of unified memory each, or four with 256 GB each. A single Mac cannot hold the model.
• Software: macOS 26.2 or later on every Mac, MLX 0.30.1 or later, and the mlx-lm package.
• Networking: Direct Thunderbolt 5 links between every pair of Macs, with RDMA enabled.
• Complexity: Setup involves SSH keys, a hostfile, network configuration, and about 537 GB of storage on each machine.
• Hosted alternative: Providers such as Together AI, Fireworks AI, and Baseten serve the model through OpenAI-compatible APIs with no local hardware.
• Best fit: Teams and enthusiasts who already own this hardware or plan to buy it, and who want inference on machines they control.

What Is Muse Spark Open?

Muse Spark Open is Meta’s open-weight model, published on Hugging Face under the Muse Model License. It uses a mixture-of-experts architecture with 256 experts per layer. The router activates 8 experts for each token, so compute stays close to that of a 42-billion-parameter model, but all 816 billion parameters must still fit in memory.

The model has a context window of 1,048,576 tokens and accepts text, image, video, and audio input. It produces text output and is built for coding and agentic work, including multi-step reasoning, tool use, and multi-file code editing.

Muse Spark and Muse Spark Open are separate products. Muse Spark, introduced in April 2026, is available through Meta’s apps and API. Muse Spark Open is the downloadable open-weight release.

Open weights do not mean unrestricted use. The license requires you to display “Built with Muse Spark Open” in products that use the model. If you offer the model to third parties as a paid API or similar service and your group’s gross revenue exceeds $20 million in any consecutive 12-month period, you must notify Meta and sign a separate agreement. Internal use, research, and using the model inside your own product are excluded from that threshold. Read the full license and its usage policy before deploying commercially.

Muse Spark Open Hardware Requirements

The NVFP4 weights need about 493 GB before inference overhead, so one 512 GB machine is not enough. Each Mac loads the model from its own disk, so each needs room for the download. Meta’s documented Mac workflow uses M5 Ultra Mac Studios only. Other Macs are not part of the official setup.

How to Run Muse Spark Open on Mac Studio

Complete these steps in order. Steps 3 and 4 apply to every Mac in the cluster, not just the primary.

Step 1: Prepare the Mac Studios

Confirm that each machine runs macOS 26.2 or later and has about 537 GB free. Choose one primary Mac to launch the job and hold the hostfile. Give each machine a stable hostname, such as mac-studio-1.local, because SSH and the hostfile depend on it.

Connect the machines directly. With two Macs, run two Thunderbolt 5 cables between them. With four, connect every Mac to each of the other three using two cables per pair. That requires six Thunderbolt 5 ports on each machine.

Step 2: Enable RDMA Over Thunderbolt

RDMA lets one Mac access another machine’s memory directly with low latency. Tensor parallelism exchanges small messages for every layer and every token, so it depends on this link. macOS 26.2 adds the RDMA-over-Thunderbolt driver, and MLX’s jaccl backend uses it. Enable RDMA on each Mac using the MLX distributed documentation.

Step 3: Configure Passwordless SSH

mlx.launch starts the job on each machine over SSH, so the primary must reach every other Mac without a password prompt. Test each connection:

bash

ssh mac-studio-2.local ‘echo ok’

If it prompts for a password, generate a key on the primary and copy it to each other Mac:

bash

ssh-keygen -t ed25519

ssh-copy-id mac-studio-2.local

Repeat the copy command for every additional Mac.

Step 4: Install mlx-lm on Every Mac

Run this on each machine:

bash

pip install -U mlx-lm

Installing only on the primary is not enough, because mlx.launch runs the server process on every Mac. Confirm the MLX version with pip show mlx and make sure it is 0.30.1 or later.

Step 5: Create the Hostfile

Create hostfile.json on the primary. It lists every Mac in the cluster, two or four. Each entry includes that machine’s Thunderbolt IP addresses and RDMA devices. Generate the file with mlx.distributed_config, as described in the MLX distributed documentation, rather than typing addresses by hand, which increases the risk of errors.

Step 6: Prepare the NVFP4 Checkpoint

The Mac workflow uses one checkpoint: meta-models/Muse-Spark-Open-816B-A42B-NVFP4, the 4-bit NVFP4 version on Hugging Face. Quantization stores each weight at lower precision. The NVFP4 weights need about 493 GB, while the full-precision BF16 version needs more than 1.6 TB. Download the checkpoint to each Mac before launch so the first start does not stall.

Step 7: Launch the Distributed Server

Run this on the primary Mac:

bash

mlx.launch –hostfile hostfile.json –backend jaccl –env MLX_METAL_FAST_SYNCH=1 — \

  mlx_lm.server –model meta-models/Muse-Spark-Open-816B-A42B-NVFP4 –port 8080

• mlx.launch starts the command on every Mac listed in the hostfile.
• –hostfile hostfile.json tells it which machines to use.
• –backend jaccl selects the RDMA-over-Thunderbolt backend.
• –env MLX_METAL_FAST_SYNCH=1 enables a feature Apple describes as experimental. It speeds CPU-GPU synchronization, so treat it as a setting to test rather than a guaranteed default.
• Everything after — runs on each Mac. mlx_lm.server serves an OpenAI-compatible API on port 8080.

Allow time for the model to load on every machine before sending requests.

Step 8: Test Generation and the Local API

Run a single test through the same launcher before connecting any client:

bash

mlx.launch –hostfile hostfile.json –backend jaccl –env MLX_METAL_FAST_SYNCH=1 — \

  mlx_lm.generate \

    –model meta-models/Muse-Spark-Open-816B-A42B-NVFP4 \

    –prompt “Give me a one-sentence summary of what you can do.” \

    –max-tokens 4096 \

    –temp 1.0 \

    –top-p 1.0

The model reasons before it answers, at the default xhigh level. The token budget must cover both the reasoning and the answer. Meta recommends temperature 1.0 and top_p 1.0.

Next, send a request to the server from the primary:

bash

curl http://127.0.0.1:8080/v1/chat/completions \

  -H “Content-Type: application/json” \

  -d ‘{

    “model”: “meta-models/Muse-Spark-Open-816B-A42B-NVFP4”,

    “messages”: [{“role”: “user”, “content”: “Explain what a mixture-of-experts model is in two sentences.”}],

    “max_tokens”: 4096,

    “temperature”: 1.0,

    “top_p”: 1.0

  }’

A reply from 127.0.0.1 confirms the request reached your local cluster, while hosted providers receive requests at their own endpoints. If the content field is empty and the response stops at the length limit, reasoning used the whole budget, so raise max_tokens. Any OpenAI-compatible client can use http://127.0.0.1:8080/v1 as its base URL.

What Can You Do With Muse Spark Open Locally?

Coding is the strongest documented use. Meta built the model for software engineering tasks, and Apple’s guide shows the OpenCode coding tool connecting to a local MLX server. The model’s context window reaches 1,048,576 tokens, but memory use grows with context length, and Apple benchmarked 8,192 and 65,536 tokens.

The model accepts images, video, and audio, but Meta’s MLX instructions do not document multimodal input for mlx_lm.server. Test that input in your MLX version before building on it.

The model can call tools, but the agent framework, permissions, and approval steps come from your software. Meta recommends human confirmation before irreversible actions in agentic deployments.

Muse Spark Open Performance on Mac Studio

Performance depends on quantization, memory bandwidth, interconnect latency, context length, and machine count. The M5 Ultra provides 1.2 TB/s of memory bandwidth, and decoding is largely bandwidth-bound. Tensor parallelism benefits most from fast Thunderbolt RDMA.

Apple reports about 36.7 tokens per second of decode speed across four M5 Ultra machines with tensor parallelism, and about 25 tokens per second across two machines with tensor parallelism. Both figures use an 8,192-token context, NVFP4 weights, and mlx_lm.benchmark. Apple reports a time to first token of 4.8 seconds on four machines at that context length. These are vendor-reported results, not independent tests. Your results will vary with prompt length, workload, macOS state, and cabling.

Common Muse Spark Open Problems and Fixes

Is Running Muse Spark Open Locally Worth It?

Local deployment makes sense when you need inference on hardware you control and already own the Macs. Hosted inference suits experimentation. Neither option is automatically cheaper or more private, so compare total costs and your data requirements. If you don’t need the full model, Meta’s separate Muse Glimmer is a 30B open-weight model released in August 2026 under Apache 2.0.

Final Verdict

Muse Spark Open is a serious local option for anyone who owns or can justify a documented Mac Studio cluster. The setup demands careful networking, SSH configuration, and memory planning, but Meta and Apple publish the exact commands. Readers without that hardware should try the model through a hosted provider first. To continue, follow the MLX section of Meta’s deployment guide.

Frequently Asked Questions

Can you run Muse Spark Open on one Mac Studio?

No. The NVFP4 weights need about 493 GB before inference overhead, and Apple states the model does not fit on a single machine. Meta’s documented setups use two or four M5 Ultra Mac Studios connected over Thunderbolt 5.

What Mac Studio configuration is required?

Meta documents two M5 Ultra Mac Studios with 512 GB each, or four with 256 GB each. Every Mac needs macOS 26.2 or later and MLX 0.30.1 or later, with direct Thunderbolt 5 links between each pair.

Can Muse Spark Open run on a MacBook?

Not under Meta’s documented workflow. The official setup uses Mac Studio with M5 Ultra, and other Macs are not part of that configuration.

How much unified memory does Muse Spark Open need?

The NVFP4 weights need about 493 GB before runtime overhead, and the BF16 version needs more than 1.6 TB. The documented clusters provide 1,024 GB combined, which leaves room for computation and the context cache.

Does Muse Spark Open run entirely locally?

It can. Inference runs on the Macs you configure. Hosted providers are a separate option and process requests on their own infrastructure.

Is Muse Spark Open free to download and use commercially?

The weights are free to download, but the Muse Model License sets conditions. You must display “Built with Muse Spark Open” in products that use it. Businesses offering the model as a paid API service above $20 million in gross revenue over 12 months need a separate agreement with Meta.

How long does the Mac Studio setup take?

Meta’s Mac documentation does not state a total setup time, so this guide does not give one. Plan for the roughly 537 GB download on each machine, SSH and Thunderbolt configuration, and testing.

Can Muse Spark Open provide a local API?

Yes. mlx_lm.server serves an OpenAI-compatible API on port 8080 of the primary Mac. Clients can use http://127.0.0.1:8080/v1 as the base URL with the model name meta-models/Muse-Spark-Open-816B-A42B-NVFP4.

Can Muse Spark Open run without Thunderbolt 5?

Not with the documented Mac workflow. It relies on RDMA over Thunderbolt 5 through the jaccl backend, which requires macOS 26.2 or later and direct links between machines.

Is local deployment better than hosted Muse Spark Open inference?

Not always. Local deployment gives you infrastructure control but requires expensive hardware and setup effort. Hosted providers need no hardware and suit variable workloads. Compare costs, expected usage, and data requirements before choosing.