
Muse Glimmer: What Meta's Technical Report Actually Settles About the 30B Local Agent
- OrcaNEWOrcaCyber: Hy4 Flash Abliterated / Uncensored2026-11-18$0.07 / $0.28 per 1M tokens · 186 tok/s
- openaiNEWOpenAI: GPT-6.2 Astra2026-11-17$8.00 / $40.00 per 1M tokens · 76 tok/s
- openaiNEWOpenAI: GPT-6.2 Sol2026-11-17$2.00 / $10.00 per 1M tokens · 151 tok/s
- tencentNEWTencent: Hy4 Flash2026-11-16$0.02 / $0.07 per 1M tokens · 246 tok/s
- AlibabaNEWQwen: Qwen4 Max2026-11-16$1.50 / $4.50 per 1M tokens · 207 tok/s
- GoogleNEWGoogle: Gemini 4 Carbon2026-11-10$2.00 / $10.00 per 1M tokens · 94 tok/s
- AnthropicNEWAnthropic: Claude Fable 5.22026-11-09$8.00 / $40.00 per 1M tokens · 221 tok/s
- OrcaOrcaCyber: GLM 5.3 Abliterated / Uncensored2026-11-04$3.00 / $5.00 per 1M tokens · 99 tok/s
- OrcaOrcaCyber: Hy4 Abliterated / Uncensored2026-11-04$0.80 / $1.60 per 1M tokens · 131 tok/s
- OrcaOrcaCyber: Kimi K3.1 Pro Abliterated / Uncensored2026-11-04$2.00 / $5.00 per 1M tokens · 82 tok/s
- tencentTencent: Hy42026-11-04$0.83 / $2.50 per 1M tokens · 122 tok/s
- OrcaOrcaCyber: MiniMax M3.1 Flash Abliterated / Uncensored2026-10-29$0.80 / $1.60 per 1M tokens · 105 tok/s
- OrcaOrcaCyber: GLM 5.3 Flash Abliterated / Uncensored2026-10-27$0.80 / $1.60 per 1M tokens · 67 tok/s
- openaiOpenAI: GPT-6.1 Terra2026-10-26$1.00 / $5.00 per 1M tokens · 36 tok/s
- OrcaOrcaCyber: Qwen3.8 Flash Next Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 89 tok/s
- OrcaOrcaCyber: MiMo V2.6 Flash Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 39 tok/s
- MoonshotMoonshotAI: Kimi K3.1 Pro2026-10-2447Intelligence
- OrcaOrcaCyber: DeepSeek V4.1 Flash Abliterated / Uncensored2026-10-23$0.80 / $1.60 per 1M tokens · 222 tok/s
- minimaxMiniMax: M3.1 Flash2026-10-1929Intelligence
- OrcaOrca: OrcaCyber Ultra 1.02026-10-17$5.00 / $10.00 per 1M tokens · 104 tok/s
Meta published the technical report for Muse Glimmer on 19 October 2026, seventy days after the model itself shipped on 10 August. That gap is why the paper matters more than a routine writeup: it is the most detailed Meta document on the model so far — it shows the arithmetic behind the consumer-hardware pitch, and it states which benchmark rows Meta ran itself and which it borrowed from someone else. Muse Glimmer is a 30-billion-parameter dense model, Apache 2.0, text and image in, distilled from Meta's frontier Muse Spark teacher, and it is benchmarked throughout the report against Gemma4-31B and Qwen3.6-27B. The report also prices that distillation properly for the first time: 55.7GB of BF16 weights compressed to 19.65GB so the language model fits a 32GB card, with the quality cost measured rather than asserted. The documented AI failures and agent incidents behind releases like this one are collected in the OrcaRouter AI Incident Archive where each entry carries its own sources, severity, confidence grade and disputed flag.
Two of the paper's disclosures are less flattering than the launch blog was. The first is that the benchmark table is a mixture, not a Meta-only sweep: four rows come from Artificial Analysis, two rival figures are those rivals' own self-reports, and the rest are Meta's internal runs against setups Meta still concedes were not tuned for the competitors. The second is that the verification this piece originally said would take weeks has already happened. Artificial Analysis has scored Muse Glimmer, and on its current index the model sits at 17 — behind Qwen3.6-27B at 21, ahead of Gemma4-31B at 15. Meanwhile the promise Meta made alongside the launch, open weights for the much larger Muse Spark, was kept on 15 October as Muse Spark Open: 816B total parameters with 42B active, under a licence that is not Apache 2.0.
What the report says the model actually is
The architecture is now public down to the tensor shapes, and it explains most of the behaviour people have been arguing about. Muse Glimmer totals about 29.6B parameters: roughly 25.16B in 52 transformer blocks, 1.34B of untied token embedding, 1.34B of untied output projection, and a separate 1.8B perception encoder — a ViT-G/14 with 50 layers at width 1536, patched at 14 pixels against a 448-pixel reference grid. Hidden dimension is 6,656. Attention is grouped-query, 32 query heads against 2 key-value heads at a 16:1 ratio, with a 2,048-token sliding window in a repeating three-local-then-one-global pattern, and RoPE applied only to the local layers. The vocabulary is 202,048 tokens on the Llama 4 BPE tokenizer, and context is 128K-plus. Knowledge cutoff is 4 January 2026.
Two numbers in the paper deserve more attention than they got on launch day. The first is the language count: the abstract says "over a hundred languages," the body says approximately 140, and the appendix reports an Omnilingual-GAIA2 score of 60.4 against Gemma4-31B's 37.5 and Qwen3.6-27B's 45.0. That is a large gap and, like everything else in the table, it is Meta's own run. The second is the training recipe. Pre-training is logit distillation from Muse Spark using the teacher's top 256 logits, with KL divergence for the first 95% of the run and a switch to cross-entropy on ground-truth targets for the last 5% to correct the truncation bias that top-k distillation introduces. Mid-training extends context from 32K to 128K and injects agentic trajectory data; post-training is supervised fine-tuning, then on-policy distillation, then multi-objective reinforcement learning. Meta states plainly that on-policy distillation beat a reinforcement-learning-only recipe at this size — a useful data point for anyone training a small agent model of their own.
The product brief has not changed. Meta built Glimmer for "always-on local agent workflows" — an agent that calls tools, follows multi-step plans, recovers when a call fails instead of stopping, and can 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 runs under orchestration frameworks such as OpenClaw, which the paper cites by name as the reason demand for compact, reliable tool-callers exists at all.
Where the "fits on your GPU" claim gets its numbers
This is the section the technical report exists to settle, and it holds up better than the marketing did. At BF16 the weights occupy 55.7GB. Meta targets deployments with 24GB or 32GB of memory, reserving room for an unquantised KV cache, the perception encoder and the DFlash drafter, and therefore aims for language-model weights under 20GB. It evaluated seven post-training quantisation schemes — GPTQ, AWQ, uniform NVFP4, uniform MXFP8, llama.cpp's Q4_K_M, a calibration variant called Greedy-KL, and an adapted EvoPress — against held-out negative log-likelihood and then against 15 downstream benchmarks.
The result is two named deployment profiles rather than one vague "4-bit" claim. The 32GB profile is EvoPress at 19.65GB of weights, and across the 15 benchmarks it averages 75.6% against BF16's 75.7% — a tenth of a point. The 24GB profile is Q4_K_M at a smaller footprint, averaging 74.8%, nine-tenths of a point down. Average response length moves from 11,070 tokens at BF16 to 11,417 at EvoPress and 10,774 at Q4_K_M, so the common worry that aggressive quantisation inflates chain-of-thought length does not show up here. Those are Meta's measurements on Meta's evaluation mix; they are the most concrete quality-versus-memory numbers anyone has published for this model, and they are still vendor numbers.
Speed is the one place the paper is thinner than the blog post. The report states that 4-bit weights plus speculative decoding produce "practical speeds on a single RTX 5090" and describes the drafter in detail — five layers, block size 16, 32 query and 8 key-value heads, trained offline on on-policy rollouts with the D-PACE objective — but publishes no throughput table. The numbers in circulation, roughly 3.1x decode speedup on an RTX 5090 (74.9 to 233 tokens/sec in llama.cpp), 1.8x on an M5 Max and 1.5x on an M4 Max, come from Meta's launch material and model card, not from the report. Treat them as vendor-stated until someone reproduces them on their own machine, which for a local model is a genuinely easy experiment to run.
Why this release matters beyond the spec sheet
Since Llama 4 in spring 2025, Meta had gone quiet on open weights, retreating to a proprietary frontier line under Meta Superintelligence Labs. Muse Glimmer was the public return to that strategy, and it arrived with a 14-page Zuckerberg essay, "The Future is for Everyone," arguing that concentrated control is the real AI risk, plus a $1 billion fund of the same name. The paper does not repeat the politics; it does something more useful, which is to show that the open-weight return was not a one-off gesture.
On 15 October Meta released the weights of Muse Spark Open — 816B total parameters, 42B active, a 1M-token context, and, per Meta, capable of running on two Apple M5 Ultra Mac Studios with MLX. That is the teacher's open-weight sibling, and it answers the question this piece originally left hanging. The answer comes with an asterisk: Muse Spark Open ships under the Muse Model License with limited commercial terms, not Apache 2.0. Glimmer remains the more permissive of the two and, at 30B, the only one of the pair that fits in a single consumer GPU's memory. Meta's own positioning is that Spark Open is the desktop-class model for people with a Mac Studio stack; Glimmer is the one for a 24GB card.
All of the Spark Open figures above are Meta's, and the "runs on two Mac Studios" claim in particular has not been independently reproduced. What is not in dispute is the shape of the lineup: a permissive 30B agent model, a restricted 816B flagship, and a frontier API tier above both. That is a coherent open-weight strategy rather than a single release, and it is the thing to price into any decision about building on Meta's smaller model.

The "smoked" claim, row by row
The scoreboard above was generated on release day, and one line in it has since been overtaken: its Artificial Analysis column still reads "no entry" for Muse Glimmer. Meta's scorecard itself compares Muse Glimmer at high reasoning strength against Gemma4-31B and Qwen3.6-27B across three dozen rows. The pattern from launch day holds: the biggest wins are general agentic reasoning, search and multilingual work.
• MCP-Atlas (agentic tool use) — Muse Glimmer 75.5, Gemma4-31B 54.2, Qwen3.6-27B 62.5. Still the headline row and the largest gap of the set.
• DeepSearch QA — 74.6 against 61.7 and 71.1; GAIA2 — 43.3 against 36.4 and 40.0; WildClawBench — 47.6 against 37.6 and 43.2.
• GDPval-AA v2 — 953 Elo against Gemma's 811 and Qwen's 1,141. Worth pausing on: on economically valuable knowledge work, Qwen wins by a wide margin.
• SWE-Bench Pro — 51.2 against 36.9 and 50.2; ARC-AGI — 66.9 at high reasoning, 67.9 at the new xhigh tier the report adds; LiveCodeBench Pro (2025 Q2) — 64.1 at high, 66.8 at xhigh.
• τ³-Banking — 23.5 against 15.1 and 16.7; PinchBench (tool use) — 90.5.
The rows where it loses are as informative. Qwen3.6-27B holds hands-on computer use and terminal work: OSWorld-Verified 75.6 against Glimmer's 65.9, TerminalBench 2.1 60.7 against 51.7, SWE-Bench Verified 77.2 against 76.0, and it edges SkillsBench at 46.6 against 44.3. Gemma4-31B posts the better privacy and safety record — a CIMemories violation rate of 12.1% against Glimmer's 26.4% and Qwen's 53.4%, and the lowest attack success rate on Siren AgentDojo at 25.6% against Glimmer's 28.4% and Qwen's 40.3%. Gemma also edges the narrow reasoning tests, GPQA Diamond at 85.7 against 83.5 and Humanity's Last Exam at 23.6 against 22.0.
The methodology appendix is the part that changes how you should read all of the above, and it corrects what this piece said at launch. Not every row is Meta's own. For rival models Meta reports "the most favorable result between self-reported scores or our internal reproductions," and four benchmarks — τ³-Banking, GDPval-AA v2, Terminal-Bench 2.1 and SciCode — are sourced from Artificial Analysis rather than run in-house. The SWE-Bench Verified figure for Qwen3.6-27B is Qwen's own self-report. The SWE-Bench Pro figure for Qwen is Meta's internal run, because Qwen's published number came from a refined version of the benchmark and Meta evaluated the original task set. For the rest, Meta reproduces the rivals itself and says its agent tools and system prompts "may not be specifically tuned for proprietary third-party models."
That is a more careful disclosure than the launch blog offered, and it cuts both ways. It is not a clean vendor sweep, which strengthens the table's credibility. But "most favorable between self-report and our reproduction" is a rule that can only help the rival on rows where the rival's own number is higher, and Meta's untuned-setup caveat still applies to every row it generated itself. The row-level detail is now auditable, which is what you want; the direction of the bias is not fully knowable from the paper.
What the independent scoreboard says
Artificial Analysis has now scored the model, which retires the "no independent result yet" caveat this piece carried through August. On AA's current index Muse Glimmer at high reasoning strength carries an Intelligence Index of 17, ranked 14th of 141 models in its comparison set. Qwen3.6-27B sits at 21 and Gemma4-31B at 15. AA also measures 137 output tokens/second with a 0.91s time to first token — fast for the class, ranking 16th of 64 — and a cost of about $0.06 per Intelligence Index task.
The levels need a caveat the ranking does not. AA's release-week writeup put the same three models at 35, 38 and 30 on its index; the current model pages put them at 17, 21 and 15. The absolute numbers moved, the order did not. Whatever the cause of the rescale, the stable fact across both readings is the ranking: Qwen ahead of Glimmer on the aggregate, Glimmer ahead of Gemma, and Glimmer ahead on the agentic-specific rows. That supports a narrower claim than "leads comparably-sized open models" — on a general intelligence index, a 27B model from April still wins — and the narrower claim is the accurate one.
AA's release-week assessment added a finding worth carrying forward: a hallucination rate of 82% for Muse Glimmer against 49% for Qwen3.6-27B, with an AA-Omniscience index of −33. For an agent that runs unattended on your machine and calls tools, that is the number that should shape how much autonomy you give it, more than MCP-Atlas does. AA also now marks Qwen3.6-27B as deprecated in favour of Qwen3.8-27B, so the rival Glimmer is being compared against in most of this table is no longer its vendor's current model — a detail Meta's comparison could not have anticipated in August and that the report, published in October, does not address.
The capture below is the comparison page as it stood before Glimmer was scored, which is why it shows the field Glimmer was entering rather than Glimmer in it. Read it as the pre-verification baseline, not as current standings.

What it actually costs to run
Muse Glimmer itself is free — Apache 2.0, no per-token fee, no payment to Meta, and the report confirms that the release includes full-precision weights, the 4-bit variants and the DFlash speculation head. The cost is the hardware underneath it. BF16 needs 55.7GB, which is two cards or none of the consumer ones. The 32GB EvoPress profile is the one to want if you are buying: it costs a tenth of a point of average accuracy against BF16 and fits a single 32GB card or a high-end Mac with unified memory. The 24GB Q4_K_M profile costs nine-tenths of a point and fits an RTX 5090-class card, which is a reasonable trade for an agent that runs continuously.
If you would rather rent than buy, the tracked hosted rate is now lower than the one this page quoted in August. Artificial Analysis records $0.30 per million input tokens and $1.20 per million output for Muse Glimmer, against the $0.35 and $1.50 that the first listings carried on release, with an 87% cache discount and a blended rate near $0.21. Those are provider-listed marketplace rates rather than a Meta price — Meta publishes no hosted Glimmer endpoint of its own, and its developer documentation is written around pointing your tooling at a local Muse Glimmer server. Whether that movement is a cut by the same provider or a cheaper provider joining the tracked set is not something the index shows; either way the direction for an open-weight release is predictable.
The comparison worth making carefully is still local versus hosted, and it is not close in the way the marketing implies. A 32GB card is a fixed cost that amortises over every token you ever generate; a hosted rate is a marginal cost that scales with volume and disappears if the provider does. At $0.30 and $1.20 the hosted path is cheap enough that most teams should start there before buying hardware, and the local path only wins when the tokens cannot leave the machine or the volume is high enough that a GPU is cheaper than a bill.
One note about us, since it bears on how you would price any of this. Muse Glimmer is not in OrcaRouter's catalogue — we route hosted APIs, and the model has not landed as a hosted route, so the 0% markup and one-key-everything arrangement do not apply to it today. What does apply is the discipline: for the 200-plus models we do route, the price shown 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. That is the standard this comparison should be held to, whichever way you run Glimmer.
How you'd actually use it this week
Because it ships as open weights, access is a download. The base repo is meta-models/Muse-Glimmer-30B on Hugging Face, with the 4-bit variants and a GGUF build published alongside it. Day-one runtime support was llama.cpp, MLX and ExecuTorch; Ollama, LM Studio, vLLM and SGLang followed within days, with hardware optimisation work listed for AMD, Arm, Dell, Intel and Nvidia. The practical path for most people is unchanged: pull the GGUF, load it in llama.cpp or a local runner, point an agent scaffold at it, and start with the 24GB Q4_K_M profile unless you have 32GB to spare for the EvoPress one.
If you are deciding whether to build on it, the honest framing is that Glimmer is a good local agent with a documented quality floor, a measured hallucination problem, and a vendor benchmark table that is now partly auditable. The teacher is a different proposition: Muse Spark 1.2 is routable through OrcaRouter at $1.25 per million input and $4.25 per million output, so a team can run the small model on-device for the cheap, private, always-on work and route the hard cases to the large one over the same key. That split — local student for the routine loop, hosted teacher for the escalation — is the architecture the two releases actually support, and it is testable this week for the price of a GPU you may already own plus a token budget. Automatic failover is what makes the hosted half safe to put on a production path while a model is still building an independent track record, which is exactly the state Glimmer is in.
The screenshot below is the model 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 hosting that began on 9 August, and it is a useful reminder of how quickly that line aged.

What to watch
The three things that were going to settle this story have mostly resolved. The Spark open-weights release happened on 15 October. Independent measurement happened, and it said Qwen ahead on the aggregate, Glimmer ahead on agentics, Gemma behind both. Hosting spread, and the tracked price is now $0.30 and $1.20 rather than $0.35 and $1.50.
What is left is narrower and more interesting. First, whether anyone outside Meta reproduces the quantisation trade — the 0.1-point and 0.9-point gaps are the strongest part of the report and the easiest to check on a 24GB card. Second, whether the agentic lead survives a harness that was not built around the model; MCP-Atlas at 75.5 is the number to beat and the one most exposed to scaffold differences. Third, whether Meta's next small release inherits the Apache 2.0 licence or the restricted Muse Model License that Spark Open shipped under — that single choice decides whether the Glimmer line stays usable as a foundation for other people's products.
The launch tweet was right about the news and generous about the verdict. What the technical report adds is the part that was missing in August: you can now see what was measured, on what hardware, by whom, and at what cost in quality. That is a better basis for a decision than either the benchmark table or the tweet, and it is the reason this model is still worth planning around rather than merely worth reading about.
Questions worth actually answering
Is Muse Glimmer truly open source?
It is open weights under Apache 2.0 — anyone can download, modify, fine-tune and deploy it commercially without paying Meta. The report also confirms what the licence actually covers: full-precision weights, two 4-bit variants and the DFlash drafter head are all released. What is not released is the training data and the Muse Spark teacher's weights, which is why "open weights" is the careful phrase rather than fully open source in the OSI sense. For practical purposes the deal is the same one 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 it wins most agentic and search rows, and the methodology appendix now shows which of those rows were Meta's runs and which came from Artificial Analysis or the rivals' own reporting. The independent read is narrower: on AA's Intelligence Index, Qwen3.6-27B scores 21 and Muse Glimmer 17, with Gemma4-31B at 15. So the accurate statement is that Glimmer leads its size class on tool use, multi-step planning and multilingual agentic work, and does not lead it on aggregate general intelligence or on computer-use tasks.
Can I run it on a laptop?
Only if "laptop" means one with a 24GB or 32GB discrete GPU, or a high-end Mac with that much unified memory. The report puts BF16 weights at 55.7GB and targets two compressed profiles: 19.65GB of weights for a 32GB machine and a smaller Q4_K_M build for 24GB, both leaving headroom for the KV cache, the perception encoder and the drafter. On integrated graphics or a 16GB machine you would be looking at heavier quantisation and slow output rather than the always-on agent the release is designed around.
Where do I get it, and is it on an API?
The weights are on Hugging Face at meta-models/Muse-Glimmer-30B, and you run it locally through llama.cpp, MLX, ExecuTorch, Ollama or LM Studio. Hosted access exists through third-party platforms at roughly $0.30 per million input tokens and $1.20 per million output, per Artificial Analysis's tracked provider pricing. Meta publishes no hosted Glimmer endpoint of its own, and the model is not on OrcaRouter — if it lands as a hosted route, the same key that reaches the 200-plus models we do route will reach it, but that is not true today.
