Meta releases Muse Glimmer 30B as an Apache 2.0 open-weight local agent model

• Meta shipped Muse Glimmer as an Apache 2.0 open-weight 30B dense model for always-on local agents, and Muse Spark 1.2 weights are also coming soon, according to finkd's announcement.
• The local story is real hardware math: alexandr_wang's quantization note says the language model is compressed to roughly 4-bit and under 20GB, leaving room for KV cache, the perception encoder, and DFlash.
• Glimmer is explicitly agent-first, with planning, tool calls, result checking, and failure recovery described in alexandr_wang's launch thread and shown in AIatMeta's Home Assistant demo.
• The benchmark profile is uneven: kimmonismus's benchmark count says Glimmer beats Gemma on 19 of 24 rows and Qwen on 14, while Qwen remains ahead on OSWorld, TerminalBench, and most multimodal tests.
• Day-0 support landed broadly, with Hugging Face weights live and runtime paths through Ollama, LM Studio, vLLM, SGLang, Together, Fireworks, OpenRouter, llama.cpp, MLX, and ExecuTorch listed in alexandr_wang's availability post.

The vLLM recipe has the oddest operational footnote: Glimmer emits channel-scoped reasoning and XML-style ATEM tool calls, not JSON tool calls, so serving requires paired muse_glimmer parsers. The GGUF repo breaks the local package into a 16.8GB text model, a 1.4GB perception encoder, and a 1.6GB DFlash drafter. Simon Willison's test used LM Studio's 18.16GB build to inspect Datasette and describe a pelican photo. Artificial Analysis gave Glimmer an 82% hallucination rate on AA-Omniscience, a sharp caveat for a model billed around agents.

Meta's launch framed Glimmer as the first open-weight model from Meta Superintelligence Labs and a return to permissive licensing after the Llama license era.

The shipped package has four concrete parts:

• 30B dense open weights under Apache 2.0, per AIatMeta's launch post.
• Hugging Face weights available immediately, per AIatMeta's resource post.
• Agent behavior built around planning, tool calls, self-checking, and failure recovery, according to alexandr_wang's agent note.
• A follow-on open-weight release for Muse Spark 1.2, announced in finkd's announcement and repeated in alexandr_wang's two-model note.

The footprint claim is more specific than "runs locally." Meta says full precision would require more than 55GB, while the 4-bit path shrinks the language model below 20GB.

The official model card lists three deployment targets:

• Full precision: 64GB VRAM target.
• K-Quant-Dynamic: 32GB VRAM target, 0.2% average degradation across 15 benchmarks.
• K-Quant-17GB: 24GB VRAM target, 1.0% average degradation across 15 benchmarks.

The GGUF repo gives the file-level version of that story: muse-glimmer-30B-kquant-17gb.gguf is 16.8GB, muse-glimmer-30B-kquant-dynamic.gguf is 19.7GB, mmproj-kquant.gguf is 1.4GB, and dflash-kquant.gguf is 1.6GB.

Community hardware notes were less magical. tomgreenwald's guide put an RTX 3090 around 40 tok/s, an RTX 5090 around 75 tok/s before DFlash, and warned that 16GB-class machines fall into low-bit quantization with quality loss.

DFlash is the latency trick. A small drafter proposes a block of tokens, and the main model verifies the block in parallel.

The official model card reports batch-1 greedy decoding speed with the K-Quant-17GB model plus the quantized DFlash drafter:

• RTX 5090: 74.9 tok/s to 233.4 tok/s, 3.1x.
• Apple M4 Max: 23.7 tok/s to 37.8 tok/s, 1.5x.
• Apple M5 Max: 26.6 tok/s to 50.2 tok/s, 1.8x.

rohanpaul_ai's breakdown made the hardware asymmetry plain: speculative decoding paid off far more on a desktop GPU than on Apple Silicon.

Meta's own table says Glimmer is strongest on agentic tool and task benchmarks, with gaps on some coding, desktop, and multimodal rows.

The headline wins in Meta's table:

• MCP Atlas: 75.5 for Glimmer, 54.2 for Gemma4-31B, 62.5 for Qwen3.6-27B.
• DeepSearch QA: 74.6 for Glimmer, 61.7 for Gemma, 71.1 for Qwen.
• τ³-Banking: 23.5 for Glimmer, 15.1 for Gemma, 16.7 for Qwen.
• SWE-Bench Pro: 51.2 for Glimmer, 36.9 for Gemma, 50.2 for Qwen.
• AA-LCR: 80.0 for Glimmer, 68.3 for Gemma, 73.3 for Qwen.

The strongest caveat in rohanpaul_ai's benchmark summary is where the lead reverses: Qwen3.6-27B scores higher on OSWorld-Verified, TerminalBench 2.1, and SWE-Bench Verified.

Artificial Analysis benchmarked Glimmer before public release and gave it a stronger parameter-efficiency read than a pure benchmark table shows.

Artificial Analysis scored Glimmer 35 on its Intelligence Index, 21 points above Llama 4 Maverick's 14, 5 points above Gemma 4 31B, and 3 points behind Qwen3.6 27B.

The same analysis flagged the nasty part: Glimmer scored 953 Elo on GDPval-AA v2, below the 1,000 human baseline, and its AA-Omniscience hallucination rate was 82% versus 49% for Qwen3.6 27B and 34% for Gemini 3.5 Flash-Lite.

Artificial Analysis still gave Glimmer a 44 on its Openness Index, tied with DeepSeek V4 Flash, GLM-5.2, and Ling 3.0 Flash, because Apache 2.0 and the methodology disclosure improved on Llama 4 Maverick.

The model card reads like a local-agent checklist rather than a chat-model spec.

The Hugging Face model card lists:

• 29.6B total parameters, including a roughly 1.8B ViT-G/14 perception encoder.
• 52 text-decoder layers with hidden dimension 6656.
• Local, Local, Local, Global repeating attention.
• 2,048-token sliding windows.
• 32 query heads and 2 KV heads, a 16:1 GQA ratio.
• 202,048-token vocabulary.
• 131,072+ token context length.
• Text plus image input, text output, and up to 4,096 visual tokens per image.

The vLLM recipe adds the serving gotcha: Glimmer does not emit JSON tool calls or wrap reasoning in conventional tags. It uses channel-scoped messages and ATEM tool-call markup, so vLLM requires both --tool-call-parser muse_glimmer and --reasoning-parser muse_glimmer, with special tokens preserved.

eliebakouch's notes compared the shape to Gemma 4, pointing to fewer text layers than Gemma 4 31B, more vision layers, a larger sliding-window attention span, and narrower attention width.

Meta says Glimmer was distilled from Muse Spark and then pushed toward agent traces, not simply post-trained as a generic chat model.

The official blog names three phases:

• Pre-training: logit distillation from Muse Spark outputs with a similar data mix as the teacher.
• Mid-training: longer-context, more agent-heavy data with richer reasoning traces, plus organic data.
• Post-training: supervised fine-tuning, on-policy distillation, and reinforcement learning across general, reasoning, coding, and agentic domains.

The model card says the training data included public multimodal content, third-party data, information from Meta products and services, external vendor curation, and Meta personnel curation, with a January 4, 2026 knowledge cutoff.

The runtime ecosystem showed up immediately, which is half the launch for a local model.

• SGLang reported about 230 tok/s on a single RTX 5090 with NVFP4 and DFlash in lmsysorg's note, while the SGLang post lists 236.4 tok/s per user and 1,452 tok/s batch-8 output throughput on RTX 5090 with NVFP4 and DFlash.
• vLLM published a Muse Glimmer recipe and launch command in vllm_project's post, including the required muse_glimmer tool-call and reasoning parsers.
• Ollama shipped initial MLX support on Apple Silicon, with more platform support coming, according to ollama's announcement.
• Together AI put Glimmer on serverless inference day 0, according to togethercompute's launch post.
• Baseten added one-click deployment from its model library, according to baseten's Model Library post.
• Unsloth published GGUF support and later claimed a 2-bit Glimmer run called 100+ tools on 14GB RAM, according to UnslothAI's 2-bit test.
• Cline exposed Glimmer through Ollama for coding-agent use, according to cline's Cline post.

The first useful hands-on posts were codebase inspection, self-deployment, local vision, and weird game tests.

• ai_for_success's repo test said Glimmer understood an existing repo, reviewed it, and created a new example matching the repo style.
• ai_for_success's Ollama test reported 45 to 50 tok/s running the MLX version locally via Ollama.
• simonw's vision test showed a laptop-local description of a pelican photo, and Simon Willison's post also ran Glimmer against a fresh Datasette checkout with a codebase question.
• ben_burtenshaw's Hugging Face demos had Glimmer quantize itself, and ben_burtenshaw's deploy demo had it deploy itself to a protected Hugging Face Inference Endpoint.
• rohanpaul_ai's arcade summary said Glimmer beat Gemma 4 31B across three local arcade-game prompts, but spent 83.4K tokens and 17.7 minutes versus Gemma's 17.8K tokens and 4.5 minutes.

Glimmer was the available model. Spark 1.2 was the strategic flare.

jack_w_rae's note described Spark 1.2 as a stronger sparse model optimized for enterprise hardware, while rohanpaul_ai's quote post repeated Meta's phrasing that Spark 1.2 is its latest foundation model and one of the leading models in the world.

emollick's read called Spark the bigger news, placing it behind the closed frontier and not quite at the frontier of open models from China, but as the strongest non-Chinese open-weight model released in a year.

The most concrete independent failure case came from a multi-turn voice-agent benchmark, not from coding.

Kwindla ran the GGUF quant through llama.cpp on an RTX 5090 and said Glimmer landed roughly in line with Laguna S 2.1 and Inkling on a hard task-agent benchmark with about 20 tools and lots of structured multi-turn input.

On Kwindla's 30-turn voice conversation benchmark, Glimmer did poorly on long-context recall and tool-calling judgment. The same thread attributed a long time-to-first-answer-token tail to runaway thinking, a mismatch with the model's agentic training target.