Muse Glimmer-30B

Muse Glimmer-30B is Meta Superintelligence Labs' return to open weights: a dense 30-billion-parameter multimodal model released in August 2026 under an Apache 2.0 license. It was distilled from Muse Spark, Meta's larger, API-only model, and post-trained specifically for autonomous agent workloads rather than chat. That distinction matters more than the parameter count. Weights are ungated on Hugging Face, and Meta ships integrations for llama.cpp, MLX, ExecuTorch and vLLM.

The pitch is concrete. This is a model small enough to leave running on a Mac or a single consumer GPU, trained on the things that actually break small local models in agent loops: long-horizon tool calling, precise function schemas, failure recovery when a tool returns garbage, and LLM-as-a-judge evaluation. An 8B model can call one tool. It typically can't hold a coherent plan across forty turns or diagnose a malformed API response and retry.

It sits in the 27–32B open-weight tier alongside Qwen3.6 27B and Gemma 4 31B. What separates it is the ~1.8B perception encoder for interleaved text and image input, plus the fact that Meta published and validated its own quantization artifacts instead of leaving that work to the community. If you're building something that runs offline, on hardware you own, and has to keep working when a tool call fails, that combination is the reason to look at it.

• Type: Dense causal transformer with a ~1.8B perception encoder (ViT-G/14, 50 layers, width 1536, patch 14)
• Total parameters: ~29.6B, including the vision encoder
• Layers: 52 | hidden dimension 6656 | SwiGLU FFN, intermediate 19,968
• Attention: [Local, Local, Local, Global] repeating, 3:1 sliding-window to global ratio, 2,048-token window
• GQA: 32 query heads / 2 KV heads (16:1), head dim 128, gated attention on both attention types
• Position encoding: RoPE (θ = 500,000), applied to global layers only
• Vocabulary: 202,048 tokens (200,000 BPE + 2,048 special)
• Context length: 131,072+ tokens
• Modalities: text + image input, text output
• Knowledge cutoff: January 4, 2026

This is a dense model, not a mixture-of-experts. Every one of the 30B parameters is active on every token. There's no router, no expert offloading, and no domain-dependent variance in which path the network takes. The tradeoff is decode speed: a 30B-A3B MoE activates roughly a tenth of the parameters per token and will generate noticeably faster on identical hardware. Glimmer's counterargument is predictability, flat latency regardless of prompt domain, and weights that quantize cleanly to 4-bit without routing artifacts.

The attention design is what keeps 131k context affordable. A 16:1 GQA ratio is aggressive for this class (most models run 4:1 or 8:1), and it shrinks the KV cache substantially, the real bottleneck for an always-on agent holding a long history of tool output. Three of every four layers attend only to the last ~2,048 tokens; every fourth layer does full global attention. That's how the model holds a six-figure context without the KV cache crowding out the weights on a 24 GB card.

• Agentic task completion. Meta reports strong success rates on full-task benchmarks including DeepSearch QA, MCP-Atlas, τ3-Bench and SWE-Bench, scaffolds, code writing and debugging, multi-turn requests resolved end to end.
• Tool use and failure recovery. The model invokes tools with precise schemas across extended workflows, and when a call fails or returns something unexpected, it diagnoses the error and retries rather than halting. This is the single most useful behavior difference versus general-purpose models of similar size.
• Multimodal reasoning. Up to 4,096 visual tokens per image, interleaved with text. Screenshots, charts, documents, dashboards and UI state can all go into the context alongside the conversation.
• Coding. Repo-level edits through file tools in a harness, plus multi-file debugging. SWE-Bench is the relevant signal here, not single-function autocomplete.
• Multilingual. Trained on data from more than 100 languages.
• Controllable effort. Reasoning strength is adjustable, so you can trade quality against latency per task.

Concrete workloads this fits: local MCP tool-server orchestration, desktop agents that read the screen and act on it, private coding assistants over a retrieved codebase, document and chart extraction, and LLM-as-a-judge scoring for eval pipelines where you don't want to ship data to an API. Scaffold compatibility covers OpenClaw, Hermes Agent and other orchestration patterns.

Meta publishes three weight formats, each targeting a specific hardware envelope:

Degradation is Meta's average accuracy delta across 15 benchmarks. Add ~1.4 GB for the perception projection if you're feeding images, and ~1.6 GB for the DFlash drafter if you want speculative decoding.

Those figures are weight sizes, not complete memory budgets. KV cache grows with context length, so at 131k tokens with vision enabled you'll need to reduce context, quantize the KV cache, or move to a larger card.

By hardware tier:

• 24 GB (RTX 4090, RTX 3090, M4 Pro): run K-Quant-17GB. You lose about 1% average accuracy and keep roughly 7 GB of headroom for KV cache and the vision encoder.
• 32 GB (RTX 5090, RTX Pro Blackwell workstation): K-Quant-Dynamic is the default. Near-lossless, with enough room for long-context agent sessions.
• 64 GB+ (dual 32 GB cards, RTX Pro 6000 Blackwell, M3 Ultra): BF16, or K-Quant-Dynamic at full context with a large KV cache.
• Apple Silicon: use MLX. A 48 GB M4 Max runs K-Quant-Dynamic comfortably; a 36 GB machine can push longer contexts than a 24 GB discrete GPU because of unified memory.

Recommendation: start with K-Quant-Dynamic unless 24 GB is a hard ceiling. The 0.2% degradation is well inside run-to-run noise for agentic tasks, and the extra headroom buys you more context and fewer eviction problems. Only drop to K-Quant-17GB when you have no choice.

Expected speed: a dense 30B at Q4 under llama.cpp typically lands in the 25–45 tok/s range for single-stream decode on an RTX 4090 or 5090, and roughly 15–25 tok/s on an M4 Max. BF16 on a 64 GB card is bandwidth-bound and usually slower per token than Q4 on the same silicon. Speculative decoding with the DFlash drafter gives a meaningful bump on structured agent output. Benchmark on your own harness, prompt processing cost dominates the first turn of a long agent loop.

Getting started: Ollama is the quickest path. It consumes GGUF directly, so the official K-Quant files load without conversion. Drop to llama.cpp if you want manual control over context size, KV cache quantization or partial GPU offload. Use vLLM if you're serving multiple concurrent clients rather than one agent, and ExecuTorch for on-device deployment.

vs. Qwen3.6 27Bthe closest direct comparison: dense, similar parameter class. Qwen3.6 27B ships a longer native context window (roughly 2x) and a deeper ecosystem of fine-tunes and tooling. Glimmer counters with its vision encoder tuned for screenshots and documents, an official 24 GB quantization path, and agentic post-training centered on failure recovery. Choose Qwen when maximum context on one machine is the constraint. Choose Glimmer when the workload is tool-call loops with images in the loop.

vs. Gemma 4 31Bsimilar hybrid attention stack (5:1 local:global versus Glimmer's 3:1) and comparable gated attention, same dense scale. Gemma is the stronger general-purpose chat and instruction model. Glimmer is the more specialized agent model. For a chat assistant, either is fine; for an agent that has to survive flaky tools and multi-turn recovery, Glimmer is the tailored option.

Dense vs. MoEif decode throughput decides it, a 30B-A3B MoE activates far fewer parameters per token and will out-generate Glimmer on the same GPU. The dense design here buys flat, domain-independent latency and a simpler quantization story, at the cost of raw tokens per second.