Skip to main content
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.
Already running this model? Register it with Tokios to reach it as https://api.tokios.com from any client.

​
Muse Glimmer at a glance

Sources: Meta’s Muse Glimmer announcement and the model card.
Muse Spark, the teacher model, is not released. Meta’s announcement covers Muse Glimmer weights only. Some coverage suggests Muse Spark 1.2 weights may follow — treat that as unconfirmed until Meta publishes a repository.

​
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 below. 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, 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 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 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
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 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. 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?.

Picked a model? Connect it

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

​
Run it — beginner to advanced

Drop -dflash if you are tight on memory. To pull Meta’s GGUF repo directly instead of Ollama’s library build:
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.

​
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: 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 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.
  • 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. Meta positions Muse Glimmer against Gemma 4 31B and Qwen3.6 27B 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, 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
macOS
Linux
Then approve the device on the Setup or Connectors tab.
3

Register a deployment

In the 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 tab, click Create key. Copy the sk-tok-… key now — it is shown only once.

​
Call it from anywhere

​
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.
  • 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

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.
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.
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. Note that open weights and open source are not the same thing — the training data and pipeline are not released.
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.
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 and Gemma.
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. The Llama line is separate and still uses the Llama Community License.
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.
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 for the matrix and coding agents with local models for setup.

Speculative decoding

How DFlash-style drafters work, and how to measure the speedup yourself.

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 mixture-of-experts line, and why 17B active still needs 67 GB.

Reach it from your phone

Use an always-on local agent when you are away from the machine.

Quickstart

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