This site does not allow itself to be embedded. You can still read it on the original site — the toolbar below keeps your place in the directory.
Meta open-sourced Muse Glimmer, a 30B Apache 2.0 multimodal agent model that runs in a 24GB envelope at up to 233 tok/s. MCP Atlas 75.5, SWE-Bench Verified 76.0, 131K context. Here is what the numbers actually say.
Meta shipped its first open-weight model built specifically for always-on local agent work on August 10, 2026. Muse Glimmer is a 30B dense multimodal model released under Apache 2.0, distilled from the much larger Muse Spark family, and tuned for the things agents actually do: calling tools, recovering from failures, reading screenshots, and holding 131K-token contexts. Quantized to about 17GB it runs inside a 24GB VRAM envelope, and with Meta's DFlash speculative decoding it hits 233.4 tokens per second on an RTX 5090. A local model that is agent-first rather than chat-first, at that size and price, is new for this class.
## Official Sources
| Resource | Description |
|----------|-------------|
| [Meta AI Research announcement](https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model) | The release post: training recipe, local optimizations, ecosystem plans |
| [Hugging Face model card](https://huggingface.co/meta-models/Muse-Glimmer-30B) | Full architecture, benchmark table, quantization data, safety evaluation |
| [Evaluation methodology report](https://research.meta.ai/static/muse-glimmer-methodology) | Sampling configs, benchmark definitions, comparison rules |
| [Meta AI Developer Center](https://developer.meta.com/ai/models/muse-glimmer/) | Developer docs and scaffold setup guidance |
| [DFlash paper (arXiv 2602.06036)](https://arxiv.org/abs/2602.06036) | The block-diffusion speculative decoding method Glimmer ships with |
## What Actually Shipped
Muse Glimmer is a 29.6B-parameter dense causal transformer with a dedicated ViT-G/14 perception encoder (~1.8B parameters), giving it interleaved text and image input: screenshots, charts, and documents alongside conversation. The 52-layer model uses a repeating local-local-local-global attention pattern, GQA at a 16:1 ratio, and a 131,072+ token context window. Knowledge cutoff is January 4, 2026.
The training story matters as much as the architecture. Glimmer was distilled from Muse Spark with logit distillation, pushed through agent-heavy mid-training with longer reasoning traces, then post-trained with SFT, on-policy distillation, and reinforcement learning across general, reasoning, coding, and agentic domains. The result is a benchmark profile that is agent-shaped: tool orchestration, full-task completion, and failure recovery ahead of its size class.
Three details from the model card are worth calling out:
- **Reasoning strength is controllable.** The model supports `low / medium / high / xhigh` reasoning strengths set through the system prompt, so you can trade think time for latency per workload.
- **Failure recovery is a first-class capability.** The model is trained to diagnose a failed tool call and retry rather than halt, which is where local agents tend to die.
- **Scaffold compatibility is explicit.** Meta lists OpenClaw and Hermes Agent as working orchestration patterns, alongside OpenRouter, Together, and Fireworks serving partners.
## The Benchmarks
All numbers below come from the official Hugging Face model card, which compares Glimmer in high-reasoning mode against Gemma4-31B and Qwen3.6-27B, both in thinking mode. Meta's methodology states that for other models it reports the most favorable result between self-reported scores and internal reproductions, so this is a conservative-to-flattering baseline; read the wins as directional until independent runs land.
Chart: Meta AI Research (via the [Muse Glimmer announcement](https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model))
| Category | Benchmark | Glimmer-30B | Gemma4-31B | Qwen3.6-27B |
|----------|-----------|-------------|------------|-------------|
| General agentic | MCP Atlas (Public) | **75.5** | 54.2 | 62.5 |
| General agentic | DeepSearch QA | **74.6** | 61.7 | 71.1 |
| General agentic | tau3-Banking | **23.5** | 15.1 | 16.7 |
| General agentic | WildClawBench | **47.6** | 37.6 | 43.2 |
| General agentic | GAIA2 | **43.3** | 36.4 | 40.0 |
| General agentic | OSWorld-Verified | 65.9 | 58.5 | **75.6** |
| Agentic coding | SWE-Bench Pro | **51.2** | 36.9 | 50.2 |
| Agentic coding | SWE-Bench Verified | 76.0 | 66.6 | **77.2** |
| Agentic coding | TerminalBench 2.1 | 51.7 | 43.4 | **60.7** |
| Agentic coding | SciCode | **43.6** | 43.4 | 39.8 |
| Reasoning | AIME 2026 | **94.7** | 89.2 | 94.1 |
| Reasoning | GPQA Diamond | 83.5 | **85.7** | 84.2 |
| Reasoning | AA-LCR | **80.0** | 68.3 | 73.3 |
| Long context | Beam128K | **65.1** | 58.2 | 63.0 |
| Instruction following | IFBench | **77.0** | 76.0 | 70.8 |
The pattern is clear: Glimmer wins where tools and long-horizon orchestration are measured (MCP Atlas, DeepSearch QA, SWE-Bench Pro, WildClawBench) and on reasoning (AIME 2026, AA-LCR), while Qwen3.6-27B keeps the lead on GUI/OS tasks (OSWorld-Verified 75.6 vs 65.9) and terminal coding (TerminalBench 2.1 at 60.7 vs 51.7). The MCP Atlas gap is the biggest single number: 75.5 against 62.5 for Qwen, 54.2 for Gemma. For anyone building local agents on Model Context Protocol servers, that is the metric that matters. One honest caveat: the comparison target is Qwen3.6, which is four months old, and a Qwen3.8-27B is expected this week.
## The Hardware Reality
This is where Meta did the work that makes the release meaningful. At full precision the model needs over 55GB, which rules out consumer hardware. Meta ships two official 4-bit quantizations and publishes the degradation numbers for both:
| Variant | Target hardware | Degradation (avg across 15 benchmarks) |
|---------|----------------|----------------------------------------|
| Full precision (BF16) | 64GB VRAM | - |
| K-Quant-Dynamic | 32GB VRAM | 0.2% |
| K-Quant-17GB | 24GB VRAM | 1.0% |
Chart: Meta AI Research (via the [Muse Glimmer announcement](https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model))
The K-Quant-17GB model fits the language model under 20GB at roughly 4-bit precision, leaving room for the KV cache, the perception encoder, and the drafter inside a 24GB or 32GB envelope. Speed is addressed the same way: Glimmer ships with a DFlash block-diffusion drafter that proposes 16-token blocks in one forward pass and lets the main model verify them in parallel.
Chart: Meta AI Research (via the [Muse Glimmer announcement](https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model))
| GPU | No speculation | With DFlash drafter | Speedup |
|-----|----------------|---------------------|---------|
| Nvidia RTX 5090 | 74.9 tok/s | 233.4 tok/s | 3.1x |
| Apple M5 Max | 26.6 tok/s | 50.2 tok/s | 1.8x |
| Apple M4 Max | 23.7 tok/s | 37.8 tok/s | 1.5x |
Mac measurements used ExecuTorch, the RTX run used llama.cpp, batch size 1 with greedy decoding. The 24GB class was previously the province of models that either decoded slowly or could not hold an agentic context; Glimmer claims both problems are addressed in one release.
## How to Run It
As of August 10, 2026, Muse Glimmer is **not available in OpenCode's model catalog** (checked `opencode models --verbose` - no Muse entry). The model is open weights, so the fast path is the vendor ecosystem instead:
```bash
pip install vllm
vllm serve "meta-models/Muse-Glimmer-30B"
```
Or with Transformers directly:
```python
from transformers import AutoProcessor, AutoModelForMultimodalLM
processor = AutoProcessor.from_pretrained("meta-models/Muse-Glimmer-30B")
model = AutoModelForMultimodalLM.from_pretrained("meta-models/Muse-Glimmer-30B", device_map="auto")
```
For local apps, the model card already lists 7 community quantizations and the official announcement says llama.cpp, MLX, ExecuTorch, Ollama, LM Studio, and Unsloth integrations land in the coming days. If you run on a 5090 or a 32GB Mac, this is the first strong open-weight option for a genuinely local agent loop: tools, screenshots, long context, all offline. If your machine is a 16GB laptop or a DDR5 mini-box, the dense architecture means you are memory-bandwidth bound and an MoE model in the same class will decode faster.
## What Developers Are Saying
The dominant reaction is relief that Meta is shipping open weights again, and praise for how much work went into the local story rather than just the model. There is real excitement about the tool-calling numbers, with the MCP Atlas result read as the headline: local agents that can drive MCP servers competently are the missing piece for self-hosted setups.
The main skepticism centers on benchmark selection: Glimmer is compared against a four-month-old Qwen3.6-27B right before Qwen3.8-27B ships, which several commenters read as deliberate timing, and the wins beyond tool calling are close. The dense-vs-MoE debate is loud too. A dense 30B is bandwidth-bound on anything without fast VRAM, so commenters estimate single-digit-to-15 tok/s on DDR5 machines, versus the 233 tok/s Meta publishes for the 5090 with the drafter.
The memory question dominates the practical talk. 24GB VRAM is still not what most laptops have, and 32-64GB Macs are expensive; a recurring calculation is whether a 4,000 euro machine beats a few hundred dollars of API tokens over a couple of years. The counterpoint lands just as often: the point of local is not price, it is that nothing leaves the machine, there are no rate limits, and context can include your own private history. There is also the usual open-weights-versus-open-source terminology debate, with the nuance that Apache 2.0 allows modification and redistribution even if training source is not published.
## Why It Matters
Three reasons this release is more than another benchmark post.
**The 27-30B class just became the agent battleground.** DeepSeek V4 Flash already runs locally on a 4090 with enough system RAM, which we covered in our [DeepSeek V4 Flash 0731 guide](/blog/deepseek-v4-flash-0731-opencode-guide). Now Meta enters the same class tuned for tool orchestration, and a Qwen3.8-27B lands this week. Three serious open-weight local agent models in one week of news means the local tier finally has real choices.
**Agent-first training is now separable from frontier size.** The old assumption was that tool use and failure recovery required frontier-scale models. Glimmer's MCP Atlas and SWE-Bench Pro numbers put that capability in a 24GB envelope at 1.0% quantization cost. For self-hosted setups, sandboxed agent deployments (see our [agent sandbox architecture guide](/blog/agent-sandbox-architecture-guide)), and anything privacy-constrained, that is a material change.
**The honest hardware tables are the actual product.** Meta published quantization degradation (0.2% at 32GB, 1.0% at 24GB) and real measured decode speeds instead of marketing numbers. That lets developers decide: if you have a 5090 or 32GB Mac, Glimmer is likely your best local agent today; if you are on DDR5, an MoE rival serves you better. We built the GPU-routing case for this in our [ZLuda guide for running CUDA models on AMD GPUs](/blog/zluda-6-cuda-amd-gpus).
This is Meta's strongest open-weights release since the Llama 3 era, and the first aimed at running agents, not chatbots, on your own hardware. The tool-calling edge is real and the ecosystem integrations are coming this week. Watch the Qwen3.8-27B numbers when they land - the next round of this comparison will be much closer.
## FAQ
### Is Muse Glimmer free to use?
The weights are open under Apache 2.0 and free to download from Hugging Face. You pay only for the hardware and electricity to run it; there is no per-token pricing because Meta ships no hosted offering.
### Can I run Muse Glimmer on my laptop?
It depends. The K-Quant-17GB variant targets 24GB VRAM with about 1.0% average degradation; K-Quant-Dynamic targets 32GB. Macs with 32GB+ unified memory can run it via MLX or ExecuTorch (37.8 tok/s on M4 Max, 50.2 on M5 Max, both with the drafter).
### How fast is Muse Glimmer?
With the DFlash drafter, Meta measures 233.4 tok/s on an RTX 5090, 50.2 tok/s on an M5 Max, and 37.8 tok/s on an M4 Max; 74.9 tok/s on the 5090 without it. Decode speed is memory-bandwidth bound on non-HBM machines.
### Is Muse Glimmer available in OpenCode?
Not yet. As of August 10, 2026 there is no Muse entry in the OpenCode model catalog. Use `vllm serve "meta-models/Muse-Glimmer-30B"` or wait for the llama.cpp, Ollama, and MLX integrations Meta announced for the coming days.
### How does Muse Glimmer compare to Qwen3.6-27B?
Glimmer leads on tool orchestration (MCP Atlas 75.5 vs 62.5), DeepSearch QA (74.6 vs 71.1), SWE-Bench Pro (51.2 vs 50.2), and AIME 2026 (94.7 vs 94.1). Qwen3.6 leads on OSWorld-Verified (75.6 vs 65.9), TerminalBench 2.1 (60.7 vs 51.7), and SWE-Bench Verified (77.2 vs 76.0). The comparison is against the four-month-old Qwen3.6; Qwen3.8-27B is expected this week.
## Sources
| Source | URL |
|--------|-----|
| Meta AI Research announcement | https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model |
| Hugging Face model card: meta-models/Muse-Glimmer-30B | https://huggingface.co/meta-models/Muse-Glimmer-30B |
| Evaluation methodology report | https://research.meta.ai/static/muse-glimmer-methodology |
| Meta AI Developer Center | https://developer.meta.com/ai/models/muse-glimmer/ |
| DFlash paper | https://arxiv.org/abs/2602.06036 |
**Last updated:** August 10, 2026
## Continue Reading
- [Meta Ships Muse Code and Muse Spark 1.2](/blog/meta-muse-code-spark-1-2-release) - the closed-weight sibling Glimmer is distilled from, and where its teacher's capabilities come from
- [DeepSeek V4 Flash 0731: Release, Benchmarks, OpenCode Setup](/blog/deepseek-v4-flash-0731-opencode-guide) - the local-first competitor in the same class, runnable on a 4090
- [What Is MCP? The Model Context Protocol Primer](/blog/what-is-mcp) - the protocol behind the MCP Atlas benchmark Glimmer wins
- [Agent Sandbox Architecture: Choosing the Right Runtime Boundary](/blog/agent-sandbox-architecture-guide) - how to deploy a local agent model safely once it runs on your machine
- [Running CUDA Models on AMD GPUs with ZLuda](/blog/zluda-6-cuda-amd-gpus) - hardware routing options when your GPU is not an Nvidia cardRead on developersdigest.tech ↗
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.