> ## 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 lokal ausführen: Hardware, Quantisierung und Setup

> Muse Spark Open von Meta ist ein MoE mit 816B Parametern (42B aktiv), 1M Kontext, multimodaler Eingabe (Text, Bild, Video, Audio) und Spitzenwerten beim agentischen Coding. Hardware, GGUF-Varianten und Setup.

> [!NOTE]
>
> Zuletzt überprüft: 2026-10-16

Muse Spark Open ist das Frontier-Open-Weight-Modell von Meta Superintelligence Labs, veröffentlicht am 15. Oktober 2026. Es handelt sich um einen **Mixture-of-Experts**-Transformer mit **816B Gesamtparametern** und **\~42B aktiven Parametern pro Token**, einem Kontextfenster von 1 Million Token und nativer Eingabe für Text, Bilder, Video und Audio. Meta hat es auf echten Entwickler-Workflows trainiert — Multi-Datei-Refactorings, lange Debugging-Sitzungen, Tool-Calling-Gerüste — und es führt das Open-Weight-Feld bei Agenten-Coding- und Tool-Use-Benchmarks an.

Die entscheidende Zahl für Self-Hosting ist **226 GB**. Das ist der 2-Bit-GGUF-Download, und deshalb läuft dieses Modell auf einem maximal ausgestatteten Mac Studio und nicht auf einem Rechenzentrum-Cluster. Der 4-Bit-Build ist 506 GB groß, und vollständiges BF16 ist \~1.5 TB.

> [!TIP]
>
> Führen Sie dieses Modell bereits aus? [Registrieren Sie es bei Tokios](/de/setup/register-model.md), um es als `https://api.tokios.com` von jedem Client aus zu erreichen.

## Muse Spark Open auf einen Blick

| Eigenschaft | Muse Spark Open 816B |
| - | - |
| Hugging Face-Repository | [`meta-models/Muse-Spark-Open-816B-A42B`](https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B) |
| Lizenz | Muse Model License |
| Architektur | Mixture-of-Experts-Transformer — 256 Experten pro Schicht, 8 aktiv pro Token |
| Parameter | \~816B insgesamt, \~42B aktiv pro Token |
| Schichten | 62 |
| Hidden-Dimension | 8,192 |
| Attention | Grouped-Query — 128 Query-Heads, 16 KV-Heads, Head-Dim 64, QK-Norm, gelernte Residual-Gates |
| Kontextfenster | 1,048,576 Token |
| Vokabular | 202,048 Token |
| Modalitäten | Text, Bild, Video und Audio als Eingabe — Text als Ausgabe |
| Sprachen | 100+ |
| Reasoning | Kontrollierbar — `low`, `medium`, `high`, `xhigh` (Standard `xhigh`) |
| Tool-Aufrufe | Ja, natives kanalbasiertes Chat-Template (`to=self` für Reasoning, `to=user` für die finale Antwort) |
| Wahrnehmungsencoder | 1.8B-Parameter-ViT, 50 Schichten, 14×14 Patches, 2D-RoPE, Sparse Attention |
| Audio-Encoder | Konvolutionale Pyramide, Roh-Wellenform mit 24 kHz Mono, 1 Token pro 80 ms |
| KV-Cache | \~250 KB pro Token in BF16 (\~266 GB für den vollständigen 1M-Kontext) |
| Training | Öffentliche Quellen, Internet-Crawls, Drittanbieter-Akquisitionen, Meta-Produkte, synthetische Daten; Safety-Post-Training |

Quellen: [Metas Blogbeitrag zu Muse Spark Open](https://huggingface.co/blog/meta-muse-spark-open) und die [Modellkarte](https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B).

## Varianten und Modell-IDs

Unsloth veröffentlicht GGUF-Builds von 2-Bit bis 4-Bit. Meta veröffentlicht BF16- und NVFP4-Checkpoints (Blackwell). Die MLX-Community bietet für Apple Silicon optimierte Quantisierungen an.

### GGUF (llama.cpp / Ollama-kompatibel)

| Quantisierung | Ungefähre Größe | Hinweise |
| - | - | - |
| `UD-IQ1_S` | 176 GB | Extreme Komprimierung; deutlicher Qualitätsverlust |
| `UD-IQ1_M` | 209 GB | Etwas höhere Präzision |
| `UD-IQ2_XXS` | 226 GB | Läuft auf Mac M3 Ultra 512 GB mit \~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 | Empfohlen — bestes Qualitäts-Größe-Verhältnis |

GGUF-Quelle: [`unsloth/Muse-Spark-Open-816B-A42B-GGUF`](https://huggingface.co/unsloth/Muse-Spark-Open-816B-A42B-GGUF).

### Vollständige Präzision und Blackwell

| Checkpoint | Größe | Hardware-Ziel |
| - | - | - |
| BF16 (`meta-models/Muse-Spark-Open-816B-A42B`) | \~1.5 TB | 4 Knoten × 8× H200 (TP=32) |
| NVFP4 (`meta-models/Muse-Spark-Open-816B-A42B-NVFP4`) | \~700 GB | Einzelner B200/GB300-Knoten |

### MLX (Apple Silicon)

| Quantisierung | Ungefährer RAM | Hinweise |
| - | - | - |
| `oQ3e` (3-Bit) | \~344 GB | \~21 tok/s Generierung auf M3 Ultra |
| `oQ4e` (4-Bit) | \~450 GB | |

MLX-Quelle: [`mlx-community/Muse-Spark-Open-816B-A42B-oQ3e`](https://huggingface.co/mlx-community/Muse-Spark-Open-816B-A42B-oQ3e) und [`-oQ4e`](https://huggingface.co/mlx-community/Muse-Spark-Open-816B-A42B-oQ4e).

## MoE-Speicherberechnung

MoE hat eine Speicherfalle: Routing aktiviert einen Bruchteil der Parameter pro Token, aber **alle** Expertengewichte bleiben resident. Muse Spark Open aktiviert 42B seiner 816B pro Token, aber die vollständige Gewichtsmasse muss geladen werden. Die Berechnung:

* 816B Parameter × \~0.5 Bytes bei 4-Bit ≈ **408 GB** an Gewichten
* \~506 GB wie in `UD-Q4_K_XL` ausgeliefert, sobald Embeddings, der Wahrnehmungsencoder, der Audio-Encoder und Metadaten einberechnet sind
* Dazu kommt der KV-Cache — bei \~250 KB pro Token in BF16 fügt ein 131K-Kontext \~33 GB hinzu; der vollständige 1M-Kontext fügt \~266 GB hinzu

Es gibt keinen Ausweg vor den Gesamtparameter-Speicherkosten. Der praktische Weg ist aggressive Quantisierung (2-Bit bei 226 GB für einen Mac Studio, 4-Bit bei 506 GB für eine Multi-GPU-Maschine) oder NVFP4 auf Blackwell. Siehe [MoE-Routing und Experten-Parallelität](/de/concepts/moe-routing-and-expert-parallelism.md) für die Funktionsweise der Architektur und [Speicher und Offloading](/de/concepts/memory-and-offloading.md) für was sich ändert, wenn Gewichte über die GPU hinausgehen.

## Hardware-Eignung

Urteile setzen voraus, dass das Modell vollständig resident ist (kein CPU-Offloading) bei einer moderaten Kontextlänge.

| Ziel | GGUF Q2 (226 GB) | GGUF Q4 (506 GB) | NVFP4 (\~700 GB) | BF16 (\~1.5 TB) |
| - | - | - | - | - |
| Mac Studio M3/M4 Ultra (192 GB) | Passt nicht | Passt nicht | Passt nicht | Passt nicht |
| Mac Studio M3/M5 Ultra (512 GB) | Komfortabel | Knapp | Passt nicht | Passt nicht |
| 2× Mac Studio M5 Ultra (geclustertes MLX) | Komfortabel | Komfortabel | Passt nicht | Passt nicht |
| 8× RTX Pro 6000 (je 98 GB, 784 GB gesamt) | Komfortabel | Komfortabel | Komfortabel (131K ctx) | Passt nicht |
| 8× H200 (je 141 GB, 1,128 GB gesamt) | Komfortabel | Komfortabel | Komfortabel | Knapp (1M ctx) |
| 4×8× H200 (TP=32) | Komfortabel | Komfortabel | Komfortabel | Komfortabel |

Auf einem 512 GB Mac Studio passt das 2-Bit-GGUF mit Platz für einen moderaten Kontext. Der 4-Bit-Build mit 506 GB lässt fast keinen Spielraum auf einer einzelnen 512-GB-Maschine — planen Sie den Kontext, den Sie tatsächlich brauchen. Für die Dimensionierungsmethode siehe [Welche Modellgröße passt auf Ihre GPU?](/de/guides/model-fit.md).

> **[Modell ausgewählt? Verbinden Sie es](/de/quickstart.md)**
>
> Ein authentifizierter Endpunkt unter `https://api.tokios.com` — keine eingehenden Ports, etwa 5 Minuten.

## Ausführen — Anfänger bis Fortgeschrittene

**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
```

Der Server startet eine Web-UI unter `localhost:9931` und einen OpenAI-kompatiblen Endpunkt. Tauschen Sie den Quantisierungs-Tag gegen `UD-IQ2_XXS` für den 226-GB-Build auf einem 512-GB-Mac. Siehe [llama.cpp Fernzugriff](/de/guides/llama-cpp-remote-access.md) um ihn von einem anderen Rechner aus zu erreichen.

**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
```

Dies bedient den NVFP4-Checkpoint auf Blackwell-GPUs mit Experten-Parallelität. Passen Sie `--tensor-parallel-size` und `--max-model-len` an Ihre Hardware an. Siehe [vLLM Fernzugriff](/de/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 zielt auf den NVFP4-Checkpoint auf Blackwell mit dem FlashInfer TRT-LLM MoE-Backend ab. Siehe die SGLang-Projektdokumentation für aktuelle Syntax und Abstimmung.

**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
```

Der 3-Bit-`oQ3e`-Build braucht \~344 GB Unified Memory und läuft mit \~21 tok/s auf einem M3 Ultra. Der 4-Bit-`oQ4e`-Build hat höhere Qualität, braucht aber \~450 GB. Meta berichtet von Tests auf zwei Mac Studios mit M5 Ultra, die über oMLX geclustert sind.

**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)
```

Erfordert verteilte Inferenz über mehrere GPUs. Setzen Sie `WORLD_SIZE` auf Ihre GPU-Anzahl. Der BF16-Checkpoint braucht \~1.5 TB über alle Geräte.

### Sampling-Einstellungen

Meta empfiehlt `temperature = 1.0`, `top_p = 1.0` und `top_k` deaktiviert. Die Reasoning-Bemühung ist standardmäßig `xhigh` — reduzieren Sie sie auf `high` oder `medium` für einfachere Aufgaben, um Token zu sparen. Es gibt keine Möglichkeit, Reasoning vollständig auszuschalten; setzen Sie es auf `low` für den kürzesten Pfad.

## Fähigkeiten

* **Kontrollierbares Reasoning.** Setzen Sie die Bemühung im Chat-Template mit `reasoning_effort="low"` (oder `medium`, `high`, `xhigh`). Höhere Einstellungen verbrauchen mehr Token für Reasoning vor der Antwort. Das Modell verwendet ein kanalbasiertes Template: `to=self` für internes Reasoning, `to=user` für die finale Antwort.
* **Vollständige multimodale Eingabe.** Text, Bilder, Video und Audio gehen hinein; Text kommt heraus. Der Wahrnehmungsencoder verarbeitet Vision (1.8B-Parameter-ViT), und eine separate konvolutionale Pyramide verarbeitet Audio mit 24 kHz Mono.
* **Agenten-Coding.** Meta hat auf echten Entwickler-Workflows trainiert: Multi-Datei-Refactorings, Debugging-Sitzungen, Tool-Calling-Gerüste. Es führt Open-Weight-Modelle bei MCP-Atlas (89.2), DeepSWE 1.1 (68), Terminal-Bench 2.1 (85.0) und Toolathlon Verified (76.5) an.
* **Native Tool-Aufrufe.** Das Chat-Template unterstützt strukturierte Tool-Aufrufe mit Schema-Einhaltung. Verwenden Sie `--tool-call-parser musespark1x` in vLLM oder das Äquivalent in Ihrer Laufzeitumgebung.
* **Mehrsprachig.** 100+ Sprachen.

### Benchmarks

Von Meta berichtet bei `xhigh` Reasoning-Bemühung, für ein am 15. Oktober 2026 veröffentlichtes Modell. Es gibt noch keine unabhängige Reproduktion — betrachten Sie dies als die Aussagen des Herstellers, bis unabhängige Auswertungen erscheinen.

| Benchmark | Ergebnis | Bester Wettbewerber |
| - | - | - |
| 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) |

## Verbinden Sie es mit Tokios

Ein Frontier-Modell auf dedizierter Hardware ist eines, das Sie von überall erreichen möchten, ohne Ports offenzulegen. Tokios sitzt nach Ihrer Laufzeitumgebung: Es lädt das Modell nicht herunter und ersetzt nicht vLLM.

**1. Lassen Sie Ihre lokale Laufzeitumgebung laufen**

Starten Sie Muse Spark Open in vLLM, SGLang, llama.cpp oder Transformers und lassen Sie es an Loopback (oder Ihrem internen Netzwerk) gebunden.

**2. Paaren Sie den Tokios-Connector**

Melden Sie sich bei [tokios.com/console](https://tokios.com/console) an, öffnen Sie den Tab **Setup** und klicken Sie auf **Start pairing**, um einen einmaligen Pairing-Code (`TKS-XXXX-XXXX`) zu erhalten. Führen Sie den Installer auf dem Rechner aus, auf dem das Modell läuft:

```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
```

Dann **approve** Sie das Gerät im Tab **Setup** oder **Connectors**.

**3. Registrieren Sie ein Deployment**

Im Tab [Models](https://tokios.com/console/models) registrieren Sie die Upstream-Modell-ID (zum Beispiel `meta-models/Muse-Spark-Open-816B-A42B`) unter einem öffentlichen Deployment-Namen wie `muse-spark`. Clients senden den Deployment-Namen im `model`-Feld, niemals die lokale ID — eine spätere Neuquantisierung ändert also auf Client-Seite nichts.

**4. Erstellen Sie einen API-Schlüssel**

Im Tab [Keys](https://tokios.com/console/keys) klicken Sie auf **Create key**. Kopieren Sie den `sk-tok-…`-Schlüssel jetzt — er wird nur einmal angezeigt.

### Von überall aus aufrufen

```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
```

## Einschränkungen

* **Dies ist kein Consumer-GPU-Modell.** Die kleinste brauchbare Quantisierung (2-Bit bei 226 GB) erfordert einen 512-GB-Mac Studio oder gleichwertige Hardware. Der empfohlene 4-Bit-Build braucht 506 GB. Planen Sie Ihre Hardware vor dem Download.
* **Benchmarks sind vom Hersteller berichtet.** Meta hat sie am Veröffentlichungstag publiziert. Warten Sie auf unabhängige Auswertungen, bevor Sie die Coding-Ergebnisse als abgeschlossen betrachten.
* **Die Lizenz ist nicht Apache 2.0.** Muse Spark Open wird unter der **Muse Model License** veröffentlicht, die sich von der Apache 2.0-Lizenz von [Muse Glimmer](/de/models/muse-glimmer.md) unterscheidet. Lesen Sie die Lizenz selbst, bevor Sie darauf aufbauen.
* **Noch keine Ollama-Unterstützung.** Zum Veröffentlichungstag hat Ollama keinen Muse Spark Open-Tag veröffentlicht. Verwenden Sie direkt llama.cpp-GGUF-Builds, vLLM, SGLang oder MLX.
* **1M Kontext ist eine Obergrenze, kein Ziel.** Der KV-Cache bei vollem Kontext ist \~266 GB in BF16 — das kommt zu den Modellgewichten hinzu. Dimensionieren Sie Ihren Kontext auf das, was Sie tatsächlich brauchen.
* **Multimodale Eingabe hängt von Ihrer Laufzeitumgebung ab.** Tokios leitet Bild-, Video- und Audioinhalte an den Upstream-Endpunkt weiter — es fügt keine Fähigkeiten hinzu, die Ihrer Laufzeitumgebung oder Quantisierung fehlen. Prüfen Sie [unterstützte Backends](/de/setup/supported-backends.md).
* **Reasoning kann nicht ausgeschaltet werden.** Die niedrigste Einstellung ist `low`, die immer noch Token für internes Reasoning verbraucht. Für die kürzestmöglichen Antworten verwenden Sie `low` und akzeptieren Sie den Overhead.

## FAQ

> **Wie viel Speicher braucht Muse Spark Open?**
>
> Der kleinste brauchbare Build ist das 2-Bit-GGUF bei 226 GB, das auf einem Mac Studio M3/M5 Ultra mit 512 GB Unified Memory läuft. Das empfohlene 4-Bit-GGUF ist 506 GB. NVFP4 braucht \~700 GB (ein einzelner B200-Knoten). Vollständiges BF16 ist \~1.5 TB über 4 Knoten mit je 8× H200-GPUs. Die transparente Berechnung: 816B Parameter × \~0.5 Bytes bei 4-Bit ≈ 408 GB an Gewichten, zuzüglich Wahrnehmungsencoder, Audio-Encoder, Embeddings und Overhead.

> **Kann Muse Spark Open auf einer einzelnen GPU laufen?**
>
> Nein. Selbst die aggressivste 2-Bit-Quantisierung bei 226 GB übersteigt den Speicher jeder einzelnen GPU. Die praktischen Einzellösungs-Pfade sind ein 512-GB-Mac Studio (GGUF Q2 über llama.cpp) oder eine 8×-GPU-Workstation (GGUF Q4 oder NVFP4). Siehe [Welche Modellgröße passt auf Ihre GPU?](/de/guides/model-fit.md) für die Dimensionierungsberechnung.

> **Ist Muse Spark Open Open Source?**
>
> Die Gewichte werden unter der **Muse Model License** veröffentlicht, die nicht Apache 2.0 oder MIT ist. Das unterscheidet sich von [Muse Glimmer](/de/models/muse-glimmer.md), das unter Apache 2.0 veröffentlicht wird. Offene Gewichte und Open Source sind nicht dasselbe — die Trainingsdaten und Pipeline werden nicht veröffentlicht. Lesen Sie die Lizenz selbst, bevor Sie darauf aufbauen.

> **Was ist der Unterschied zwischen Muse Spark Open und Muse Glimmer?**
>
> Muse Glimmer ist ein dichtes 30B-Modell, das auf eine einzelne 24-GB-GPU passt, destilliert aus dem Muse-Spark-Lehrmodell. Muse Spark Open ist der Lehrer selbst — 816B insgesamt, 42B aktiv, MoE, 1M Kontext, multimodal (Text/Bild/Video/Audio). Glimmer ist für Consumer-Hardware; Spark Open ist für Workstation- und Serverklasse-Hardware. Sie teilen die Muse-Architektur-Linie, unterscheiden sich aber in Skalierung, Fähigkeiten und Hardware-Anforderungen.

> **Kann ich Ollama mit Muse Spark Open verwenden?**
>
> Noch nicht. Zum 15. Oktober 2026 Veröffentlichungstag hat Ollama keinen Muse Spark Open-Tag veröffentlicht. Verwenden Sie direkt llama.cpp-GGUF-Builds (`llama serve -hf unsloth/Muse-Spark-Open-816B-A42B-GGUF:UD-Q4_K_XL`), vLLM, SGLang oder MLX. Ollama-Unterstützung könnte folgen — prüfen Sie [ollama.com/library](https://ollama.com/library) auf Aktualisierungen.

> **Wie steuere ich, wie viel Muse Spark Open denkt?**
>
> Setzen Sie `reasoning_effort` auf `low`, `medium`, `high` oder `xhigh` (Standard) im Chat-Template oder API-Aufruf. Höhere Einstellungen verbrauchen mehr Token für Reasoning vor der Antwort. Es gibt keine Möglichkeit, Reasoning vollständig auszuschalten — `low` ist das Minimum. Dies wird auch durch Tokios durchgereicht — setzen Sie es in den API-Aufrufparametern.

> **Ist Muse Spark Open besser als Kimi K3 oder GLM 5.3?**
>
> Metas eigene Benchmarks vergleichen es mit Kimi K3, GLM 5.3, Qwen3.8 und anderen und bevorzugen Muse Spark Open bei den meisten Agenten- und Coding-Aufgaben. Aber das sind herstellerseitige Zahlen am Veröffentlichungstag. Alle diese Modelle erfordern ernsthafte Hardware (Multi-GPU oder 512 GB+ Unified Memory), daher ist die praktische Antwort, jedes einzelne zu betreiben und Ihren tatsächlichen Workload zu testen — siehe [Kimi](/de/models/kimi.md), [GLM](/de/models/glm.md) und [Qwen3.8](/de/models/qwen3.8.md).

> **Kann ich Muse Spark Open feinabstimmen?**
>
> Meta dokumentiert LoRA-Feinabstimmung nur bei Attention-Schichten (Experten bleiben eingefroren), aber es erfordert 64 GPUs (8 Knoten × 8× H100). Die Trainingskonfiguration verwendet FSDP mit Experten-Parallelität. Siehe die Modellkarte für das vollständige Feinabstimmungsrezept und die `DistributedConfig`-Einrichtung.

> **[Muse Glimmer](/de/models/muse-glimmer.md)**
>
> Der dichte 30B-Geschwister, der auf eine einzelne 24-GB-GPU passt — gleiche Muse-Linie, Consumer-Hardware.

> **[MoE-Routing und Experten-Parallelität](/de/concepts/moe-routing-and-expert-parallelism.md)**
>
> Wie Mixture-of-Experts-Modelle Token routen und wie man über GPUs parallelisiert.

> **[Coding-Agenten mit lokalen Modellen](/de/guides/coding-agents-local-models.md)**
>
> Richten Sie Claude Code, Cline oder Aider auf ein Modell, das Sie hosten.

> **[Was passt auf Ihre GPU?](/de/guides/model-fit.md)**
>
> Dimensionieren Sie Modell und Kontext nach Ihrem VRAM oder Unified Memory.

> **[Llama 4](/de/models/llama-4.md)**
>
> Metas andere Open-Weight-Linie, und warum 17B aktiv immer noch 67 GB brauchen.

> **[Schnellstart](/de/quickstart.md)**
>
> Paaren Sie einen Connector und registrieren Sie Ihr erstes Modell von Anfang bis Ende.


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