Muse Glimmer: Meta's 30B Open-Weight Agent Model Claims to Beat Gemma4-31B and Qwen3.6-27B

One X post on the morning of 10 August 2026 said it more bluntly than any press release: "Holy meta is back." The release that post was reacting to — Muse Glimmer, Meta's first open-weight model since Llama 4 — landed the same day, and Meta's own announcement is nearly as aggressive as the tweet. The 30-billion-parameter model's benchmark table claims it beats Go​ogle's Gemma4-31B on 19 of 24 rows and Alibaba's Qwen3.6-27B on 14 of 24, headlined by the agentic benchmark MCP-Atlas, where Meta reports 75.5 against 54.2 and 62.5 respectively.

Before "smoked" becomes a fact in your head, note who produced those numbers. Every score in Meta's table was run by Meta, against rival models whose setups Meta itself acknowledged it had not tuned. Muse Glimmer has no entry yet on Artificial Analysis, the independent leaderboard that does track this exact size class — where Qwen3.6-27B currently holds an Intelligence Index of 46 and Gemma4-31B sits at 39. This is therefore two stories at once: a genuinely consequential open-weight release from Meta, and a benchmark claim that will take weeks to verify. This piece keeps them separate.

What Muse Glimmer actually is

Muse Glimmer is a 30B dense, multimodal model — text plus image input through a dedicated perception encoder — trained on more than 100 languages and released under the permissive Apache 2.0 license. Its weights are on Hugging Face at meta-models/Muse-Glimmer-30B. It is a distilled version of Meta's larger proprietary flagship, Muse Spark 1.2, and the training recipe shows it: logit distillation from the teacher in pre-training, mid-training on longer-context, agent-heavy data, then supervised fine-tuning combined with on-policy distillation and reinforcement learning.

The product brief is as specific as the tech. Meta built Glimmer for "always-on local agent workflows" — an agent that lives on your machine and can call tools, follow multi-step plans, recover when a tool call fails instead of stopping, and dial reasoning effort up or down. The intended jobs are the unglamorous ones: local coding, function calling, schedule management, file organisation, LLM-as-a-judge evaluation. It is compatible with agent orchestration frameworks like OpenClaw, which is how a lot of people will actually run it.

The hardware story is the other half of the pitch. At full precision a 30B model needs upward of 55GB of memory; Meta's ~4-bit quantization brings that to roughly 17–20GB, which fits on a 24GB or 32GB consumer card (an RTX 5090 is the reference) and high-end Macs with unified memory. A speculative-decoding drafter — a small companion model Meta calls DFlash — speeds up generation: Meta reports about 3.1x on an RTX 5090 (from 74.9 to 233 tokens/sec in llama.cpp), 1.8x on an M5 Max, and 1.5x on an M4 Max, where unified memory is already less bandwidth-constrained.

Why this release matters beyond the spec sheet

The tweet got the shape of it right. Since Llama 4 in spring 2025, Meta had gone quiet on open weights, retreating to a proprietary frontier line under Meta Superintelligence Labs and Chief AI Officer Alexandr Wang. Muse Glimmer is the public return to the open-weight strategy that made Llama the most-downloaded family in AI — and it arrived wrapped in the strongest signal of intent yet: Zuckerberg published a 14-page essay, "The Future is for Everyone," alongside the launch, arguing that the real AI risk is concentrated control and that open weights are how America stays competitive with China's open-model labs. He called for looser US regulation of open-source AI, and Meta announced a $1 billion "Future is for Everyone Fund." Meta also said it plans to release the weights of the much larger Muse Spark 1.2 "in the coming weeks."

That context changes how you should read the benchmark table. This is not a research-lab curiosity shipping quietly; it is a strategy statement with a model attached. Glimmer is the "cheap local agent" position in Meta's lineup, deliberately undercutting the argument that serious agentic work requires a cloud API. Whether it actually delivers that is exactly what the verification question is about.

The "smoked" claim, row by row

Meta's table compares Muse Glimmer against Gemma4-31B and Qwen3.6-27B across 24 benchmark rows. Where it claims the biggest wins, the pattern is consistent: general agentic reasoning and search.

• MCP-Atlas (agentic tool use) — Muse Glimmer 75.5, Gemma4-31B 54.2, Qwen3.6-27B 62.5. This is the headline row and the biggest gap of the set.

• DeepSearch QA — 74.6 against 61.7 and 71.1.

• GAIA2 (general assistant) — 43.3 against 36.4 and 40.0.

• WildClawBench (agentic suite) — 47.6 against 37.6 and 43.2.

• SWE-Bench Pro — 51.2 against 36.9 and 50.2. Note the third number: 50.2 is Meta's own measurement of Qwen3.6-27B, while Alibaba's own published figure is 53.5. Same model, two different scores depending on who ran it.

• AIME 2026 — 94.7, IFBench 77.0, and AA-LCR 80.0 against Ge​mma's 68.3.

That is a strong row. But the table is not a clean sweep, and the rows where Muse Glimmer loses are as informative as the ones where it wins. Qwen3.6-27B holds the field on hands-on computer use and terminal-heavy work: SWE-Bench Verified 77.2 against Glimmer's 76.0, OSWorld-Verified 75.6 against 65.9, and TerminalBench 2.1 60.7 against 51.7, plus a consistent edge on multimodal tests like ScreenSpot Pro, OmniDocBench and MMMU-Pro. Gemma4-31B, for its part, posts the better safety record on the two metrics Meta reports — the lowest violation rate on CI Memories and the lowest attack success rate on Siren AgentDojo — and edges the narrow reasoning tests (GPQA Diamond, Humanity's Last Exam).

Read straight, Meta's claim is "beats the other two on most agentic benchmarks," and on its own table that is roughly true. The caveats are the point. Meta ran every row itself and admitted its test setups for the rival models were not tuned the way its own was. That is not a fraud allegation — untuned rival setups are a routine, even expected, sin in this industry — but it is exactly the reason vendor-run tables get independent confirmation. The Q​wen SWE-Bench Pro discrepancy above is the whole problem in miniature.

What the independent scoreboard says

Artificial Analysis does not list Muse Glimmer yet — the model is only days old, and AA's index is built on its own runs, which take time. But AA does track both rivals, which gives you the measured field the newcomer claims to be entering. As of the current index, Qwen3.6-27B carries an Intelligence Index of 46, described by AA as the most intelligent open-weights model under 150B parameters; Gemma4-31B sits at 39. Those are independent numbers, not vendor claims.

The independent picture also shows a cost wrinkle the headline numbers hide. AA's efficiency data has Qwen3.6-27B generating about 54.6 tokens/sec versus Gemma4-31B's 34.8, with Ge​mma's time-to-first-token faster — but Q​wen uses roughly 3.7x more output tokens to run the full index, which makes it about 21x more expensive to evaluate end-to-end. Token-hungry models are more expensive in the real world even when their benchmark scores are better, and that is a decision input no vendor table will volunteer.

So the honest state of the world as of this writing is: a strong vendor-reported result, no independent result at all yet for Muse Glimmer, and a rival field that is independently measured and split by task. "Smoked Ge​mma and Q​wen" is a claim in good standing; it is not yet a verified outcome. The verification markers to watch are an AA index entry, LMArena Elo, and community reproductions — all of which usually land within weeks of a release like this.

What it actually costs to run

Muse Glimmer is free — Apache 2.0, no per-token fee, no payment to Meta. The cost is the hardware you put under it. A 30B model at 4-bit needs about 17–20GB of resident memory plus room for KV cache, the perception encoder and the DFlash drafter, which is why Meta's own guidance is a 24GB or 32GB card or a high-end Mac. If you own that hardware, the marginal cost of running an always-on local agent is essentially electricity. If you do not, a 24GB GPU or a maxed M-series Mac is a real line item — and since 9 August there is a third option: rent it. The first hosted API listings, live as of that date, price Muse Glimmer at $0.35 per million input tokens and $1.50 per million output tokens on a 131K context window. That is a provider-listed marketplace rate rather than a Meta price, but it is the number you can actually pay today if you would rather not buy hardware.

That is the comparison worth making carefully, because "open weights, zero price" meets "hosted API, per-token price" on very different terms. When you run the numbers, price both sides honestly. On our side at OrcaRouter, the price you see for any of the 200+ hosted models is the provider's list price passed through at 0% markup, so a vendor price cut is live here the same day rather than after a margin recalculation — which makes the local-vs-hosted comparison a straight one. Muse Glimmer itself is not yet one of those 200+ models, so that pass-through does not apply to it today. But the discipline is the point: the way to price an unproven open-weight model is your own traffic, not a vendor table, and the routing DSL exists to run exactly that comparison once a model is behind an API you can call.

How you'd actually use it this week

Because it ships as open weights, "access" is not a sign-up — it is a download. The base repo is meta-models/Muse-Glimmer-30B on Hugging Face, with a GGUF variant already published and quantization variants arriving from third parties. Day-one runtime support was llama.cpp, MLX and ExecuTorch, with Ollama, LM Studio, vLLM and SGLang integrations landing in the days after release, and hardware optimisation work listed for AMD, Arm, Dell, Intel and Nvidia. The practical path for most people is: pull the GGUF, load it in llama.cpp or a local runner, point an agent scaffold at it. Meta hosts no public API for Glimmer itself, and the local path is the one the model was built around — but the hosted path is no longer hypothetical: third-party platforms began serving it on 9 August, so "download and run" and "call an API" are both live options now.

One honest note about us specifically: Muse Glimmer is still not available through OrcaRouter. We route hosted APIs, and as of this update the model has not landed in our catalogue — the 0% markup and one-key-everything deal apply to the 200+ models we do route, and this is not yet one of them. When it is, the same key that reaches the rest of the catalogue reaches it with no new contract, and automatic failover is the mechanism that makes it safe to point real traffic at a brand-new, vendor-reported model before it has an independent track record. That is the same reason the routing DSL exists: an unproven model should earn a production path on your data, not on its own press release.

The screenshot below is the Hugging Face card as it read on release day — its "not deployed by any inference provider" line refers to Hugging Face's own first-party inference, which is a separate thing from the third-party hosted API listings that went live on 9 August.

What to watch

Three things will settle this story, in rough order of speed. First, the promised Muse Spark 1.2 open-weights release — if the teacher ships in the "coming weeks," Glimmer stops being a one-off and becomes the thin end of a full open-weight lineup, which is the real strategic read on "Meta is back." Second, independent measurement: an Artificial Analysis index entry, LMArena placement, and community reproductions will tell you whether the 19-of-24 claim survives contact with someone who is not Meta. Third, the hosting wave — that one has already begun. Providers started serving Glimmer on 9 August, so the local-versus-hosted question is now an actual choice you can make with one API key; what remains to watch is how wide the hosting spread gets and what the per-token price does once the release-week novelty wears off.

The tweet was right about the news. Whether it was right about the verdict — that is a weeks-long question, and the honest position right now is that nobody outside Meta has run enough to know. What is already true is that a 30B Apache-2.0 agent model that fits on a consumer GPU and is backed by a full strategy push is a release to plan around, whatever its independent scores end up being.

Questions worth actually answering

Is Muse Glimmer truly open source?

It is open weights under the permissive Apache 2.0 license — anyone can download, modify, fine-tune and deploy it commercially without paying Meta. The careful phrasing is "open weights" rather than fully open source in the OSI sense, because the training data, the Muse Spark teacher's weights, and some tooling are not included. For practical purposes — you can run it, ship it, and sell a product on top of it — it is the same deal that made Llama the most-deployed open family in AI.

Does Muse Glimmer actually beat Gemma4-31B and Qwen3.6-27B?

On Meta's own table, yes on most agentic and search benchmarks, with the caveats that Meta ran the comparison itself and did not tune the rivals' setups. The honest picture is more specific: Meta wins the agentic-reasoning rows, Qwen3.6-27B wins hands-on computer use and terminal work plus most multimodal tests, and Gemma4-31B posts the better safety record. As of release day there is no independent index entry for Muse Glimmer at all, so treat the 19-of-24 claim as vendor-reported until someone else runs it.

Can I run it on a laptop?

Only if "laptop" means one with a 24GB-or-32GB discrete GPU or a high-end M-series Mac with enough unified memory — a 4-bit Muse Glimmer needs roughly 17–20GB plus headroom for KV cache, the perception encoder and the DFlash drafter. That is a real purchase for most people, and it is the hidden cost inside a "free" model. On integrated graphics or a 16GB machine, you would be looking at heavy quantisation and slow output rather than the always-on agent the release is built around.

Where do I get it — is it on an API?

The weights are on Hugging Face at meta-models/Muse-Glimmer-30B (with a GGUF variant), and you run it locally through llama.cpp, MLX, ExecuTorch, or the local runners now integrating it. Hosted API access is live too, as of 9 August, through third-party platforms at a listed $0.35 per million input tokens and $1.50 per million output tokens — so you no longer need to own a 24GB GPU to call it. Meta itself still hosts no public API for Glimmer, and it is not on OrcaRouter yet either. When it lands in our catalogue, the same key that reaches the rest of the catalogue will reach it; until then the two honest paths are local inference or a third-party hosted platform.