Muse Glimmer is live on Swfte Connect — run it on your own hardware through the embedded SDK or on our clustered cloud, behind the same API you already call. Try it today.
Meta released Muse Glimmer on 10 August 2026: a 29.6-billion-parameter dense multimodal model, weights on Hugging Face under Apache 2.0, engineered to run on one consumer GPU (Hugging Face, SiliconANGLE). It arrived with a 6,500-word essay from Mark Zuckerberg arguing that "rather than centralizing superintelligence, we should distribute it widely and give every person the ability to direct it" (Engadget).
The essay will get the coverage. The config file is the more interesting document. Glimmer is not a scaled-down flagship with the corners sanded off — it is a distillation target with an architecture chosen so that a 128K-token agent loop fits in a 24GB memory budget. Almost every design decision in it trades generality for a specific deployment envelope, and the result beats models its own size on the tasks it was pointed at while losing to them on the tasks it wasn't.
That trade is the story. Not this model in isolation, but what it implies about the next two years of model supply.
What actually shipped
| Muse Glimmer | |
|---|---|
| Total parameters | ~29.6B (28B decoder + ~1.8B vision tower) |
| Sparsity | None — dense causal transformer |
| Decoder layers | 52, hidden dimension 6,656 |
| Feed-forward | SwiGLU, intermediate size 19,968 |
| Attention heads | 32 query / 2 key-value (16:1 GQA), head dim 128 |
| Context | 131,072 tokens |
| Vocabulary | 202,048 (200K BPE + 2,048 special) |
| Modalities | Text + interleaved images in, text out. No audio |
| Licence | Apache 2.0, all artifacts |
| Repo | meta-models/Muse-Glimmer-30B |
Meta trained it by distilling from the closed Muse Spark family, then ran two further post-training passes — the first targeting long-context reasoning, the second targeting agentic behaviour, including the habit of retrying a failed tool call rather than halting (SiliconANGLE). Training data covered more than 100 languages (Engadget).
The attention pattern is doing the work
Glimmer's decoder repeats a four-layer block thirteen times: three sliding-window layers with a 2,048-token window, then one full-attention layer. RoPE at θ = 500,000 is applied only on the local layers; the global layers use no positional encoding at all (Hugging Face).
Work out what that does to the KV cache and the design intent becomes obvious.
With 2 key-value heads at head dim 128, each layer stores 256 key values and 256 value values per token. At FP16 that is 1 KiB per token per layer — a clean number, and a small one, because 16:1 grouped-query attention already cut it sixteenfold against full multi-head.
Now apply the layer pattern at full context:
- 13 global layers × 131,072 tokens × 1 KiB ≈ 1.63 GiB
- 39 local layers × 2,048 tokens × 1 KiB ≈ 78 MiB
Total KV cache at a filled 128K window: roughly 1.7 GiB.
Had every layer been global, the same context would cost about 7 GiB. Had the model used 32 KV heads instead of 2, it would cost 27 GiB — more than the weights. The sliding-window rhythm and the 16:1 grouping are not micro-optimisations; they are the reason a long agent trajectory fits on a card you can buy at retail.
The rest of the budget follows. Meta ships three calibrated builds: full BF16 at 64GB VRAM, a dynamic k-quant at 32GB, and a 17GB build targeting 24GB VRAM. Reported degradation averaged across fifteen benchmarks is 0.2% for the dynamic quant and 1.0% for the 17GB build — small enough that four-bit is the intended serving format rather than a fallback. At roughly 4 bits, 28B decoder parameters land under 20GB, leaving room for the vision tower, the cache, and the drafter inside a 24GB card.
The vision side is a frozen ViT-G/14 perception encoder: 50 layers, width 1536, patch size 14, capped at 4,096 visual tokens per image, with a 2×2 pixel shuffle after the transformer that cuts image tokens fourfold without dropping channels. Frozen matters for anyone fine-tuning — you are adapting the decoder, not the encoder.
DFlash: block-diffusion drafting
Glimmer ships an optional companion, DFlash — a five-layer block-diffusion drafter with 32 query and 8 key-value heads, trained at block size 16 (one anchor plus fifteen proposed tokens). It proposes a block, the main model verifies, accepted tokens commit.
Measured throughput (Hugging Face):
| Hardware | Base | With DFlash | Speedup |
|---|---|---|---|
| RTX 5090 | 74.9 tok/s | 233.4 tok/s | 3.1× |
| M4 Max | 23.7 tok/s | 37.8 tok/s | 1.5× |
The gap between those two rows is the useful part. Speculative decoding converts spare compute into throughput, so it pays out on a card with compute headroom and memory bandwidth to spare, and pays much less on a unified-memory laptop that is bandwidth-bound already. Drafting also costs resident memory, which on a 24GB budget you may not have. It is a per-deployment decision, not a global on switch — and acceptance rates run highest on structured output, so code and JSON tool calls benefit more than prose.
Benchmarks, including the losses
Meta evaluated against Gemma4-31B Thinking and Qwen3.6-27B Thinking, and beat them on roughly half of about two dozen benchmarks (SiliconANGLE). The split is not random.
Where Glimmer leads: MCP Atlas 75.5, DeepSearch QA 74.6, GAIA2 43.3, WildClawBench 47.6, SWE-Bench Pro 51.2, SciCode 43.6, CharXiv Reasoning 78.8, IFBench 77.0, AIME 2026 94.7, AA-LCR 80.0, BEAM 128K 65.1.
Where it trails: GDPval-AA 953 against Qwen's 1141, SkillsBench 44.3, OSWorld-Verified 65.9, SWE-Bench Verified 76.0, TerminalBench 2.1 51.7, ScreenSpot Pro 75.4, OmniDocBench v1.5 75.8, MMMU Pro 74.0, GPQA Diamond 83.5, HLE 22.0.
Read the two lists as a profile rather than a scoreboard. The wins cluster in tool orchestration, multi-hop retrieval, instruction adherence, and long-context recall — exactly the second post-training run's target. The losses cluster in GUI grounding, document parsing, broad multimodal reasoning, and hard science QA. Meta pointed the model at agent loops and long documents and got a model that is good at agent loops and long documents. On OSWorld and ScreenSpot, where the task is pixel-level desktop grounding, a 27B Qwen checkpoint tuned for it wins.
One number deserves attention before anything ships to production. On Siren AgentDojo, prompt-injection attack success is 28.4% with 94.2% task utility, and on CI Memories the violation rate is 26.4%. Gemma4 is safer on both. A model that retries failed tool calls instead of stopping is, by construction, more persistent in the presence of a hostile instruction embedded in a retrieved page. Treat tool permissions and content provenance as load-bearing, not as hardening you add later.
The trend line: capability is decoupling from parameter count
Here is the argument this release supports.
For four years the reliable way to get a more capable model was to make it bigger. That relationship has not inverted, but it has loosened, and the mechanism doing the loosening is now well understood: a large model generates high-quality training signal, a small model absorbs it for a bounded task distribution, and targeted post-training recovers most of the gap on that distribution while the small model keeps its deployment economics. Glimmer is that recipe executed at production scale and released under a permissive licence — see our primer on distillation as a service for the mechanics.
The consequence is a supply-side change. If a 29.6B dense model distilled from a frontier teacher can lead a 31B general-purpose model on tool orchestration while trailing it on document parsing, then the efficient unit of capability stops being "one model that does everything adequately" and becomes a set of narrow models, each strong across a deliberately small task distribution, selected per request.
You can already see the shape. Glimmer is not a general model — it is a long-context agentic model that also handles images. Qwen3.6-27B is stronger at desktop grounding. Something tuned on your own claims data will beat both on your claims data, at a fraction of the size, because the distribution it needs to cover is a fraction as wide.
The economics compound. A narrow 8B model tuned on one workflow can be trained in hours, evaluated against a task suite you actually own, and served at a cost that makes per-request routing viable. Ten of those cost less to run than one 400B generalist and are individually replaceable when a better checkpoint lands. That is the direction of travel: not one model getting steadily larger, but a fleet getting steadily more numerous and more specific, with the frontier labs supplying the teachers and the licences supplying the freedom to distil.
Meta's essay is, read commercially, a bid to be the teacher. Zuckerberg explicitly urged regulators to reconsider their stance on distillation — training a weaker model on a stronger one's outputs — while the administration moves against Chinese labs for doing exactly that (SiliconANGLE). A company that wants an ecosystem of derivatives needs distillation to stay legal.
Switching is the hard part, not running
If the fleet thesis holds, the operational problem moves. Running one model is a solved problem — llama.cpp had day-zero support, vLLM serves it through the transformers backend, and Ollama, LM Studio, Together and Fireworks were named as launch partners (Hugging Face).
Running eleven models and choosing between them per request is not solved. The problems that appear are specific:
Memory is exclusive. Two 20GB models do not coexist on a 24GB card. Switching means eviction, and eviction means cold-start latency unless something is managing residency against observed traffic.
Prompts are not portable. Glimmer's vocabulary is 202,048 tokens with its own special-token conventions and its own chat template. A prompt tuned against one checkpoint's template silently degrades against another's.
Cache boundaries move. Prefix caching economics differ per model. A prompt layout that is cheap on one is expensive on the next.
Routing needs ground truth. Deciding that a request should go to the agentic model rather than the document model requires an eval suite over your own traffic. Benchmark tables cannot make that call for you.
Failure modes differ. A 28.4% injection success rate is a property of this checkpoint. Swap the model and your threat model changes with it.
None of these are research problems. They are platform problems, and they are the reason "just download the weights" and "run a fleet in production" are different sentences.
Where Swfte sits
Our commitment is narrow and we intend to keep it: Swfte is the place you host these models, on your hardware or ours, behind one interface.
Glimmer is available in Swfte Connect now. Two deployment paths, same API:
On device. Through the Connect embedded SDK, the 17GB build runs on a 24GB workstation card or an Apple silicon laptop, with DFlash on or off per deployment. Weights and inference stay local — the relevant path when the input is patient data, source code under NDA, or anything that cannot leave the building. We covered the robotics and disconnected-edge case separately.
Clustered cloud. The same model, BF16 or quantised, on our infrastructure, with residency and cold-start handled for you. Our local-versus-cloud deployment guide walks the decision.
The point of both being one API is switching cost. Route Glimmer for long-context tool orchestration, route something else for desktop grounding, route your own fine-tune for the workflow you know best, and change any of those decisions without rewriting the calling code. When the next 30B checkpoint lands — and on current cadence that is weeks, not quarters — you change a routing rule.
That is the bet: model supply is going to keep fragmenting into narrower, cheaper, more numerous checkpoints, and the durable value is in the layer that lets you hold ten of them at once and pick correctly. We covered the same dynamic from the frontier-model side and from the very large open-weight side — Kimi K3's 2.8 trillion parameters need sixteen GPUs across two nodes. Glimmer needs one card. Both are open weights. Only one of them is going to end up on a laptop in a field office.
What to do this week
Pull meta-models/Muse-Glimmer-30B-GGUF at Q4_K_M with the mmproj projector weights and run it against your traffic, not the benchmark table. Specifically: measure tool-call accuracy on your own MCP surface, measure recall at your real context lengths rather than at 128K, and run an injection suite against any tool with write access before you enable one. Then compare against whatever you are paying an API for on the same requests.
If it wins on a slice of your traffic, that slice is now a routing rule rather than a line item. Try it in Swfte Connect and find out which slice.
Sources: Meta's Muse Glimmer release notes and model card, Hugging Face · SiliconANGLE, 10 August 2026 · Engadget, 10 August 2026 · Quartz, 10 August 2026
Benchmark figures are Meta's own, measured against Gemma4-31B Thinking and Qwen3.6-27B Thinking, and had not been independently reproduced at the time of writing. Memory arithmetic in this article is derived from the published model configuration.