Muse Spark Open 816B 로컬 실행: 하드웨어, 양자화, 설정

Last verified: 2026-10-16

Muse Spark Open is Meta Superintelligence Labs’ frontier open-weight model, released October 15, 2026. It is a mixture-of-experts transformer with 816B total parameters and ~42B active per token, a 1 million-token context window, and native input for text, images, video, and audio. Meta trained it on real developer workflows — multi-file refactors, long debugging sessions, tool-calling scaffolds — and it leads the open-weight field on agentic coding and tool-use benchmarks. The number that matters for self-hosting is 226 GB. That is the 2-bit GGUF download, and it is why this model runs on a maxed-out Mac Studio rather than a datacenter cluster. The 4-bit build is 506 GB, and full BF16 is ~1.5 TB.

Already running this model? Register it with Tokios to reach it as https://api.tokios.com from any client.

Muse Spark Open at a glance

Property	Muse Spark Open 816B
Hugging Face repo	`meta-models/Muse-Spark-Open-816B-A42B`
License	Muse Model License
Architecture	Mixture-of-experts transformer — 256 experts per layer, 8 active per token
Parameters	~816B total, ~42B active per token
Layers	62
Hidden dimension	8,192
Attention	Grouped-query — 128 query heads, 16 KV heads, head dim 64, QK-norm, learned residual gates
Context window	1,048,576 tokens
Vocabulary	202,048 tokens
Modalities	Text, image, video, and audio in — text out
Languages	100+
Reasoning	Controllable — `low`, `medium`, `high`, `xhigh` (default `xhigh`)
Tool calling	Yes, native channel-based chat template (`to=self` for reasoning, `to=user` for final answer)
Perception encoder	1.8B-param ViT, 50 layers, 14×14 patches, 2D RoPE, sparse attention
Audio encoder	Convolutional pyramid, raw waveform at 24 kHz mono, 1 token per 80 ms
KV cache	~250 KB per token in BF16 (~266 GB for full 1M context)
Training	Public sources, internet crawls, third-party acquisitions, Meta products, synthetic data; safety post-training

Sources: Meta’s Muse Spark Open blog post and the model card.

Variants and model ids

Unsloth publishes GGUF builds from 2-bit to 4-bit. Meta publishes BF16 and NVFP4 (Blackwell) checkpoints. The MLX community provides Apple Silicon-optimized quantizations.

GGUF (llama.cpp / Ollama-compatible)

Quantization	Approximate size	Notes
`UD-IQ1_S`	176 GB	Extreme compression; significant quality loss
`UD-IQ1_M`	209 GB	Slightly higher precision
`UD-IQ2_XXS`	226 GB	Runs on Mac M3 Ultra 512 GB at ~18 tok/s
`UD-IQ2_S`	275 GB
`UD-Q2_K_XL`	311 GB
`UD-IQ3_XXS`	340 GB
`UD-Q3_K_XL`	401 GB
`UD-Q4_K_XL`	506 GB	Recommended — best quality/size balance

GGUF source: unsloth/Muse-Spark-Open-816B-A42B-GGUF.

Full precision and Blackwell

Checkpoint	Size	Hardware target
BF16 (`meta-models/Muse-Spark-Open-816B-A42B`)	~1.5 TB	4 nodes × 8× H200 (TP=32)
NVFP4 (`meta-models/Muse-Spark-Open-816B-A42B-NVFP4`)	~700 GB	Single B200/GB300 node

MLX (Apple Silicon)

Quantization	Approximate RAM	Notes
`oQ3e` (3-bit)	~344 GB	~21 tok/s generation on M3 Ultra
`oQ4e` (4-bit)	~450 GB

MLX source: mlx-community/Muse-Spark-Open-816B-A42B-oQ3e and -oQ4e.

MoE memory math

MoE has a memory trap: routing activates a fraction of parameters per token, but every expert weight stays resident. Muse Spark Open activates 42B of its 816B per token, but the full weight footprint is what you must load. The arithmetic:

816B parameters × ~0.5 bytes at 4-bit ≈ 408 GB of weights
~506 GB as shipped in UD-Q4_K_XL, once embeddings, the perception encoder, the audio encoder, and metadata are included
Add KV cache on top — at ~250 KB per token in BF16, a 131K context adds ~33 GB; the full 1M context adds ~266 GB

There is no way around the total-parameter memory cost. The practical path is aggressive quantization (2-bit at 226 GB for a Mac Studio, 4-bit at 506 GB for a multi-GPU box) or NVFP4 on Blackwell. See MoE routing and expert parallelism for how the architecture works and memory and offloading for what changes once weights spill past the GPU.

Hardware fit

Verdicts assume the model is fully resident (no CPU offloading) at a modest context length.

Target	GGUF Q2 (226 GB)	GGUF Q4 (506 GB)	NVFP4 (~700 GB)	BF16 (~1.5 TB)
Mac Studio M3/M4 Ultra (192 GB)	Won’t fit	Won’t fit	Won’t fit	Won’t fit
Mac Studio M3/M5 Ultra (512 GB)	Comfortable	Tight	Won’t fit	Won’t fit
2× Mac Studio M5 Ultra (clustered MLX)	Comfortable	Comfortable	Won’t fit	Won’t fit
8× RTX Pro 6000 (98 GB each, 784 GB total)	Comfortable	Comfortable	Comfortable (131K ctx)	Won’t fit
8× H200 (141 GB each, 1,128 GB total)	Comfortable	Comfortable	Comfortable	Tight (1M ctx)
4×8× H200 (TP=32)	Comfortable	Comfortable	Comfortable	Comfortable

On a 512 GB Mac Studio the 2-bit GGUF fits with room for a moderate context. The 4-bit build at 506 GB leaves almost no headroom on a single 512 GB machine — plan for the context you actually need. For the sizing method, see what size model fits your GPU?.

Picked a model? Connect it

One authenticated endpoint at https://api.tokios.com — no inbound ports, about 5 minutes.

Run it — beginner to advanced

llama.cpp (GGUF)
vLLM (NVFP4, Blackwell)
SGLang (NVFP4, Blackwell)
MLX (Apple Silicon)
Transformers (multi-GPU)

macOS / Linux

curl -LsSf https://llama.app/install.sh | sh
llama serve -hf unsloth/Muse-Spark-Open-816B-A42B-GGUF:UD-Q4_K_XL

Windows

winget install llama.cpp
llama serve -hf unsloth/Muse-Spark-Open-816B-A42B-GGUF:UD-Q4_K_XL

The server starts a web UI at localhost:9931 and an OpenAI-compatible endpoint. Swap the quantization tag to UD-IQ2_XXS for the 226 GB build on a 512 GB Mac. See llama.cpp remote access to reach it from another machine.

export CKPT=meta-models/Muse-Spark-Open-816B-A42B-NVFP4
VLLM_PLUGINS=musespark1x_models,ptq_nvfp4 \
vllm serve "$CKPT" \
  --tensor-parallel-size 4 \
  --enable-expert-parallel \
  --max-model-len 131072 \
  --reasoning-parser musespark1x \
  --tool-call-parser musespark1x \
  --port 8000

This serves the NVFP4 checkpoint on Blackwell GPUs with expert parallelism. Adjust --tensor-parallel-size and --max-model-len to your hardware. See vLLM remote access.

export CKPT=meta-models/Muse-Spark-Open-816B-A42B-NVFP4
uv run sglang_meta serve \
  --model-path "$CKPT" \
  --quantization modelopt_fp4 \
  --moe-runner-backend flashinfer_trtllm \
  --tp-size 4 --ep-size 4 \
  --port 30000

SGLang targets the NVFP4 checkpoint on Blackwell with FlashInfer TRT-LLM MoE backend. See the SGLang project docs for current syntax and tuning.

pip install mlx-lm
mlx_lm.generate --model mlx-community/Muse-Spark-Open-816B-A42B-oQ3e \
  --prompt "Explain convolutional networks like I am 5" \
  --max-tokens 5000

The 3-bit oQ3e build needs ~344 GB of unified memory and runs at ~21 tok/s on an M3 Ultra. The 4-bit oQ4e build is higher quality but needs ~450 GB. Meta reports testing on two Mac Studios with M5 Ultra clustered via oMLX.

from transformers import AutoModelForMultimodalLM, AutoTokenizer, DistributedConfig
import os

distributed_config = DistributedConfig(
    tp_size=int(os.environ["WORLD_SIZE"]),
    ep_size=int(os.environ["WORLD_SIZE"]),
)

model = AutoModelForMultimodalLM.from_pretrained(
    "meta-models/Muse-Spark-Open-816B-A42B",
    distributed_config=distributed_config,
)
tokenizer = AutoTokenizer.from_pretrained("meta-models/Muse-Spark-Open-816B-A42B")

messages = [{"role": "user", "content": "Explain quantum physics."}]
inputs = tokenizer.apply_chat_template(
    messages,
    reasoning_effort="medium",
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device).to(model.dtype)

outputs = model.generate(**inputs, max_new_tokens=2000)

Requires distributed inference across multiple GPUs. Set WORLD_SIZE to your GPU count. The BF16 checkpoint needs ~1.5 TB across all devices.

Sampling settings

Meta recommends temperature = 1.0, top_p = 1.0, and top_k disabled. The reasoning effort defaults to xhigh — lower it to high or medium for simpler tasks to save tokens. There is no way to turn reasoning off entirely; set it to low for the shortest path.

Capabilities

Controllable reasoning. Set the effort in the chat template with reasoning_effort="low" (or medium, high, xhigh). Higher settings spend more tokens reasoning before answering. The model uses a channel-based template: to=self for internal reasoning, to=user for the final answer.
Full multimodal input. Text, images, video, and audio all go in; text comes out. The perception encoder handles vision (1.8B-param ViT), and a separate convolutional pyramid handles audio at 24 kHz mono.
Agentic coding. Meta trained on real developer workflows: multi-file refactors, debugging sessions, tool-calling scaffolds. It leads open-weight models on MCP-Atlas (89.2), DeepSWE 1.1 (68), Terminal-Bench 2.1 (85.0), and Toolathlon Verified (76.5).
Native tool calling. The chat template supports structured tool calls with schema adherence. Use --tool-call-parser musespark1x in vLLM or the equivalent in your runtime.
Multilingual. 100+ languages.

Benchmarks

Meta-reported at xhigh reasoning effort, on a model released October 15, 2026. No independent reproduction exists yet — treat these as the vendor’s claims until third-party evaluations appear.

Benchmark	Score	Best competitor
MCP-Atlas	89.2	Qwen3.8 (84.5)
DeepSWE 1.1	68	GLM 5.3 (67)
Terminal-Bench 2.1	85.0	Qwen3.8 (82.0)
SWE-Atlas-QnA	66	Mistral Large 4 (59)
Toolathlon Verified	76.5	GLM 5.3 (73.0)
GPQA Diamond	93.5	Qwen3.8 (93.5)
HLE (w/ tools)	62.5	Qwen3.8 (56.2)
HLE-Diamond (no tools)	26.1	Kimi K3 (22.2)
JobBench	61.8	GLM 5.3 (61.4)
OSWorld Verified	80.4	Kimi K3 (84.8)
SciCode	59.5	GLM 5.3 (59.0)
Artificial Analysis Intelligence Index	39	Beam (40)

Connect it with Tokios

A frontier model on dedicated hardware is one you want to reach from anywhere without exposing ports. Tokios sits after your runtime: it does not download the model or replace vLLM.

Keep your local runtime running

Start Muse Spark Open in vLLM, SGLang, llama.cpp, or Transformers and leave it bound to loopback (or your internal network).

Pair the Tokios connector

Sign in at tokios.com/console, open the Setup tab, and click Start pairing to get a one-time claim code (TKS-XXXX-XXXX). Run the installer on the machine that runs the model:

Windows

irm https://tokios.com/downloads/install/windows | iex; tokios-install -Code 'TKS-XXXX-XXXX'

macOS

curl -fsSL https://tokios.com/downloads/install/macos | sh -s -- --code TKS-XXXX-XXXX

Linux

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Then approve the device on the Setup or Connectors tab.

In the Models tab, register the upstream model id (for example meta-models/Muse-Spark-Open-816B-A42B) under a public deployment name like muse-spark. Clients send the deployment name in the model field, never the local id — so re-quantizing later changes nothing on the client side.

Create an API key

In the Keys tab, click Create key. Copy the sk-tok-… key now — it is shown only once.

Call it from anywhere

curl https://api.tokios.com/v1/chat/completions \
  -H "Authorization: Bearer sk-tok-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muse-spark",
    "stream": true,
    "messages": [
      {"role": "user", "content": "Audit this repository and propose a phased refactor."}
    ]
  }'

export ANTHROPIC_BASE_URL=https://api.tokios.com
export ANTHROPIC_API_KEY=sk-tok-YOUR_KEY
claude --model muse-spark

Caveats

This is not a consumer-GPU model. The smallest usable quantization (2-bit at 226 GB) requires a 512 GB Mac Studio or equivalent. The recommended 4-bit build needs 506 GB. Plan your hardware before downloading.
Benchmarks are vendor-reported. Meta published them on release day. Wait for independent evaluations before treating the coding scores as settled.
The license is not Apache 2.0. Muse Spark Open ships under the Muse Model License, which differs from the Apache 2.0 license on Muse Glimmer. Read the license yourself before building on it.
No Ollama support yet. As of release day, Ollama has not published a Muse Spark Open tag. Use llama.cpp GGUF builds directly, vLLM, SGLang, or MLX.
1M context is a ceiling, not a target. The KV cache at full context is ~266 GB in BF16 — that is on top of the model weights. Size your context to what you actually need.
Multimodal input depends on your runtime. Tokios passes image, video, and audio content through to the upstream endpoint — it does not add capabilities your runtime or quantization lacks. Check supported backends.
Reasoning cannot be turned off. The lowest setting is low, which still spends tokens on internal reasoning. For the shortest possible responses, use low and accept the overhead.

FAQ

How much memory does Muse Spark Open need?

The smallest usable build is the 2-bit GGUF at 226 GB, which runs on a Mac Studio M3/M5 Ultra with 512 GB of unified memory. The recommended 4-bit GGUF is 506 GB. NVFP4 needs ~700 GB (a single B200 node). Full BF16 is ~1.5 TB across 4 nodes of 8× H200 GPUs. The transparent calculation: 816B parameters × ~0.5 bytes at 4-bit ≈ 408 GB of weights, plus the perception encoder, audio encoder, embeddings, and overhead.

Can Muse Spark Open run on a single GPU?

No. Even the most aggressive 2-bit quantization at 226 GB exceeds any single GPU’s memory. The practical single-machine paths are a 512 GB Mac Studio (GGUF Q2 via llama.cpp) or an 8× GPU workstation (GGUF Q4 or NVFP4). See what size model fits your GPU? for sizing math.

Is Muse Spark Open open source?

The weights are published under the Muse Model License, which is not Apache 2.0 or MIT. That differs from Muse Glimmer, which ships under Apache 2.0. Open weights and open source are not the same thing — the training data and pipeline are not released. Read the license yourself before building on it.

What is the difference between Muse Spark Open and Muse Glimmer?

Muse Glimmer is a dense 30B model that fits a single 24 GB GPU, distilled from the Muse Spark teacher. Muse Spark Open is the teacher itself — 816B total, 42B active, MoE, 1M context, multimodal (text/image/video/audio). Glimmer is for consumer hardware; Spark Open is for workstation and server-class hardware. They share the Muse architecture lineage but differ in scale, capability, and hardware requirements.

Can I use Ollama with Muse Spark Open?

Not yet. As of the October 15, 2026 release, Ollama has not published a Muse Spark Open tag. Use llama.cpp GGUF builds directly (llama serve -hf unsloth/Muse-Spark-Open-816B-A42B-GGUF:UD-Q4_K_XL), vLLM, SGLang, or MLX. Ollama support may follow — check ollama.com/library for updates.

How do I control how much Muse Spark Open thinks?

Set reasoning_effort to low, medium, high, or xhigh (default) in the chat template or API call. Higher settings spend more tokens reasoning before answering. There is no way to turn reasoning off entirely — low is the minimum. This also passes through Tokios — set it in the API call parameters.

Is Muse Spark Open better than Kimi K3 or GLM 5.3?

Meta’s own benchmarks compare it against Kimi K3, GLM 5.3, Qwen3.8, and others, and favour Muse Spark Open on most agentic and coding tasks. But those are vendor-run numbers on release day. All of these models require serious hardware (multi-GPU or 512 GB+ unified memory), so the practical answer is to serve each one and test your actual workload — see Kimi, GLM, and Qwen3.8.

Can I fine-tune Muse Spark Open?

Meta documents LoRA fine-tuning on attention layers only (experts remain frozen), but it requires 64 GPUs (8 nodes × 8× H100). The training config uses FSDP with expert parallelism. See the model card for the full fine-tuning recipe and the DistributedConfig setup.

Muse Glimmer

The dense 30B sibling that fits a single 24 GB GPU — same Muse lineage, consumer hardware.

MoE routing and expert parallelism

How mixture-of-experts models route tokens and how to parallelize across GPUs.

Coding agents with local models

Point Claude Code, Cline, or Aider at a model you host.

What fits your GPU?

Size the model and context to your VRAM or unified memory.

Llama 4

Meta’s other open-weight line, and why 17B active still needs 67 GB.

Quickstart

Pair a connector and register your first model end to end.

시작하기

모델

개념

참고

Muse Spark Open 816B 로컬 실행: 하드웨어, 양자화, 설정

Muse Spark Open at a glance

Variants and model ids

GGUF (llama.cpp / Ollama-compatible)

Full precision and Blackwell

MLX (Apple Silicon)

MoE memory math

Hardware fit

Picked a model? Connect it

Run it — beginner to advanced

Sampling settings

Capabilities

Benchmarks

Connect it with Tokios

Call it from anywhere

Caveats

FAQ

Muse Glimmer

MoE routing and expert parallelism

Coding agents with local models

What fits your GPU?

Llama 4

Quickstart

​Muse Spark Open at a glance

​Variants and model ids

​GGUF (llama.cpp / Ollama-compatible)

​Full precision and Blackwell

​MLX (Apple Silicon)

​MoE memory math

​Hardware fit

Picked a model? Connect it

​Run it — beginner to advanced

​Sampling settings

​Capabilities

​Benchmarks

​Connect it with Tokios

​Call it from anywhere

​Caveats

​FAQ

Muse Glimmer

MoE routing and expert parallelism

Coding agents with local models

What fits your GPU?

Llama 4

Quickstart

Muse Spark Open at a glance

Variants and model ids

GGUF (llama.cpp / Ollama-compatible)

Full precision and Blackwell

MLX (Apple Silicon)

MoE memory math

Hardware fit

Run it — beginner to advanced

Sampling settings

Capabilities

Benchmarks

Connect it with Tokios

Call it from anywhere

Caveats

FAQ