Muse Glimmer 30B

Meta released Muse Glimmer on August 10, 2026: a 30-billion-parameter open-weight model built for one job, running agents on your own machine. The license is Apache 2.0, not a Llama-style community agreement, and the quantized weights fit in under 20 GB. That combination, a real open license plus single-GPU agentic performance, is what makes this release worth your afternoon. Here is what shipped, where it wins, where Qwen still beats it, and how to have it running before your coffee goes cold.

Muse Glimmer 30B: a local agent model with a real open license

Muse Glimmer is a 30B dense model. Every parameter activates for every token, so there is no Mixture-of-Experts routing (the technique where only a slice of a much larger network fires per token). Dense costs more compute per token than MoE, but it also means predictable memory use and no expert-routing overhead, which matters when the whole model has to live on one consumer GPU.

The model was not trained from scratch at this size. Meta distilled it from Muse Spark, its larger flagship, using logit distillation: the small model learns to match the big model's full output distribution instead of just its final answers. It also carries a dedicated perception encoder for image input, a context window of 120K+ tokens, and coverage of 100+ languages.

The headline for builders is the license. Apache 2.0 means commercial use, modification, and redistribution with no acceptable-use policy, no monthly-active-user cutoff, and no lawyer required. After years of "open-ish" Llama community licenses, Meta shipping a straight Apache 2.0 model is the actual news here.

How a 30B model fits in under 20 GB

Full-precision Muse Glimmer needs 55+ GB of memory, which rules out every consumer card. Meta's answer is two official quantized variants, K-Quant-Dynamic and K-Quant-17GB, that compress the weights to roughly 4-bit precision and land under 20 GB with what Meta describes as minimal accuracy loss. That fits a 24 GB card like an RTX 3090 or 4090, or unified memory on an Apple Silicon Mac.

Speed comes from DFlash, a small companion drafter model for speculative decoding. The drafter guesses several tokens ahead and the main model verifies the batch in one pass, so you get identical output faster. Meta reports 3.1x faster generation on an RTX 5090, 1.8x on an M5-Max MacBook, and 1.5x on an M4-Max. NVIDIA separately reports 20+ tokens per second per GPU at BF16/NVF4 precision on its Blackwell Ultra hardware.

Benchmarks: wins the agent tests, not everything

Meta compared Muse Glimmer against the two open-weight models in its size class, Gemma 4-31B and Qwen3.6-27B. These are Meta-reported numbers from the launch post; we have not independently tested them, and you should read them the way you read any vendor deck.

The pattern is clear and Meta, to its credit, publishes it. Muse Glimmer wins the agentic benchmarks, tool calling by 13 points over its nearest rival, and agentic search by 3.5. On raw coding it does not: Qwen3.6-27B edges it on SWE-Bench Verified and also leads on OSWorld-Verified and TerminalBench 2.1 in Meta's own table. Meta additionally reports strong results on tau-Bench, its published agent-workflow suite.

So the honest summary: if your workload is an agent loop, browsing, searching, calling MCP tools, recovering from failures, this is now the model to beat at 30B. If your workload is pure code generation, GLM-5.2 class coders and Qwen3.6 still have the edge.

Get it running in under 10 minutes

Launch-day ecosystem support is unusually complete. Official weights, an official GGUF conversion, and an ExecuTorch build are on Hugging Face, Unsloth has its usual quant spread, and there is a first-party Ollama library entry. If you have Ollama v0.32 or newer, this is the whole install:

ollama run muse-glimmer

For llama.cpp or LM Studio, pull a GGUF directly. The Unsloth repo carries the full quant ladder if you want something smaller than Meta's official 4-bit:

# official Meta GGUF
huggingface-cli download meta-models/Muse-Glimmer-30B-GGUF

# or Unsloth's quant spread
huggingface-cli download unsloth/Muse-Glimmer-30B-GGUF

Mac users get MLX support at launch, so LM Studio on an M-series machine works day one; Meta's own test hardware was an M4-Max and M5-Max. If you are serving the model rather than chatting with it, vLLM and SGLang recipes shipped alongside the release, and NVIDIA has a prebuilt NIM container plus NeMo AutoModel support for fine-tuning with SFT, LoRA, and RL. We covered the same local-first release pattern when Kimi K3 GGUFs landed, but at 594 GB that one was a server toy. This one actually fits.

Limitations and gotchas

A few things to know before you rearrange your stack. First, the 20 GB figure is the quantized model; full BF16 needs 55+ GB, so serious fine-tuning still wants workstation or cloud hardware. Second, the DFlash speedups assume you run the drafter alongside the main model, which costs extra memory; budget for that on a 24 GB card. Third, cards below 16 GB are out of luck locally, though Together AI, Fireworks, and OpenRouter all have hosted endpoints live.

And the benchmark caveat bears repeating: every number above is vendor-run. Independent replications will land within days for a release this big. We would treat the agentic wins as directionally real, since the margins are wide, and the coding parity claims as wait-and-see.

Who should use it, and what comes next

Use it now if you are building local agent workflows: MCP tool servers, research agents, browser automation, anything with a loop and a failure mode. A 30B Apache 2.0 model that wins tool-calling benchmarks and runs on a 4090 is exactly the gap the open ecosystem had, sitting between small models like DeepSeek-V4 Flash and the 100B+ giants nobody runs at home.

Skip it if you mainly need a code-completion model, where Qwen3.6 is cheaper to run at 27B and slightly better, or if you need vision output rather than vision input.

What comes next is the bigger story. Meta says an open release of Muse Spark 1.2, the teacher model Glimmer was distilled from, is on the roadmap. Zuckerberg framed the release around distributing capable models widely rather than centralizing them, and whatever you think of the framing, Apache 2.0 weights are the receipts. If Spark ships under the same license, the open-weight landscape shifts again.

Your under-10-minute move: run ollama run muse-glimmer, point it at an MCP server you already use, and see whether that 75.5 tool-calling score survives contact with your own stack.

Sources and further reading

• Meta: Introducing Muse Glimmer
• Muse Glimmer 30B on Hugging Face
• Unsloth GGUF quantizations
• Muse Glimmer on Ollama
• NVIDIA: Muse Glimmer local agent workflows
• Constellation Research: Muse Spark 1.2 on tap

Tested on: not independently tested. All benchmark and performance figures are Meta- or NVIDIA-reported from the launch materials linked above.
Date checked: 2026-08-10