Meta has released a model built less for chatting and more for doing. Muse Glimmer is a 30-billion-parameter open model from Meta Superintelligence Labs, released in August 2026 under the permissive Apache 2.0 license, and purpose-built for autonomous agentic work: multi-step planning, calling tools in sequence, recovering when a step fails, and carrying a task through to completion on consumer hardware rather than in a data center.
It is distilled from Muse Spark, Meta's larger frontier-class model, which means it inherits much of the bigger model's reasoning depth and tool-use reliability in a compressed form that fits on a single GPU. The technical report followed in October 2026, with full weights published on Hugging Face. What follows is a detailed look at what Glimmer can actually do, where its numbers lead its rivals, and where they do not.
What "agentic" means for Glimmer
Most open models aimed at consumer hardware are general-purpose chat systems. Glimmer is specialized differently. Its design brief is the agent loop: reason over a long horizon, invoke tools with precise schemas, read the results (including screenshots, charts and documents), remember earlier steps, and keep going when something breaks. Meta's own framing lists four core behaviors: multi-step planning, sequential tool invocation, failure recovery, and long-horizon task execution.
In practice, that points at workloads like these:
- Tool-using assistants that work through software APIs and MCP-style tool servers, chaining calls rather than answering in one shot.
- Coding agents that write, run, debug and fix code across several steps.
- Document and screen work — reading charts, documents and interface screenshots and acting on what they show.
- Personal agents that stay private, because the model can run locally instead of sending everything to a cloud API.
- Multilingual agents, with training data across roughly 140 languages and demonstrated multilingual agentic ability.
Why Meta built it this way
The technical report opens with a gap Meta clearly wanted to close. On one side sit proprietary cloud systems that can reason, plan and use tools reliably. On the other sit publicly available models small enough for consumer hardware — but those, Meta argues, are mostly trained as general-purpose systems and lack the specialization reliable autonomous behavior needs: sustained multi-step reasoning, robust tool invocation, and principled handling of private user context. Glimmer is Meta's attempt to put the agent half of the equation into the small open half of the market.
The method was distillation, not training from scratch at small scale. Meta took Muse Spark, its frontier-class model, and compressed its reasoning depth and tool-use reliability into a 30-billion-parameter form. The report also describes an architecture search under a fixed memory ceiling: dense designs proved roughly twice as compute-efficient as mixture-of-experts variants at the same footprint, which is why the final model is dense rather than MoE.
Tool use in detail
Tool use is where Glimmer makes its strongest claim, and it is worth understanding what the headline benchmark actually measures. MCP Atlas tests multi-step tool-call orchestration against tool schemas — in plain terms, whether a model can pick the right tool, fill in its arguments correctly, read what comes back, and choose the next call, over and over, without drifting off schema or losing the thread. Glimmer scores 75.5 there, against 54.2 for Gemma4-31B and 62.5 for Qwen3.6-27B. That 13-point margin over its nearest rival is the widest gap anywhere in Meta's comparison, and it is the number the whole launch pitch rests on.
The supporting agent benchmarks point the same way. On GAIA2, a suite of general agent tasks, Glimmer scores 43.3 against 36.4 and 40.0. On WildClawBench it scores 47.6 against 37.6 and 43.2. On the banking workflow suite Tau-Bench it scores 23.5 against 15.1 and 16.7. And on DeepSearchQA, which tests agentic search — finding, checking and synthesizing information across sources — it scores 74.6 against 61.7 and 71.1. Read together, these say Glimmer is unusually reliable at the bounded, schema-driven part of agent work: call the right tool, with the right arguments, in the right order.
Coding ability
On coding, the picture is more mixed, and the two SWE-Bench numbers tell different stories. SWE-Bench Verified measures a model's ability to fix real issues from open-source repositories, and Glimmer scores 76.0 there — strong, but just behind Qwen3.6-27B at 77.2 and well ahead of Gemma4-31B at 66.6. SWE-Bench Pro, a harder coding set, is where Glimmer leads: 51.2 against 36.9 for Gemma and 50.2 for Qwen. On SciCode, a scientific coding benchmark, the three are nearly tied at 43.6, 43.4 and 39.8.
The practical reading is that Glimmer is a capable coding agent for its size, leading on the harder Pro set, but it is not the outright coding leader of its class — Qwen edges it on the standard Verified set. For a developer choosing a local coding agent, that distinction matters more than any single headline number.
Seeing the screen
Glimmer's multimodal side is built around a dedicated perception encoder, a roughly 1.8-billion-parameter vision transformer that processes images at native resolution on a 448-pixel reference grid. After downsampling, a 448 by 448 image becomes 256 visual tokens, and higher-resolution images scale up to a maximum of 4,096 tokens per image. The model accepts interleaved text and image input and produces text output, which covers multi-image contexts such as comparing screenshots or reading a document page by page.
The multimodal scores are solid without leading the class. On Screenspot Pro, which tests grounding interface elements on screens, Glimmer scores 75.4 against 75.9 for Gemma and 76.1 for Qwen — a near tie. On OmniDocBench, a document understanding suite, it scores 75.8 against 72.5 and 77.8. On CharXiv chart reasoning it scores 78.8 against 77.7 and 78.4, a narrow lead. On MMMU-Pro, a broad multimodal knowledge test, it scores 74 against 73 and 75. In short, it sees screens, documents and charts about as well as its rivals, sometimes a little better, sometimes a little worse — competent, not dominant.
One limitation is stated plainly in the report: while Glimmer can ingest video as a sequence of frames, it is not explicitly optimized for video. Image and multi-image understanding is the focus, so anyone expecting native video comprehension should look elsewhere.
Memory across long jobs
Long agent sessions live or die on memory, and this is where Glimmer's architecture choices pay off. Two design decisions bound the key-value cache that normally balloons during multi-step execution: sliding-window attention, which limits how far back each layer looks, and grouped-query attention with only 2 key-value heads per layer, which shrinks what must be stored per token. The attention pattern repeats three local sliding-window layers followed by one global layer, preserving long-range information flow while keeping cache growth under control.
The long-context scores reflect that design. On Beam 128K, a long-context benchmark, Glimmer scores 65.1 against 58.2 for Gemma and 63.0 for Qwen. On AA-LCR, a long-context recall test, it scores 80.0 against 68.3 and 73.3 — its clearest memory win. Combined with a 128K-plus token context window, that makes Glimmer well suited to jobs where the agent must hold a long task history, a large document, or many tool results in mind at once.
Speaking 140 languages
Multilingual ability is one of Glimmer's quieter strengths. The model was trained on data from roughly 140 languages, and on Omnilingual Gaia2 — agentic tasks posed across languages — it scores 60.4, far ahead of Gemma's 37.5 and Qwen's 45.0. On Linguini, a multilingual reasoning test, it scores 8.8 against 3.8 and 2.5. For builders serving users outside English, that multilingual agent gap may matter more than any English-language benchmark, since it means the same local agent can plausibly work across many languages without switching models.
Inside the model
Glimmer is a dense causal transformer, not a mixture-of-experts design. A dedicated perception encoder handles images, and the model accepts interleaved text and image input and produces text output.
| Spec | Muse Glimmer 30B |
|---|---|
| Total parameters | About 29.6B (25.16B language model, 1.8B perception encoder, plus embeddings) |
| Architecture | Dense transformer, 52 layers, grouped-query attention (32 query heads, 2 key-value heads) |
| Attention pattern | Three sliding-window local layers followed by one global layer, repeating |
| Sliding window | 2,048 tokens; rotary position embeddings on local layers only |
| Context length | 128K+ tokens |
| Input / output | Text and images in, text out |
| Languages | About 140 |
| License | Apache 2.0 — full-precision weights, 4-bit weights and a speculative-decoding head |
| Distilled from | Muse Spark, Meta's frontier-class model |
Two engineering choices matter for agent work specifically. The sliding-window attention and grouped-query attention bound the growth of the key-value cache, which is what normally balloons during long multi-step sessions. And the model ships with a DFlash speculative-decoding head: Meta-reported figures put generation at about 3.1 times faster on an RTX 5090 with DFlash enabled (74.9 to 233.4 tokens per second), about 1.8 times on an Apple M5 Max and 1.5 times on an M4 Max. NVIDIA separately reports over 20 tokens per second per GPU at BF16 precision on its Blackwell Ultra hardware.
The benchmarks, read honestly
Meta's own scorecard compares Glimmer at high reasoning strength against the two open models closest to its size, Google's Gemma4-31B and Alibaba's Qwen3.6-27B. All figures below are Meta-reported, not independently verified, and the honest reading is that Glimmer wins the agent tests but not everything.
Benchmarks where Glimmer leads
Scores out of 100. Glimmer's widest lead is tool use: MCP Atlas 75.5 against Qwen's 62.5 and Gemma's 54.2.
Benchmarks where a rival leads
Scores out of 100. Qwen3.6-27B leads the desktop and terminal sessions, SkillsBench, ScreenSpot Pro, OmniDocBench and MMMU Pro; Gemma4-31B leads GPQA Diamond and HLE Text. GDPVal-AA is not charted because it uses an index scale, not 0–100 — see the table.
| Benchmark | Muse Glimmer | Gemma4-31B | Qwen3.6-27B |
|---|---|---|---|
| MCP Atlas (tool use) | 75.5 | 54.2 | 62.5 |
| DeepSearch QA (agentic search) | 74.6 | 61.7 | 71.1 |
| GAIA2 (general agent tasks) | 43.3 | 36.4 | 40.0 |
| WildClawBench (agentic) | 47.6 | 37.6 | 43.2 |
| Tau-Bench Banking | 23.5 | 15.1 | 16.7 |
| GDPVal-AA v2 (index score, not out of 100) | 953 | 811 | 1141 |
| SWE-Bench Pro (coding) | 51.2 | 36.9 | 50.2 |
| SWE-Bench Verified (coding) | 76.0 | 66.6 | 77.2 |
| OSWorld-Verified (computer use) | 65.9 | 58.5 | 75.6 |
| TerminalBench 2.1 (terminal tasks) | 51.7 | 43.4 | 60.7 |
| SciCode | 43.6 | 43.4 | 39.8 |
| CharXiv Reasoning | 78.8 | 77.7 | 78.4 |
| ScreenSpot Pro | 75.4 | 75.9 | 76.1 |
| OmniDocBench v1.5 | 75.8 | 72.5 | 77.8 |
| MMMU Pro | 74 | 73 | 75 |
| AIME 2026 (reasoning) | 94.7 | 89.2 | 94.1 |
| GPQA Diamond (knowledge) | 83.5 | 85.7 | 84.2 |
| Instruction following (IFBench) | 77.0 | 76.0 | 70.8 |
| SkillsBench | 44.3 | 32.4 | 46.6 |
| AA-LCR (long-context recall) | 80.0 | 68.3 | 73.3 |
| Beam128K (long context) | 65.1 | 58.2 | 63.0 |
| HLE Text | 22.0 | 23.6 | 23.1 |
The pattern is clear. On bounded tool-calling and agentic search, Glimmer leads its size class by a wide margin — the MCP Atlas gap of 13 points over its nearest rival is the largest in the whole comparison. On reasoning it is also strong, with 94.7 on AIME 2026 ahead of both rivals. But on sustained sessions inside a real desktop or terminal, where an agent must keep state and recover from its own mistakes across dozens of steps, Qwen3.6-27B leads instead — OSWorld-Verified 75.6 against Glimmer's 65.9, and TerminalBench 2.1 at 60.7 against 51.7. And on GDPval-AA, an agentic value benchmark, Qwen leads at 1141 against Glimmer's 953. So Glimmer looks sharpest for a well-scoped task with a clear success condition, and less proven for the longest, messiest jobs.
There is also a safety number worth noting. On Siren AgentDojo, which measures how often a model falls for a prompt injection hidden in tool output rather than in the user's own instructions, Glimmer's attack success rate is 28.4 percent — better than Qwen's 40.3 but behind Gemma's 25.6, with utility at 94.2. On CI Memories, which tests handling of private context, its violation rate is 26.4 percent against Gemma's 12.1 and Qwen's 53.4. In other words, it is usable but not immune to injected instructions, which matters for any agent allowed to act on its own.
System requirements
Glimmer's headline promise is that it runs on consumer hardware, but "consumer" here has a specific meaning, and it is set by one number: memory. Meta designed the model around a 32GB VRAM envelope — the practical ceiling for high-end consumer graphics cards — and the report states the target form factor as devices with 32GB of dedicated memory available. Everything else in the design, from the dense architecture to the 4-bit quantization, serves that envelope.
That gives three practical tiers:
- Full-precision inference needs datacenter-class memory. Reports put full inference on a single 80GB H100, which is far beyond a desktop card — this is the route for researchers and labs, not home PCs.
- 4-bit quantized inference is the consumer route. Meta releases 4-bit weights specifically for single-GPU inference, reported to fit in around 24GB of VRAM. A high-end consumer card in that class can run the model locally, fully offline, with no cloud calls.
- Below the bar means API access instead. Cards with 10–12GB of VRAM, such as an RTX 3080, cannot hold even the 4-bit build locally. For those machines the practical path is calling Glimmer through an API provider, listed at around $0.30 per million input tokens and $1.10–$1.50 per million output tokens depending on provider.
Meta publishes the tradeoff explicitly. Measured as an average across 15 common benchmarks:
| Weights | Target hardware | Quality loss |
|---|---|---|
| Full precision | 64GB VRAM | — |
| K-Quant-Dynamic | 32GB VRAM | 0.2% |
| K-Quant-17GB | 24GB VRAM | 1.0% |
At approximately 4-bit precision the language model itself shrinks to under 20GB, leaving headroom for the KV cache, the perception encoder and the speculative-decoding drafter within the 24GB or 32GB envelope.
Two more requirements matter for real agent sessions. First, the context window runs past 128K tokens, and long sessions grow a large key-value cache; Glimmer's sliding-window attention and grouped-query attention are designed to bound that growth, but long-horizon jobs still need headroom beyond the bare weight footprint. Second, software support is ready on day one: the weights ship for Transformers, llama.cpp and vLLM, with quantized GGUF builds for consumer hardware, and Meta's DFlash speculative-decoding head for faster generation — Meta-reported figures show about 3.1 times faster generation on an RTX 5090 with DFlash, and the same head measured on Apple M4 Max and M5 Max machines, so high-end Apple Silicon runs it too.
What Meta does not publish in the report is a full desktop specification — there is no stated CPU, system-RAM or disk figure, only the dedicated-memory envelope. The honest summary is therefore simple: if the machine has around 24GB or more of GPU memory available, Glimmer runs locally; if it does not, the API route is the way to use it. No cloud account, subscription or datacenter is required in either case beyond the provider chosen.
Running it yourself
The weights are published on Hugging Face under meta-models/Muse-Glimmer-30B, with day-one support reported in Transformers, llama.cpp and vLLM. Meta designed the model around a 32GB VRAM envelope for consumer hardware, and the 4-bit quantized weights are reported to fit in around 24GB — so a high-end consumer card can run it, but a mid-range card with 10–12GB cannot hold it locally. For those machines, the practical route is API access: providers list it at around $0.30 per million input tokens and $1.10–$1.50 per million output tokens, varying by provider.
The Apache 2.0 license is the other half of the story. It covers commercial use, fine-tuning and redistribution, which is why Glimmer matters beyond benchmarks: a developer can build a private, local agent product on it without a cloud dependency or a license negotiation. The release includes full-precision weights, 4-bit quantized weights and the DFlash speculation head, so the community can deploy, fine-tune and extend the model rather than merely run it.
Who should use it, and who should not
Glimmer fits best for builders who want a local, private agent with strong tool use: a coding assistant that runs on one machine, a document-processing agent that never sends files to a cloud, a multilingual support agent, or a research agent that chains searches and tool calls. Its combination of tool reliability, long-context memory and quantization quality is exactly tuned for those jobs.
It fits less well for two kinds of work. First, pure coding at the frontier, where Qwen3.6-27B edges it on the standard Verified set and larger coder models lead further. Second, long desktop-automation sessions, where its OSWorld and TerminalBench numbers trail. And it fits nobody out of the box: it is a model, not a finished assistant, so the browser, the logins, the memory and the scheduling all have to be built around it first.
What it does not do
Glimmer is a model, not a finished assistant. Out of the box it has no browser, no logins, no memory across days, no scheduling and no accounts — all of that has to be built around it in an agent harness before it does anything in the real world. It is also not the frontier: it is distilled from Muse Spark, so it is the smaller local cousin of Meta's biggest model, not something above it. And its video handling is frame-by-frame ingestion rather than native video understanding.
Even so, the release marks a shift. The best small open model for agent work no longer has to live in a data center, and the gap between a capable local agent and a cloud agent just got much smaller. The next step to watch is the ecosystem: fine-tunes, agent frameworks and local deployments built on Glimmer will show whether its benchmark lead in tool use survives contact with real, messy workflows.
Frequently asked questions
Is Muse Glimmer free to use?
The weights are released under Apache 2.0, which permits free use including commercial use, fine-tuning and redistribution. Running it yourself costs whatever hardware or API usage you choose; the model itself carries no license fee.
Can it run on an ordinary PC?
It is designed for a single consumer GPU, with 4-bit weights reported to fit in around 24GB of VRAM. A high-end consumer card can run it locally; a card with 10–12GB cannot, and would need API access instead.
Is it better than Muse Spark?
No. Glimmer is distilled from Muse Spark, Meta's larger frontier model, into a smaller form that runs locally. It trades some capability for size, openness and local execution.
How is it different from Gemma and Qwen?
All three are open models in the 27–31B range, but Glimmer is specialized for agent work: it leads on tool use (MCP Atlas 75.5), agentic search and multilingual agent tasks, while Qwen leads on desktop and terminal sessions and Gemma leads on some knowledge and safety measures. The right choice depends on the workload.
Can it work as a fully autonomous agent on its own?
Not alone. It needs an agent harness that gives it tools, a browser or terminal, memory and permission rules. Its benchmarks show strong tool use within such a harness, but also a real susceptibility to prompt injection in tool output, so unsupervised action on sensitive systems would be unwise.
Be the first to share a useful question or thought.