Meta Muse Glimmer 30B: a local-agent model with mixed benchmark results

Research checked on August 12, 2026. Muse Glimmer 30B is Meta’s new dense 29.6B-parameter multimodal model built around a specific constraint: autonomous agents should be able to run on consumer hardware rather than requiring a cloud-only stack. The release uses Apache 2.0, accepts text and images, returns text, exposes a 131,072+ token official context baseline, and ships with quantized checkpoints plus an optional DFlash speculative-decoding drafter. [S01][S04]

The important part is what the model is not. It is not an across-the-board replacement for Qwen3.6-27B or larger frontier systems. Meta’s own evaluation table has Muse ahead on several tool-use and agent benchmarks, but Qwen ahead on others. Independent Artificial Analysis results reinforce that split: Muse is unusually competitive on τ³-Banking tool use, while Qwen leads on its broader Intelligence Index, GDPval-AA v2, Terminal-Bench, and hallucination rate. [S01][S03][S13]

Quick specification

Item	Muse Glimmer 30B	Why it matters
Parameters	~29.6B	Dense model, not MoE
Vision encoder	~1.8B ViT-G/14	Image + text input
Official context	131,072+ tokens	Long agent traces, but memory still scales with context
Decoder	52 layers, hidden size 6656	Hybrid local/global attention
Attention pattern	local, local, local, global	2,048-token sliding window on local layers
Q/KV heads	32 / 2	16:1 GQA reduces KV-cache pressure
License	Apache 2.0	Permissive model artifact license; trademark rights remain separate
Meta hardware targets	64 GB full precision / 32 GB dynamic quant / 24 GB 17GB quant	Official deployment envelopes, not universal runtime guarantees
Modalities	text + image → text	Vision understanding, no native image generation
Reasoning strength	low / medium / high / xhigh	Meta recommends high or xhigh for difficult coding/agent tasks
Knowledge cutoff	January 4, 2026	Current information still needs tools or retrieval

Sources: Meta model card and Hugging Face’s release engineering article. [S01][S04]

Why Muse Glimmer is different from a generic 30B chat model

Meta describes Muse Glimmer as a distillation of Muse Spark with training focused on end-to-end agent completion, schema-based tool calling, multi-step reasoning, failure recovery, multimodal input and scaffold compatibility. The model card explicitly names OpenClaw and Hermes Agent among supported orchestration patterns. [S01]

That positioning is backed by unusually broad release-day runtime work. Hugging Face documented day-zero support across Transformers, llama.cpp and vLLM; Ollama exposes a direct model command and an Apple-Silicon MLX path with DFlash and images; ExecuTorch provides prebuilt exports for Apple and NVIDIA targets. [S04][S08][S09]

For local-agent builders, that software availability matters almost as much as a benchmark score. A model that is theoretically strong but fragile in tool-call parsing, vision preprocessing or serving can lose much of its advantage once placed inside an agent loop.

The architecture is designed to make long local sessions less painful

Muse Glimmer alternates three 2,048-token sliding-window attention layers with one global layer, repeating the pattern across 52 decoder layers. It also uses only two KV heads for 32 query heads. Hugging Face describes this as 16:1 grouped-query attention, a configuration that substantially reduces KV-cache storage versus conventional attention. [S01][S04][S16]

That design choice is important for agent workloads. Long conversations, tool traces and retrieved documents do not only consume prompt tokens; they expand the KV cache. Lower cache cost gives a local model more room for long sessions before memory pressure becomes the bottleneck. It does not mean every 24 GB machine can run the full 131K context together with vision and DFlash. Those components still compete for the same physical memory.

The vision path is a separate ~1.8B-parameter Perception Encoder derived from Meta’s perception-model work. It enables screenshot, chart and document interpretation alongside text prompts. [S01][S28][S29]

Memory: 24 GB is the official target, not a promise of unlimited context

Meta publishes three deployment targets. Full precision targets 64 GB VRAM. K-Quant-Dynamic targets 32 GB. K-Quant-17GB targets 24 GB. Meta reports average benchmark degradation of roughly 0.2% and 1.0% for the two quantized variants across 15 benchmarks. That number should be read as a vendor aggregate, not proof that every downstream task loses exactly the same amount. [S01]

24 GB

This is the smallest official target tier. It makes a 30B multimodal agent plausible on a single high-end GPU or unified-memory machine. The caveat is headroom: long contexts, the perception encoder and DFlash add memory pressure beyond the core quantized language-model weights.

32 GB

This is the safer local tier. Meta’s dynamic quant target fits here, and there is more space for context and multimodal components. AMD also recommends greater-than-32-GB VRAM or variable graphics memory for an easy LM Studio path on its supported hardware. [S06][S11]

64 GB+

This tier is relevant if you want the full-precision checkpoint or large context reserves. vLLM’s DGX Spark example describes BF16 weights at roughly 55 GiB before the rest of the serving stack. [S05]

What about 16 GB Macs?

A hands-on Medium report used a custom 12.5 GB quantization including the vision tower on a 16 GB Mac mini. The author measured roughly 3.5 tokens per second and described a practical prompt comfort ceiling around 2,000 tokens on that setup. This is useful evidence that 16 GB is technically possible with aggressive custom compression, but it is outside Meta’s official target and not evidence that a 16 GB Mac is a good long-context agent machine. [S37]

DFlash is the performance feature to watch

Muse Glimmer ships with an optional DFlash drafter. It proposes 16-token blocks and lets the target model verify those proposals in parallel. The research mechanism comes from block-diffusion speculative decoding; the practical benefit depends on acceptance rate, workload, quantization and runtime. [S01][S26][S27]

Meta measured the 17GB quant plus quantized DFlash at batch size 1 with greedy decoding:

Device	Baseline	With DFlash	Speed-up
RTX 5090	74.9 tok/s	233.4 tok/s	~3.1×
Apple M4 Max	23.7 tok/s	37.8 tok/s	~1.6×
Apple M5 Max	26.6 tok/s	50.2 tok/s	~1.9×

The speed-up factors are computed from the two measurement columns and rounded to one decimal place. These are Meta measurements, not a universal speed ranking. AMD separately reports preliminary Windows llama.cpp/Vulkan results of up to 24 tok/s on Ryzen AI Max+ 395 and 53 tok/s on Radeon AI PRO R9700 with DFlash. Different hardware and test conditions mean the two tables should not be merged into one leaderboard. [S01][S06]

The benchmark story: strong agent skills, mixed overall dominance

Meta reports Muse Glimmer ahead of Qwen3.6-27B on MCP Atlas (75.5 vs 62.5), DeepSearch QA (74.6 vs 71.1), WildClawBench (47.6 vs 43.2) and SWE-Bench Pro (51.2 vs 50.2). The same Meta table has Qwen ahead on GDPVal-AA v2 (1141 vs 953), OSWorld-Verified (75.6 vs 65.9), SkillsBench (46.6 vs 44.3) and Terminal-Bench 2.1 (60.7 vs 51.7). [S01]

Meta’s methodology document is essential context. It says third-party agent models were run on a best-effort basis under the same framework, but the tools and system prompts may not be optimized for those competitors. Some comparison values also come from different evaluation sources. The table helps with orientation, but it is not a neutral, single-lab, perfectly tuned apples-to-apples tournament. [S03]

Artificial Analysis provides a useful independent check. Its August 2026 analysis places Muse slightly behind Qwen3.6-27B on the broader Intelligence Index. It reports GDPval-AA v2 at 953 for Muse versus 1141 for Qwen and Terminal-Bench at about 52% versus 61%. Muse’s counterexample is τ³-Banking, where it scores around 24% versus Qwen’s 17%. The biggest caution is AA-Omniscience: Artificial Analysis reports an 82% hallucination rate for Muse versus 49% for Qwen, where lower is better. [S13]

The result is not “Meta wins” or “Qwen wins.” It is a workload split:

• Muse is a better fit for tool-heavy local agent loops.
• Qwen remains stronger on several general reasoning, knowledge-work and terminal measurements.
• Coding is mixed: Muse narrowly wins Meta’s SWE-Bench Pro comparison while Qwen leads Terminal-Bench by a wider margin. [S01][S13]
• Retrieval and verification should be mandatory for factual research agents given Muse’s independent hallucination result.

Why WildClawBench matters more than a single coding score

WildClawBench runs 60 hand-built tasks inside real agent environments, covering productivity, coding, search, multimodal work and safety. It also compares multiple harnesses — OpenClaw, Claude Code, Codex and Hermes Agent — on the same task suite. Its current OpenClaw leaderboard lists Muse Glimmer at 47.6% and Qwen3.6-27B at 43.2%, while stronger frontier models remain well above both. [S18]

The deeper lesson is that the harness can materially change the outcome. Local model selection should therefore include the exact orchestration layer you plan to use rather than benchmarking the raw model in isolation.

Local deployment options

Ollama

ollama run muse-glimmer:30b is the shortest path to a local test. Ollama’s Apple-Silicon MLX tag muse-glimmer:30b-mlx adds DFlash and image input. [S08]

# Standard Ollama model
ollama run muse-glimmer:30b

# Apple Silicon: MLX, DFlash and image input
ollama run muse-glimmer:30b-mlx

llama.cpp

Muse Glimmer support landed around release and follow-up commits quickly addressed tool-call behavior. Pin the build or commit in any benchmark report; otherwise a result from August 11 may not reproduce a few days later. [S10]

ExecuTorch and MLX

ExecuTorch publishes prebuilt exports encoded by quantization, context length, modality, solo/DFlash mode and target hardware. Apple targets use MLX; NVIDIA uses CUDA. Vision can be included as an export component. [S09]

vLLM

vLLM supports an OpenAI-compatible server and Muse-specific tool-call and reasoning parsers. Its documented recipe uses a 131,072 maximum model length. This is the most natural path among the documented options for server-style local or LAN inference. [S05]

LM Studio

LM Studio provides the GUI route. AMD notes that its local server can expose OpenAI- or Anthropic-compatible endpoints for agent systems including Hermes Agent and OpenClaw. [S06][S11]

Cloud pricing is provider pricing, not a Meta model price

The open weights have no token fee. Hosted inference does. On August 12, 2026, OpenRouter listed Muse Glimmer at $0.30 per million input tokens and $1.20 per million output tokens. This is a third-party provider listing, not an official Meta API price, and it can change. [S12]

At that rate:

• 1M input + 0.25M output ≈ $0.60
• 10M input + 2M output ≈ $5.40
• 100M input + 20M output ≈ $54.00

Those examples exclude taxes, caching discounts and provider-specific extras.

Local privacy does not remove agent security risk

Running the model locally can keep raw prompts and files off a hosted inference API. But an autonomous agent may still connect to browsers, email, shells, APIs and third-party content. Meta explicitly recommends system-level guardrails and application-specific evaluation rather than treating the base model as a complete safety layer. [S01]

Practical deployments should still enforce least-privilege tools, approval before irreversible actions, secret filtering, prompt-injection boundaries and audit logs.

Muse Glimmer vs Qwen3.6-27B: who should switch?

Choose or test Muse Glimmer first when your main workload is local tool use, multimodal documents/screenshots, long agent loops, or a 24–32 GB offline deployment where DFlash and Apache 2.0 are attractive.

Keep Qwen3.6-27B in the comparison when broader reasoning, terminal-heavy coding, factual robustness, or an already mature Qwen deployment matters more. [S13][S30]

The best decision test is a small private benchmark: same machine, same quantization class, same harness, same tool schemas, and 20–50 tasks sampled from the real workflow. Record success rate, retries, tool-call validity, wall-clock time, peak memory and factual verification failures. That dataset is more decision-useful than another public leaderboard screenshot.

What the evidence supports

The Muse Glimmer 30B release packages a local-agent stack rather than only a language-model checkpoint: multimodal input, low-KV-cache architecture, official 24/32 GB quant targets, DFlash acceleration and broad runtime support are documented together. These features make it suitable for testing in local agent workflows.

Taken together, the sources support a workload-specific conclusion: Muse Glimmer targets local, tool-oriented multimodal agents, while Qwen3.6-27B remains stronger in several independent metrics.