Muse Glimmer

Muse Glimmer

Quick answer: Muse Glimmer is Meta Superintelligence Labs' 30-billion-parameter (29.6B including its vision encoder) open-weight agentic model, distilled from Muse Spark and purpose-built to run entirely on a single consumer GPU or Mac. It has a 131,072-token context window, Apache 2.0 licensing, and ships with 4-bit quantized builds plus a DFlash speculative-decoding drafter that delivers up to 3.1x faster generation.

At a Glance

Where Muse Glimmer leads

• Strong general-agentic scores for its size class: 75.5 on MCP-Atlas and 74.6 on DeepSearch QA, both ahead of Gemma4-31B
• Best-in-class AA-LCR long-context score (80.0) and AIME 2026 (94.7) among the three compared models
• Designed to fit entirely on a single 24–32GB consumer GPU at 4-bit precision with only 0.2–1.0% accuracy degradation

Where it lags

• Trails Qwen3.6-27B on several agentic-coding and computer-use benchmarks (OSWorld-Verified: 65.9 vs 75.6; TerminalBench 2.1: 51.7 vs 60.7)
• Higher Attack Success Rate on the Siren AgentDojo safety eval (28.4) than Gemma4-31B (25.6)
• Not evaluated for audio input/output or video (frame-sampled only)

Best for: Always-on local coding/agent assistants that need to run entirely offline on a single consumer GPU without sacrificing tool-use reliability.

What Muse Glimmer Is

Muse Glimmer is a dense, decoder-only causal transformer (29.6B total parameters, including a ~1.8B-parameter ViT-G/14 perception encoder) trained via logit distillation from Meta's larger "Muse Spark" model, then mid-trained on longer-context, agent-heavy data and post-trained with a combination of supervised fine-tuning, on-policy distillation, and reinforcement learning. It uses grouped-query attention (32 query / 2 KV heads) with a repeating local/local/local/global attention pattern and a 2,048-token sliding window on local layers, keeping inference memory manageable at long context lengths.

The model is explicitly built for local, always-on agent deployment rather than cloud-hosted API serving: Meta ships full-precision BF16 weights alongside two 4-bit quantized variants (a 32GB "K-Quant-Dynamic" build and a 24GB "K-Quant-17GB" build) sized to fit on a single consumer GPU or Apple Silicon Mac, plus a DFlash speculative-decoding drafter for faster generation. Muse Glimmer is evaluated under Meta's Advanced AI Scaling Framework and does not meet Meta's internal definition of "Frontier AI," since it's less capable than Muse Spark — but its size class still targets meaningful agentic capability: multi-step planning, reliable tool/function calling, failure recovery, multimodal (text+image) understanding, and compatibility with agent scaffolds like OpenClaw and Hermes Agent.

Positioned against similarly-sized open-weight models, Muse Glimmer competes directly with Google's Gemma4-31B and Alibaba's Qwen3.6-27B — both compared directly in Meta's own release benchmarks (see below).

Specifications

Pricing

Muse Glimmer is released under Apache 2.0 with no per-token API fee — cost is limited to your own hosting/compute. Meta publishes full-precision (BF16) weights plus two 4-bit quantized variants (~20GB) sized to run on 24GB or 32GB consumer GPUs, and the model is also available through inference platforms including Together AI, Fireworks AI, and OpenRouter for teams that prefer hosted pricing.

Context Window

Muse Glimmer has a 131,072-token context window — roughly 300+ pages of text in a single request. Meta reports an AA-LCR (long-context reasoning) score of 80.0, ahead of both Gemma4-31B (68.3) and Qwen3.6-27B (73.3), suggesting the model retains strong retrieval and reasoning quality at its full context length rather than only at short prompts.

Local Deployment & Quantization

Muse Glimmer is explicitly optimized to run entirely on-device. Meta's quantized builds trade a small accuracy cost for a large memory reduction:

Degradation measured as an average across accuracy metrics on 15 common benchmarks.

Muse Glimmer also ships with a DFlash speculative-decoding drafter — a small block-diffusion model that proposes 16 tokens at once for the main model to verify in parallel, producing identical output quality at significantly higher throughput:

Public Benchmark Scores

Scores above are reported by Meta and shown for context. They are not Benchgen measurements. All scores are from the "High Reasoning" effort setting; figures depend on harness, tools, and effort settings — see the Meta model card and methodology report for details.

Muse Glimmer vs Alternatives

Muse Glimmer leads on general-agentic and long-context tasks (MCP-Atlas, DeepSearch QA, AA-LCR) and edges out on coding via SWE-Bench Verified, but Qwen3.6-27B remains stronger on real desktop/computer-use work (OSWorld-Verified, TerminalBench 2.1) and Gemma4-31B slightly leads on GPQA Diamond — the right pick depends on whether the workload is agent/tool-use heavy or reasoning/knowledge heavy.

How Muse Glimmer Performs on Real Agent Tasks

Muse Glimmer's headline scores (MCP-Atlas 75.5, SWE-Bench Verified 76.0, DeepSearch QA 74.6) indicate solid general tool-use and multi-turn task completion for a model in its size class, but a single leaderboard number doesn't capture reliability across repeated runs or unfamiliar scaffolds. Meta explicitly designed Muse Glimmer for scaffold compatibility (OpenClaw, Hermes Agent) and failure recovery — diagnosing and retrying failed tool calls rather than halting — which matters more for production agent uptime than any single benchmark score. Builders evaluating Muse Glimmer for a specific domain (e.g., a coding agent vs a browser-automation agent) should weight OSWorld-Verified and TerminalBench 2.1 more heavily if computer-use is the target workload, since Muse Glimmer trails Qwen3.6-27B on both.

Use Muse Glimmer via API

from vllm import LLM, SamplingParams

llm = LLM(model="meta-models/Muse-Glimmer-30B", trust_remote_code=True)
sampling_params = SamplingParams(temperature=1.0, top_p=0.95, top_k=64, max_tokens=1024)

# Reasoning strength controls how much the model thinks before responding:
# set via system prompt as "Reasoning strength: high"
messages = [{"role": "user", "content": "Summarize this contract clause..."}]
output = llm.chat(messages, sampling_params)
print(output[0].outputs[0].text)

Related Models & Benchmarks

• Compare: Gemma4-31B · Qwen3.6-27B
• Benchmarks: MCP-Atlas · SWE-Bench Verified · GAIA2 · WildClawBench · ScreenSpot-Pro

Frequently Asked Questions