> ## 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-.

# Run Muse Glimmer 30B locally: hardware, DFlash, and setup

> Meta's Muse Glimmer 30B is Apache 2.0, fits a 24 GB GPU at 4-bit, and ships a DFlash drafter for 3.1x faster local agents. Tags, VRAM, and setup.

> [!NOTE]
>
> Last verified: 2026-08-10

Muse Glimmer is Meta Superintelligence Labs' open-weight agent model, released August 2026 under **Apache 2.0**. It is a **dense** 29.6B-parameter causal transformer with a built-in 1.8B ViT-G/14 perception encoder, a 131,072-token context window, and text-plus-image input. Meta built it for always-on local agents: tool calls with precise schemas, multi-step reasoning, and retry after failure — on one consumer GPU or a Mac.

The number that matters for self-hosting is **18 GB**. That is the 4-bit download, and it is why this model fits hardware you probably already own.

> [!TIP]
>
> Already running this model? [Register it with Tokios](https://docs.tokios.com/setup/register-model.md) to reach it as `https://api.tokios.com` from any client.

## Muse Glimmer at a glance

| Property | Muse Glimmer 30B |
| - | - |
| Hugging Face repo | [`meta-models/Muse-Glimmer-30B`](https://huggingface.co/meta-models/Muse-Glimmer-30B) |
| License | Apache 2.0 |
| Architecture | Dense causal transformer — **not** mixture-of-experts |
| Parameters | \~29.6B total, including a \~1.8B ViT-G/14 perception encoder |
| Context window | 131,072 tokens |
| Vocabulary | 202,048 tokens |
| Modalities | Text and image in, text out |
| Languages | 100+ |
| Reasoning | Controllable — `low`, `medium`, `high`, `xhigh` |
| Tool calling | Yes, with schema adherence across multi-step workflows |
| Speculative decoding | DFlash drafter ships with the model |
| Knowledge cutoff | January 4, 2026 |
| Training | Logit distillation from the larger Muse Spark teacher |

Sources: [Meta's Muse Glimmer announcement](https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model) and the [model card](https://huggingface.co/meta-models/Muse-Glimmer-30B).

> [!NOTE]
>
> **Muse Spark Open, the teacher model, is now released.** Meta published the 816B/42B-active MoE weights on October 15, 2026 under the Muse Model License — see [Muse Spark Open](https://docs.tokios.com/models/muse-spark-open.md). Glimmer remains the consumer-GPU option; Spark Open is the frontier workstation option.

## Variants and tags

Ollama publishes 13 builds. The `-dflash` variants bundle the speculative-decoding drafter, which costs about 2 GB and buys a large speedup — see [DFlash speculative decoding](#dflash-speculative-decoding) below.

| Ollama tag | Size | Format | Drafter |
| - | - | - | - |
| `muse-glimmer:30b-q4_K_M` | 18 GB | GGUF 4-bit | No |
| `muse-glimmer:30b-q4_K_M-dflash` | 20 GB | GGUF 4-bit | Yes |
| `muse-glimmer:30b-nvfp4` | 19 GB | NVFP4 (Blackwell) | No |
| `muse-glimmer:30b-nvfp4-dflash` | 21 GB | NVFP4 (Blackwell) | Yes |
| `muse-glimmer:30b-mlx` | 21 GB | MLX (Apple Silicon) | No |
| `muse-glimmer:30b-q8_0` | 31 GB | GGUF 8-bit | No |
| `muse-glimmer:30b-q8_0-dflash` | 33 GB | GGUF 8-bit | Yes |
| `muse-glimmer:30b-mxfp8` | 33 GB | MXFP8 | No |
| `muse-glimmer:30b-mxfp8-dflash` | 35 GB | MXFP8 | Yes |
| `muse-glimmer:30b-bf16` | 57 GB | BF16 | No |
| `muse-glimmer:30b-bf16-dflash` | 59 GB | BF16 | Yes |
| `muse-glimmer:30b-mlx-bf16` | 60 GB | MLX BF16 | No |
| `muse-glimmer:30b-mlx-bf16-dflash` | 65 GB | MLX BF16 | Yes |

Every tag carries the full 131,072-token context and accepts text and images. Meta's own GGUF repo, [`meta-models/Muse-Glimmer-30B-GGUF`](https://huggingface.co/meta-models/Muse-Glimmer-30B-GGUF), names its two K-quant builds `muse-glimmer-30B-kquant-17gb.gguf` (targets 24 GB VRAM) and `muse-glimmer-30B-kquant-dynamic.gguf` (targets 32 GB), with the drafter as `dflash-kquant.gguf`.

Confirm sizes against [ollama.com/library/muse-glimmer](https://ollama.com/library/muse-glimmer/tags) before you standardize on one — quantizations get re-cut.

## Why dense matters here

Recent flagship releases are almost all mixture-of-experts, and MoE has a memory trap: routing activates a fraction of parameters per token, but **every** expert weight stays resident. [Llama 4 Scout](https://docs.tokios.com/models/llama-4.md) activates 17B parameters and still needs \~67 GB, because memory scales with total parameters, not active ones.

Muse Glimmer goes dense at 30B specifically so the whole model fits. The arithmetic is unremarkable, which is the point:

* 29.6B parameters × \~0.5 bytes at 4-bit ≈ **15 GB** of weights
* \~18 GB as shipped, once the vision encoder, embeddings, and metadata are included
* Add KV cache for your context on top — see [KV cache and context](https://docs.tokios.com/concepts/kv-cache-and-context.md)

There is no offloading tier to plan around and no expert-parallelism topology to design. If you have 24 GB, the model is resident. See [memory and offloading](https://docs.tokios.com/concepts/memory-and-offloading.md) for what changes once weights spill past the GPU.

## Hardware fit

Verdicts assume the 4-bit build at a modest context length. Meta reports testing on MacBook M4 Max, M5 Max, and RTX 5090.

| Target | `q4_K_M` (18 GB) | `-dflash` (20 GB) | `q8_0` (31 GB) | `bf16` (57 GB) |
| - | - | - | - | - |
| RTX 4070 Ti Super / 4080 (16 GB) | Won't fit | Won't fit | Won't fit | Won't fit |
| RTX 3090 / 4090 (24 GB) | Comfortable | Fits — tight with long context | Won't fit | Won't fit |
| RTX 5090 (32 GB, Blackwell) | Comfortable | Comfortable | Tight | Won't fit |
| RTX 6000 Ada / A6000 (48 GB) | Comfortable | Comfortable | Comfortable | Won't fit |
| Apple Silicon (32 GB unified) | Comfortable | Comfortable | Tight | Won't fit |
| Apple Silicon (64 GB+ unified) | Comfortable | Comfortable | Comfortable | Comfortable |
| DGX Spark / Strix Halo (128 GB unified) | Comfortable | Comfortable | Comfortable | Comfortable |

On a 24 GB card the `-dflash` build fits, but the drafter and a long context compete for the same headroom. Start at a modest context, measure, then raise it. For the sizing method, see [what size model fits your GPU?](https://docs.tokios.com/guides/model-fit.md).

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

## Run it — beginner to advanced

> [tab] Ollama (easiest)
>
> ```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
> ollama run muse-glimmer:30b-q4_K_M-dflash
> ```
>
> Drop `-dflash` if you are tight on memory. To pull Meta's GGUF repo directly instead of Ollama's library build:
>
> ```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
> ollama run hf.co/meta-models/Muse-Glimmer-30B-GGUF
> ```
>
> Leave Ollama on its default `http://127.0.0.1:11434` and raise `num_ctx` from its small default only as far as your free memory allows. See [Ollama remote access](https://docs.tokios.com/guides/ollama-remote-access.md).

> [tab] LM Studio (GUI)
>
> Search for `meta/muse-glimmer` in the **Discover** tab and download a build that fits your machine. LM Studio lists a 25.77 GB variant and states a 26 GB RAM minimum for its smallest option, so check the specific file size before downloading.
>
> Start the local server from the **Developer** tab, then see [LM Studio remote access](https://docs.tokios.com/guides/lm-studio-remote-access.md).

> [tab] llama.cpp
>
> ```bash macOS / Linux theme={"theme":{"light":"github-light","dark":"css-variables"}}
> curl -LsSf https://llama.app/install.sh | sh
> llama serve -hf meta-models/Muse-Glimmer-30B-GGUF
> ```
>
> ```powershell Windows theme={"theme":{"light":"github-light","dark":"css-variables"}}
> winget install llama.cpp
> llama serve -hf meta-models/Muse-Glimmer-30B-GGUF
> ```
>
> See [llama.cpp remote access](https://docs.tokios.com/guides/llama-cpp-remote-access.md) to reach it from another machine.

> [tab] vLLM (GPU serving)
>
> ```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
> vllm serve "meta-models/Muse-Glimmer-30B"
> ```
>
> This serves the BF16 checkpoint, so budget \~57 GB plus KV cache. Confirm the flags for your vLLM version against the model card before you standardize. SGLang, Docker Model Runner, and ExecuTorch are also supported by the release — check each project's own docs for current syntax. See [vLLM remote access](https://docs.tokios.com/guides/vllm-remote-access.md).

### Sampling settings

Meta recommends `temperature = 1.0`, `top_p = 0.95`, and `top_k = 64`. A temperature of 1.0 is higher than many local models want — lowering it to the 0.6–0.7 range that suits other checkpoints is a common cause of degraded output here.

## DFlash speculative decoding

DFlash is a lightweight companion model that proposes blocks of 16 tokens for the main model to verify in one pass, instead of generating strictly one token at a time. Meta reports:

| Hardware | Reported speedup |
| - | - |
| RTX 5090 | 3.1x |
| Apple M5 Max | 1.8x |
| Apple M4 Max | 1.5x |

What makes this notable is packaging, not novelty. Speculative decoding normally means sourcing a compatible draft model and tuning the pairing yourself. Here the drafter ships with the weights and the `-dflash` Ollama tags enable it on pull — roughly 2 GB for a speedup you would otherwise spend an afternoon configuring.

The speedup is for **decoding**, so it helps most where output is long: agent loops, code generation, and extended reasoning at `high` or `xhigh`. It does little for short answers. See [speculative decoding](https://docs.tokios.com/guides/speculative-decoding.md) for the mechanism and how to measure the gain on your own hardware.

## Capabilities

* **Controllable reasoning.** Set the strength in the system prompt with `Reasoning strength: low` (or `medium`, `high`, `xhigh`). Higher settings spend more tokens before answering — raise it for hard tasks, lower it for latency.
* **Vision.** The perception encoder is part of the model, not a bolt-on, so image input works on any build. Output is text only.
* **Agentic use.** Meta trained and evaluated it for end-to-end task completion: planning, tool invocation against precise schemas, checking results, and recovering from failure. That is a different target from a general chat model — see [coding agents with local models](https://docs.tokios.com/guides/coding-agents-local-models.md).
* **Multilingual.** 100+ languages.

### Benchmarks

Meta-reported, on a model released today. No independent reproduction exists yet — treat these as the vendor's claims until third-party evaluations appear.

| Benchmark | Score |
| - | - |
| SWE-Bench Verified | 76.0% |
| SWE-Bench Pro | 51.2% |
| AIME 2026 | 94.7% |
| MCP Atlas | 75.5% |
| DeepSearch QA | 74.6% |

Meta positions Muse Glimmer against [Gemma 4 31B](https://docs.tokios.com/models/gemma.md) and [Qwen3.6 27B](https://docs.tokios.com/models/qwen3.6.md) across agentic, coding, multimodal, safety, and reasoning tasks — the same size class, so compare them on your own workload before switching.

## Connect it with Tokios

An always-on local agent is one you want to reach when you are not at the machine running it. Tokios sits after your runtime: it does not download the model or replace Ollama.

**1. Keep your local runtime running**

Start Muse Glimmer in Ollama, LM Studio, llama.cpp, or vLLM and leave it bound to loopback.

**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 `muse-glimmer:30b-q4_K_M-dflash`) under a public deployment name like `muse-glimmer`. 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-glimmer",
    "stream": true,
    "messages": [
      {"role": "system", "content": "Reasoning strength: high"},
      {"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-glimmer
```

## Caveats

* **Benchmarks are vendor-reported.** Meta published them on release day. Wait for independent evaluations before treating the coding scores as settled.
* **131,072 tokens is a ceiling, not a target.** Long contexts add KV-cache memory on top of the 18 GB weights, and on a 24 GB card that is exactly the headroom the DFlash drafter also wants.
* **Temperature 1.0 is the recommendation.** Do not carry over sampling settings from another local model without testing.
* **Vision and tool calls depend on your runtime.** Tokios passes image content and tool-call fields through to the upstream endpoint — it does not add capabilities your runtime or quantization lacks. Check [supported backends](https://docs.tokios.com/setup/supported-backends.md).
* **Apache 2.0 is a real change for Meta.** Llama 4 ships under the Llama 4 Community License with an acceptable-use policy and a threshold for large products. Muse Glimmer has neither, but read the license yourself before building on it.

## FAQ

> [accordion] How much VRAM does Muse Glimmer need?
>
> 18 GB for the 4-bit `q4_K_M` build, or 20 GB with the DFlash drafter — so a 24 GB card such as an RTX 3090 or 4090 runs it, with the remaining headroom going to KV cache. The 8-bit build needs 31 GB and BF16 needs 57 GB. The transparent calculation: 29.6B parameters × \~0.5 bytes at 4-bit ≈ 15 GB of weights, plus the vision encoder, embeddings, and overhead.

> [accordion] Can Muse Glimmer run on a 24 GB GPU?
>
> Yes. This is the headline for the release — a dense 30B agent model that is fully resident on one consumer card at 4-bit. Use `muse-glimmer:30b-q4_K_M` at 18 GB, or `muse-glimmer:30b-q4_K_M-dflash` at 20 GB if you want the speculative-decoding drafter and can spare the memory.

> [accordion] Is Muse Glimmer open source?
>
> The weights are published under **Apache 2.0**, which is permissive and carries no acceptable-use policy or user-count threshold. That is a departure from the Llama Community License used by [Llama 4](https://docs.tokios.com/models/llama-4.md). Note that open weights and open source are not the same thing — the training data and pipeline are not released.

> [accordion] What is DFlash?
>
> A lightweight drafter model that ships alongside Muse Glimmer. It proposes blocks of 16 tokens which the main model verifies in a single pass, rather than decoding one token at a time. Meta reports 3.1x on an RTX 5090, 1.8x on an M5 Max, and 1.5x on an M4 Max. Pull an Ollama tag ending in `-dflash` to get it — no separate configuration.

> [accordion] Is Muse Glimmer better than Qwen3.6 or Gemma 4?
>
> Meta's own benchmarks compare it against Gemma 4 31B and Qwen3.6 27B and favour Muse Glimmer, but those are vendor-run numbers on release day. All 3 sit in the same size class and run on the same hardware, so the practical answer is to serve each one and test your actual workload — see [Qwen3.6](https://docs.tokios.com/models/qwen3.6.md) and [Gemma](https://docs.tokios.com/models/gemma.md).

> [accordion] Is Muse Glimmer a Llama model?
>
> No. It is a new family from Meta Superintelligence Labs, distilled from a larger teacher model called Muse Spark, with a different architecture and a different license from [Llama 4](https://docs.tokios.com/models/llama-4.md). The Llama line is separate and still uses the Llama Community License.

> [accordion] How do I control how much Muse Glimmer thinks?
>
> Put `Reasoning strength: low`, `medium`, `high`, or `xhigh` in the system prompt. Higher settings spend more tokens reasoning before they answer, which raises both quality on hard tasks and latency. This also passes through Tokios — set it in the `system` message of your API call.

> [accordion] Can I use Muse Glimmer with a coding agent?
>
> Yes — it is built for it, with tool calling against precise schemas and failure recovery across multi-step workflows. Whether a specific agent works depends on how your runtime exposes tool calls; see [coding agent compatibility](https://docs.tokios.com/guides/coding-agent-compatibility.md) for the matrix and [coding agents with local models](https://docs.tokios.com/guides/coding-agents-local-models.md) for setup.

> [card] [Speculative decoding](https://docs.tokios.com/guides/speculative-decoding.md)
>
> How DFlash-style drafters work, and how to measure the speedup yourself.

> [card] [Coding agents with local models](https://docs.tokios.com/guides/coding-agents-local-models.md)
>
> Point Claude Code, Cline, or Aider at a model you host.

> [card] [What fits your GPU?](https://docs.tokios.com/guides/model-fit.md)
>
> Size the model and context to your VRAM or unified memory.

> [card] [Llama 4](https://docs.tokios.com/models/llama-4.md)
>
> Meta's mixture-of-experts line, and why 17B active still needs 67 GB.

> [card] [Reach it from your phone](https://docs.tokios.com/use-cases/local-model-on-your-phone.md)
>
> Use an always-on local agent when you are away from the machine.

> [card] [Quickstart](https://docs.tokios.com/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.