Meta released Muse Glimmer 30B under Apache 2.0: where the local-agent benchmarks split

Meta released Muse Glimmer, a 30-billion-parameter model, on August 10, 2026, open sourcing the weights under a permissive Apache 2.0 license. The model comes from Meta Superintelligence Labs and is described as optimized for always-on local agent workflows, and while it requires over 55 GB of memory at full precision, 4-bit K-Quant shrinks the language model to under 20 GB so it runs on a single consumer GPU. Muse Glimmer scores 75.5 on the MCP Atlas agentic benchmark against 54.2 for Gemma4-31B and 62.5 for Qwen3.6-27B, yet it trails Qwen3.6-27B on OSWorld-Verified and TerminalBench 2.1. ASAP works from Meta's announcement and the published model documentation to separate what this model wins from what it loses.

The license is as much of the news as the benchmark table

Meta states that it is open sourcing the model weights under a permissive Apache 2.0 license. Apache 2.0 permits commercial use, redistribution, and derivative models without user-count thresholds or a separate approval process, and it carries an explicit patent grant. For an organization planning to ship the model inside a product, the legal review effectively disappears.

That matters because the license and the intended use are coupled. An always-on on-device agent runs inside user hardware, the number of devices is not something the distributor controls, and fine-tuning derivatives for specific jobs is routine. A conditional license generates recurring compliance cost in exactly that shape, and Apache 2.0 drives the cost to zero.

Distribution opened just as wide. The model is available at meta-models/Muse-Glimmer-30B on Hugging Face with a separate GGUF quantized release, and Meta names Ollama, LM Studio, llama.cpp, ExecuTorch, MLX, vLLM, SGLang, Together AI, Fireworks AI, and OpenRouter as partners. Local runtimes, serving frameworks, and hosting providers were all in place on day one.

Cutting 55 GB down to under 20 GB is the real product decision here

The most operationally consequential number in this release is memory, not benchmark score. Meta notes that a 30-billion-parameter model would require over 55 GB of memory at full precision, and that quantization shrinks the language model to under 20 GB. The stated target is a 24 GB or 32 GB envelope, and the hardware named is MacBook M4-Max, M5-Max, and RTX 5090.

Speed comes from DFlash speculative decoding. Meta reports that it increases Muse Glimmer decode speed by 3.1 times on RTX 5090, 1.8 times on M5 Max, and 1.5 times on M4 Max. The published model documentation describes DFlash as a lightweight block-diffusion drafter trained with a block size of 16, using one anchor token plus 15 proposed tokens.

Put the two numbers together and the target becomes legible. An always-on agent is defined less by the quality of any single response than by whether it can stay running, and that condition reduces to whether the weights fit in the machine and whether tokens arrive at a tolerable rate. Going from 55 GB to under 20 GB and adding a 3.1x decode speedup is not performance tuning; it is what makes the use case exist at all. Four-bit quantization is not free, however, and the release does not state whether the published benchmark scores were measured at full precision or on the quantized build.

The wins and the losses fall into different categories

Where Muse Glimmer clearly leads is multi-step work that involves calling tools. It beats both comparison models on MCP Atlas at 75.5 against 54.2 and 62.5, DeepSearch QA at 74.6 against 61.7 and 71.1, τ³-Banking at 23.5 against 15.1 and 16.7, WildClawBench at 47.6 against 37.6 and 43.2, and GAIA2 at 43.3 against 36.4 and 40.0. It also leads IFBench at 77.0 against 76.0 and 70.8, and the long-context entries are its widest margins: AA-LCR at 80.0 and Beam 128K at 65.1.

The losses cluster in coding and computer control. OSWorld-Verified comes in at 65.9 against Qwen3.6-27B's 75.6, a 9.7-point gap, and TerminalBench 2.1 lands at 51.7 against 60.7, a 9.0-point gap. SWE-Bench Verified trails at 76.0 against 77.2, SkillsBench at 44.3 against 46.6, and GDPval-AA at 953 against 1141. On general knowledge, GPQA Diamond reaches 83.5 against Gemma4-31B's 85.7, and Humanity's Last Exam sits at 22.0 against 23.6 and 23.1.

This split does not look accidental. The wins concentrate in tool invocation, multi-step planning, and holding long context; the losses concentrate in directly manipulating an environment and in breadth of knowledge. The shape matches Meta's own framing of the model as built for local agents and function calling, local coding, and LLM-as-a-judge evaluation. At 30B, raising every axis at once is not available, so the choice of what to give up is the design, and Muse Glimmer traded knowledge breadth and environment-manipulation precision for orchestration. Leading SWE-Bench Pro at 51.2 against 36.9 and 50.2 while trailing TerminalBench fits the same picture: the planning is strong and the hands are less precise.

The safety numbers are a review item, not a selling point

For anyone evaluating deployment, the safety rows deserve the first look. On CI Memories, Muse Glimmer posts a violation rate of 26.4 against Gemma4-31B's 12.1, more than double. Its coverage of 64.8 exceeds Gemma4-31B's 53.0, and reading the pair together suggests a model that answers more and lets more through. Qwen3.6-27B is worst of the three at 53.4.

On Siren AgentDojo, which probes prompt-injection resistance, Muse Glimmer records a 28.4 attack rate with 94.2 utility. Gemma4-31B posts 25.6 and 90.8, and Qwen3.6-27B posts 40.3 and 92.7. Muse Glimmer has the highest utility of the three and is 2.8 points worse than Gemma4-31B on attack rate.

That combination matters because of the use case. An always-on local agent sits where it reads real user material such as files, calendars, and mail, and prompt injections arrive inside exactly that material. A 28.4 attack rate is a benchmark condition rather than a field risk rate, but it points the opposite way from the assumption that local means safe. Running locally removes the risk of data leaving the machine, not the risk of the model following a hostile instruction. Narrow tool permissions and a confirmation step before execution are worth building in specifically for this model.

Distillation sets the ceiling

Muse Glimmer is a distilled model rather than one built from its own pre-training run, and Meta names Muse Spark as the teacher. Meta says it trained Muse Glimmer on Muse Spark's outputs using logit distillation during pre-training, and that the training data spans more than 100 languages.

Distillation explains both why a 30B model posts these agentic scores and where the structural limit sits. A student's ceiling is set by its teacher, and areas the teacher handles poorly do not get filled in by distillation. It is also worth noting which artifact was opened: the student is under Apache 2.0 and the teacher is not. What was released is a product of capability rather than the machinery that produces it.

The practical consequence concerns fine-tuning expectations. Distilled models are stable inside the regions their teacher covered well, and they resist being pulled toward domains far from that distribution because the underlying capability was never independently built. An organization planning to specialize this model on internal data should first judge how close the target domain sits to general agentic work.

Where a local model makes sense first

The concrete opening here is work where data cannot leave the building. Tasks touching personal data, medical records, or unreleased financials have had the API call itself as the review blocker, which is why many agent projects stall at pilot stage. A 30B model under Apache 2.0 that runs in a 24 GB to 32 GB envelope means that review now has a route around it.

The cost structure changes too. An always-on agent makes many calls, and most of them are simple. Sending that entire load to an API scales cost with usage, whereas a local model front-loads the hardware cost and drives marginal cost toward the electricity bill. The likely design is two-tiered: local models handle continuous monitoring, classification, and tool invocation, while only hard judgments escalate to a frontier model.

What this release does not establish is performance in any specific language. The only statement is that training data spans more than 100 languages, no per-language metrics are published, and the comparison table carries no language-specific rows. Anyone evaluating adoption should measure on their own task set rather than infer from these benchmarks.

Open questions: self-reported measurement and the choice of comparisons

Every score in this comparison table is self-reported by Meta, the company that released Muse Glimmer on August 10, 2026. None of it is third-party reproduction, and the nature of that measurement should be stated plainly before the ordering is quoted anywhere. Agentic benchmarks swing considerably with tool configuration, attempt budgets, and grading methodology, so until outside parties match the conditions, the direction and size of gaps are more informative than the ordering.

The choice of comparisons also shapes the picture. Muse Glimmer is placed against Gemma4-31B and Qwen3.6-27B, two open models of similar size, and no frontier closed model appears. That is a defensible reference set for evaluating a 30B local model, but the question this table answers is which locally runnable model to pick, not whether the work should move local at all.

Finally, several specifics remain unpublished. The announcement does not state a context length, and it does not clarify whether the benchmark numbers reflect full precision or the sub-20 GB quantized build. How quantization loss manifests on agentic tasks matters especially for always-on use, and that answer will most likely come from community measurement rather than the release itself. External reproductions over the next few weeks will settle where this model actually stands.

Source: ASAP analysis based on Meta's announcement "Introducing Muse Glimmer: An Open Agentic Model That Runs on Your Device" (August 10, 2026) and the published model documentation