Muse Glimmer 30B: Meta Ships an Apache 2.0 Local Agent

Muse Glimmer 30B is Meta’s new local agent model — released Monday, August 10, 2026 by Meta Superintelligence Labs as a dense, multimodal, 30-billion-parameter model with its weights published under a genuine, unmodified Apache 2.0 license. It is small enough to run on a Mac or a PC with a single consumer GPU, and it is aimed squarely at always-on local agent workflows: function calling, local coding, and LLM-as-a-judge evaluation.

Three facts about this release are routinely garbled, so they are worth stating plainly up front. Glimmer is not a new model line — Meta says it is distilled from Muse Spark, the family’s flagship, and describes it as generally less capable than its teacher. It is dense, not a Mixture-of-Experts — the raw config.json shows a dense causal transformer with no expert routing anywhere. And it is multimodal — text and images in, text out, with a roughly 1.8B-parameter vision encoder inside the ~29.6B total. Audio is explicitly unsupported in both directions.

This guide covers what shipped and where, the distillation lineage and architecture, why the Apache 2.0 license is the real headline, Meta’s full benchmark table — including the rows Glimmer loses — and what the release means for teams weighing local agents against hosted frontier models.

The release landed as a coordinated set of surfaces. Meta’s launch announcement introduces the model and its training recipe; the weights live in the Hugging Face meta-models/Muse-Glimmer-30B repository — a Hugging Face-verified Meta organization — alongside three companion repos: pre-quantized GGUF builds, the DFlash drafter for speculative decoding, and ExecuTorch .pte builds for Apple Metal and NVIDIA Ampere-class targets. Meta also maintains a developer documentation page for the model.

Meta’s stated purpose is specific: a model optimized for always-on local agent workflows — small enough for a Mac or a PC with a single consumer GPU, covering local agents and function calling, local coding, and LLM-as-a-judge evaluation. The launch post lists a wide deployment ecosystem: local partners Ollama, LM Studio, and Unsloth; edge frameworks llama.cpp, ExecuTorch, and MLX; scale serving via vLLM and SGLang; hosted access through Together AI, Fireworks AI, and OpenRouter; and PyTorch’s TorchTitan for further fine-tuning. AMD, Arm, Dell, Intel, and NVIDIA are named as hardware partners for future device-level optimization.

One nuance on availability: Meta’s own blog says llama.cpp, MLX, and ExecuTorch integrations are landing “in the coming days,” while Hugging Face’s companion post states day-0 support shipped in transformers, llama.cpp, vLLM, and Inference Endpoints, with a GGUF repo live from the start. Both are true at once — basic support at launch, with optimized integration work rolling out after.

The most common misreading of this launch is that Meta added a fourth product line. It did not. Glimmer is the small, local tier of the existing Muse family, created by distillation: in Meta’s own words, the team trained Muse Glimmer on Muse Spark’s outputs using logit distillation, leveraging a similar data mix as the teacher. No Meta primary states which Muse Spark version served as the distillation teacher.

The full training recipe runs in three phases: pre-training via logit distillation on the teacher’s outputs; mid-training on longer-context, more agent-heavy data with richer reasoning traces alongside organic data; and post-training combining supervised fine-tuning with on-policy distillation and reinforcement learning across general, reasoning, coding, and agentic domains. Meta says the model was trained and evaluated across a set of capability pillars — end-to-end agentic task completion, reliable tool use, multi-step reasoning, failure recovery, multimodal input, scaffold compatibility, controllable effort, and multilingual coverage across more than 100 languages.

We covered the top of this lineup in our guide to Muse Spark 1.2 and Muse Code, and Muse Code’s internals in our Muse Code deep dive. Glimmer extends that lineup downward rather than replacing any of it. Looking ahead: per VentureBeat’s reporting of a post by Mark Zuckerberg, Meta has said it will also release Muse Spark 1.2 weights — announced as forthcoming, not shipped, at the time of writing. Muse Spark itself remains proprietary as of this post’s date.

On scaffolding, the model card says Glimmer works across OpenClaw, Hermes Agent, and other agentic orchestration patterns (the launch blog itself names only OpenClaw). For identification: OpenClaw is an open-source multi-agent orchestration framework built around a central gateway process; Hermes Agent is Nous Research’s open-source, local-first multi-agent framework — a natural pairing for a model designed to run entirely on user-controlled hardware.

The second common misreading is architectural. Glimmer is not a Mixture-of-Experts model. The raw config.json declares MuseGlimmerForConditionalGeneration — a dense causal transformer paired with a separate perception encoder for vision, with no expert routing anywhere in the configuration. The language model runs 52 layers at hidden size 6656, with grouped-query attention at 32 query heads against just 2 KV heads (a 16:1 ratio), head dimension 128, and a SiLU-gated FFN at intermediate size 19,968.

The attention layout is the interesting part for long-context efficiency: the 52 layers repeat a strict three-local, one-global pattern — three sliding-window layers (window 2048) followed by one full-attention layer. Rotary position embeddings run at θ = 500,000 on the local layers, while the raw config shows a literal 0 at every fourth position — the global layers carry no rotary encoding at all. Stated context length is 131,072 tokens, the vocabulary is 202,048 entries (200,000 BPE plus 2,048 special tokens), and the stated knowledge cutoff is January 4, 2026.

Vision input runs through a roughly 1.8B-parameter ViT-G/14 encoder — 50 layers, hidden width 1536, patch size 14, up to 4,096 visual tokens per image — based on Meta’s own Perception Encoder research. That encoder sits inside the ~29.6B total parameter count. The modality contract is precise: interleaved text and images in, text out, and the model card’s out-of-scope section states plainly that audio input and output are not supported.

“Open” model releases have trained everyone to read the fine print, and Meta’s own Llama history is the reason: the Llama community license drew years of criticism for bespoke restrictions. Glimmer breaks that pattern, and the claim checks out at multiple independent layers. The repository’s LICENSE file is the full, unmodified Apache License 2.0 text — not a “Muse Community License” dressed up with the Apache name. The Hugging Face metadata tags the repo apache-2.0, the card body states that all released artifacts are under Apache 2.0, and each of the three companion repos — GGUF, the DFlash drafter, and the ExecuTorch builds — carries its own independent Apache 2.0 tag rather than inheriting one.

There is one document worth understanding precisely: USAGE_POLICY.md ships alongside the license. It is a prohibited-uses policy — barring things like weapons development, critical-infrastructure operation, fraud, and use by minors — and it imposes behavioral expectations on deployers. But it is not a license term: it does not restrict redistribution, modification, or commercial use the way Llama’s community license did. Apache 2.0 governs the weights; the usage policy is separate deployment guidance.

Independent framing agrees. VentureBeat’s coverage calls this “a more permissive license than Llama ever carried,” noting Apache 2.0 permits unrestricted commercial use, modification, and redistribution. The same piece flags a nuance procurement teams should hold onto: as with most open-weight releases, it is the weights that are open — Meta has not released the training data or the training code. And for license-conscious comparison shopping in this size class, note that Google’s Gemma family ships under Google’s own bespoke Gemma terms rather than an OSI-approved license.

The strategic weight of this is easy to miss. VentureBeat frames Glimmer as Meta’s first fully open release since the company moved to the proprietary Muse Spark in April 2026 — which makes this a deliberate reversal, not a routine drop. In VentureBeat’s analysis, the closest US-lab comparison is OpenAI’s gpt-oss family: also Apache 2.0, but sparse MoE and text-only, where Glimmer is dense with native vision input.

A sourcing quirk worth knowing: Meta’s launch blog embeds its benchmark comparison as a chart image only. The Hugging Face model card carries the full table as text, and it is materially richer than the launch-day charts suggest. The table below transcribes it: Muse Glimmer 30B in High Reasoning mode against Gemma4-31B and Qwen3.6-27B, both in their thinking modes. Every cell is Meta’s own reported measurement — no independent third party had reproduced these numbers on the pages we reviewed at the time of writing. Bold marks the best of the three models on each row, following the card’s own convention.

The honest pattern: Glimmer wins the general agentic and tool-use category broadly — MCP Atlas, DeepSearch QA, τ³-Banking, WildClawBench, Gaia2, and SWE-Bench Pro — plus IFBench, AIME 2026, AA-LCR, and Beam128K on the reasoning side. It is not a clean sweep. Qwen3.6-27B takes TerminalBench 2.1 by a clear margin (60.7 vs Glimmer’s 51.7), edges SWE-Bench Verified (77.2 vs 76.0), and leads most of the multimodal rows plus GDPVal-AA v2, SkillsBench, and OSWorld-Verified. Gemma4-31B takes GPQA Diamond and HLE Text. For a model marketed on agentic tool use, losing the terminal-work row to Qwen3.6-27B is the most operationally relevant gap — terminal-heavy coding agents should benchmark both.

The card also publishes two security-oriented rows where directionality matters. On CI Memories, Gemma4-31B posts the lowest contextual-integrity violation rate at 12.1 (lower is better) against Glimmer’s 26.4 and Qwen3.6-27B’s 53.4, while Glimmer’s coverage of 64.8 sits between Qwen3.6’s 66.9 and Gemma4’s 53.0. On Siren AgentDojo, Glimmer records the highest utility of the three at 94.2 but a 28.4 attack success rate (lower is better) against Gemma4’s 25.6. A separate Preparedness section adds chem/bio safety benchmarks with Kimi K3 shown for reference context; Glimmer scores below Kimi K3 on all six of those rows — consistent with Meta’s own designation of Glimmer as outside its Frontier AI definition — though it still posts the highest score of the three size-class models on two of them, WMDP (Bio) at 86.5% and Lab Bench ProtocolQA at 80.2%.

The engineering that makes “local agent” more than a slogan is in the packaging. Meta ships two official quantized builds with measured quality deltas: K-Quant-Dynamic, targeting a 32GB memory envelope, at 0.2% average degradation across the 15 benchmarks Meta measured; and K-Quant-17GB, targeting 24GB, at 1.0% average degradation on the same card. Full precision requires 64GB. Both degradation figures are Meta’s own measurements, a caveat VentureBeat’s independent write-up also flags explicitly.

In concrete hardware terms — VentureBeat’s examples — the 24GB build lines up with an NVIDIA RTX 3090 or RTX 4090, the 32GB build with an RTX 5090, and on Apple silicon a MacBook Pro or Mac Studio with 32GB or more of memory can hold the full stack: model, KV cache, vision encoder, and drafter.

That drafter is the release’s second technical novelty. DFlash is a block-diffusion speculative decoder — described in a companion paper — that predicts blocks of 16 tokens per forward pass using a 5-layer draft model whose features tap five of the main model’s 52 layers. Meta’s own measurements, at batch size 1 with greedy decoding, show decode speed roughly tripling on an RTX 5090 (74.9 to 233.4 tokens per second via llama.cpp), with smaller gains on Apple silicon via ExecuTorch — 26.6 to 50.2 tokens per second on an M5 Max, and 23.7 to 37.8 on an M4 Max.

Because Glimmer is a self-hosted open-weight release, Meta itself lists no metered API price on the pages we reviewed. The one concrete number in circulation belongs to a specific surface: OpenRouter’s listing prices Glimmer at $0.35 input / $1.50 output per million tokens, with cached input at $0.04 per million — an OpenRouter provider rate, not a Meta list price. The listing also confirms the 131,072-token context and exposes the model card’s four reasoning-effort levels — low, medium, high, and xhigh — with medium as the default.

One catalog-hygiene footnote: OpenRouter’s listing appeared late on August 9 UTC, ahead of the August 10 date on Meta’s own blog post. Aggregator catalogs can lead a vendor’s announcement as well as lag it — one more reason to never derive a launch date from a listing timestamp in either direction.

Read as strategy rather than specs, this release marks a genuine shift. Meta went proprietary with Muse Spark in April 2026 and is now re-entering open weights at the tier where openness pays: the local agent layer, where distribution, ecosystem integrations, and developer trust compound — while the frontier tier stays closed and monetized. The license choice is the tell. Apache 2.0 answers the licensing objection enterprise legal teams raised against Llama-style terms, and it puts direct pressure on the size-class incumbents that ship under bespoke licenses. For the on-device agent trend we mapped in our small-language-model guide and our on-device agent forecast, Glimmer adds a US-lab entry with genuinely permissive terms.

Looking forward: the sub-35B, single-GPU class is getting crowded — NVIDIA shipped its own entry the very next day, covered in our companion piece on Nemotron 3.5 Lightning — and Meta has said, per VentureBeat’s reporting, that Muse Spark 1.2 weights are coming too. If that announced release ships, Meta would hold open entries at two tiers. None of that is guaranteed; what is already true is that a genuinely permissively-licensed, vision-capable, agent-tuned 30B model now exists for anyone to build on.

The practical adoption path mirrors what we recommend for any open-weight candidate: pull the quantized build that matches your hardware, replay a week of your real agent traffic against it, and measure completion quality, tool-call reliability, and latency against your current stack — vendor tables are a shortlist filter, not a decision. If you are weighing local open-weight agents against hosted frontier models for specific pipelines, our AI transformation engagements start with exactly this comparative evaluation.