> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tokios.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Tokios exposes private local models through https://api.tokios.com using an outbound-only connector tunnel.
> Use 'connector' for the local tokios-connector process.
> Use 'deployment' for the public model name in the API model field.
> Use 'upstream model id' for the model served by Ollama, llama.cpp, vLLM, LM Studio, or another local backend.
> API keys use the prefix sk-tok-. Connector tokens use the prefix ct-tok-.

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

> Meta의 Muse Spark Open은 816B/42B 활성 MoE로, 1M 컨텍스트, 멀티모달 입력(텍스트, 이미지, 동영상, 오디오), 프런티어급 에이전트 코딩 점수를 갖췄습니다. 하드웨어, GGUF 변형, 설정을 다룹니다.

> [!NOTE]
>
> 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.

> [!TIP]
>
> Already running this model? [Register it with Tokios](/ko/setup/register-model.md) 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`](https://huggingface.co/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](https://huggingface.co/blog/meta-muse-spark-open) and the [model card](https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B).

## 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`](https://huggingface.co/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`](https://huggingface.co/mlx-community/Muse-Spark-Open-816B-A42B-oQ3e) and [`-oQ4e`](https://huggingface.co/mlx-community/Muse-Spark-Open-816B-A42B-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](/ko/concepts/moe-routing-and-expert-parallelism.md) for how the architecture works and [memory and offloading](/ko/concepts/memory-and-offloading.md) 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?](/ko/guides/model-fit.md).

> **[Picked a model? Connect it](/ko/quickstart.md)**
>
> One authenticated endpoint at `https://api.tokios.com` — no inbound ports, about 5 minutes.

## Run it — beginner to advanced

**llama.cpp (GGUF)**

```bash macOS / Linux theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -LsSf https://llama.app/install.sh | sh
llama serve -hf unsloth/Muse-Spark-Open-816B-A42B-GGUF:UD-Q4_K_XL
```

```powershell Windows theme={"theme":{"light":"github-light","dark":"css-variables"}}
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](/ko/guides/llama-cpp-remote-access.md) to reach it from another machine.

**vLLM (NVFP4, Blackwell)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
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](/ko/guides/vllm-remote-access.md).

**SGLang (NVFP4, Blackwell)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
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.

**MLX (Apple Silicon)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
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.

**Transformers (multi-GPU)**

```python theme={"theme":{"light":"github-light","dark":"css-variables"}}
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.

**1. 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).

**2. Pair the Tokios connector**

Sign in at [tokios.com/console](https://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:

```powershell Windows theme={"theme":{"light":"github-light","dark":"css-variables"}}
irm https://tokios.com/downloads/install/windows | iex; tokios-install -Code 'TKS-XXXX-XXXX'
```

```bash macOS theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -fsSL https://tokios.com/downloads/install/macos | sh -s -- --code TKS-XXXX-XXXX
```

```bash Linux theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX
```

Then **approve** the device on the **Setup** or **Connectors** tab.

**3. Register a deployment**

In the [Models](https://tokios.com/console/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.

**4. Create an API key**

In the [Keys](https://tokios.com/console/keys) tab, click **Create key**. Copy the `sk-tok-…` key now — it is shown only once.

### Call it from anywhere

```bash curl (OpenAI-compatible) theme={"theme":{"light":"github-light","dark":"css-variables"}}
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."}
    ]
  }'
```

```bash Claude Code (Anthropic-compatible) theme={"theme":{"light":"github-light","dark":"css-variables"}}
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](/ko/models/muse-glimmer.md). 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](/ko/setup/supported-backends.md).
* **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?](/ko/guides/model-fit.md) 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](/ko/models/muse-glimmer.md), 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](https://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](/ko/models/kimi.md), [GLM](/ko/models/glm.md), and [Qwen3.8](/ko/models/qwen3.8.md).

> **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](/ko/models/muse-glimmer.md)**
>
> The dense 30B sibling that fits a single 24 GB GPU — same Muse lineage, consumer hardware.

> **[MoE routing and expert parallelism](/ko/concepts/moe-routing-and-expert-parallelism.md)**
>
> How mixture-of-experts models route tokens and how to parallelize across GPUs.

> **[Coding agents with local models](/ko/guides/coding-agents-local-models.md)**
>
> Point Claude Code, Cline, or Aider at a model you host.

> **[What fits your GPU?](/ko/guides/model-fit.md)**
>
> Size the model and context to your VRAM or unified memory.

> **[Llama 4](/ko/models/llama-4.md)**
>
> Meta's other open-weight line, and why 17B active still needs 67 GB.

> **[Quickstart](/ko/quickstart.md)**
>
> Pair a connector and register your first model end to end.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.