Meta released Muse Glimmer on August 10, 2026, a 30-billion-parameter open-weight model distilled from Muse Spark and built specifically for local, multimodal agent workflows. It’s Apache 2.0 licensed, ships with day-0 support across transformers, llama.cpp, and vLLM, and Meta’s own materials frame it as suited for “Claw- or Hermes-like setups”, the same category of local agent harness this site has covered with LFM2.5-2.6B.

If you’re already evaluating local agent models like Qwen 3.8-27B, Nemotron 3.5 Lightning, or LFM2.5, the question this guide answers is: what does Muse Glimmer actually add to that list, and when should you reach for it instead?

What is Muse Glimmer?

Muse Glimmer is a dense, multimodal causal language model with a dedicated perception encoder, distilled from Meta’s larger Muse Spark model down to roughly 30B parameters (Meta’s own model card lists it at approximately 29.6B). It’s built by Meta Superintelligence Labs and released under a plain Apache 2.0 license, with no Llama-style monthly-active-user cap.

Key specs, per Meta’s and NVIDIA’s model cards:

• Parameters: ~30B dense (29.6B per the NVIDIA model card)
• Architecture: Causal language model with a dedicated perception encoder for image and video input; hybrid attention pattern (sliding-window attention layers repeated in blocks, interleaved with full attention layers)
• Modalities: Text, image, and video input; text output
• Distillation: From Muse Spark, using a dedicated recipe to transfer agentic reasoning from the larger teacher model
• License: Apache 2.0
• Speculative decoding: Ships with a dedicated DFlash “assistant” drafter model that predicts blocks of 16 tokens per forward pass for faster decoding
• Runtime support at launch: transformers, llama.cpp (with Meta-distributed calibrated GGUF quants), vLLM (transformers backend), Hugging Face Inference Endpoints
• Hardware: Runs identically on NVIDIA (CUDA), AMD (ROCm), and Intel (XPU) GPUs via device_map="auto" in transformers

The perception encoder is a meaningful architectural choice, it’s a separate component dedicated to visual understanding rather than a bolted-on vision adapter, which is consistent with Meta’s broader multimodal model lineage.

How Muse Glimmer differs from Qwen 3.8-27B, Nemotron 3.5 Lightning, and LFM2.5

These four models get lumped together as “small local agent models,” but they solve different problems. Here’s the honest breakdown:

The practical distinction: Qwen 3.8-27B and Muse Glimmer overlap the most since both are ~27-30B dense multimodal models with agentic benchmarks and Apache 2.0 licenses. Meta’s own benchmark table (see below) puts them close on many tasks, with Qwen ahead on pure coding benchmarks and Muse Glimmer ahead on general agentic and safety-adjacent evaluations. Nemotron 3.5 Lightning is a different category entirely, it’s not competing to be your primary agent model, it’s designed to sit underneath one as a cheap execution layer, and it’s text-only. LFM2.5 is an order of magnitude smaller and targets hardware neither of the 27-30B models can run on (a phone, a low-power laptop), trading capability for a dramatically smaller footprint.

If you need multimodal understanding (images, video) in a local agent and have a single consumer GPU, Muse Glimmer and Qwen 3.8-27B are your two realistic options. If your bottleneck is the cost of high-volume repetitive tool calls inside an already-working agent, look at Nemotron 3.5 Lightning instead. If you need to run on genuinely constrained hardware, LFM2.5 is the one built for that.

Vendor-reported benchmarks (label these as vendor-reported, not independently verified)

Meta’s own Hugging Face blog post publishes a benchmark table comparing Muse Glimmer against Gemma4-31B and Qwen3.6-27B (not 3.8-27B, since 3.6-27B was the current Qwen dense model at the time Meta ran these evaluations). These are Meta’s self-reported numbers, not independently verified by a third party, and we’re presenting them as such:

Read this table carefully rather than as a simple leaderboard. Muse Glimmer leads on general agentic tasks (MCP Atlas, GAIA2) by a wide margin, is roughly comparable to Qwen3.6-27B on SWE-bench Pro, but trails on Terminal-Bench 2.1 and OSWorld-Verified. This isn’t a case where one model wins everything, it’s a case where the two models have different strengths, which matches their different design goals (Meta optimized for general local agent workflows; Alibaba’s Qwen line has leaned harder into terminal-based coding agent performance). We have not independently reproduced any of these numbers, and neither Meta’s nor Alibaba’s self-reported benchmarks should be treated as a substitute for testing against your own workload.

Hardware and quantization

That BF16 inference figure (1x 80GB H100) is for full-precision inference and fine-tuning workloads specifically, it’s not the realistic bar for just running the model locally as a chat or agent backend. For local, single-consumer-GPU use, quantization is the practical path: Meta distributes calibrated GGUF quants directly, and community quantizers (Unsloth, among others) are producing additional variants. The exact VRAM figure for a Q4_K_M quantization wasn’t published in Meta’s launch materials at the numbers we could verify; if you’re planning hardware, start with a Q4_K_M GGUF on whatever consumer GPU you have and adjust based on observed memory use, following the same pattern used for other 27-30B dense models in this class.

Running Muse Glimmer locally

llama.cpp (recommended for most local setups)

curl -LsSf https://llama.app/install.sh | sh

llama serve -hf meta-models/Muse-Glimmer-30B-GGUF

This starts a local server with a built-in WebUI at localhost:8080, and exposes an OpenAI-compatible /v1/chat/completions endpoint.

With DFlash speculative decoding (faster generation)

Muse Glimmer ships with a dedicated speculative decoding drafter model. In llama.cpp:

llama serve -hf meta-models/Muse-Glimmer-30B-GGUF \
  --spec-type draft-dflash \
  --spec-draft-n-max 15

The DFlash drafter was trained with a block size of 16 (one anchor token plus 15 proposed tokens), so --spec-draft-n-max values above 15 get clamped automatically.

Ollama (Apple Silicon, MLX-accelerated)

Ollama added Muse Glimmer support on August 10, 2026, with MLX acceleration and native DFlash and image-input support on Apple Silicon:

ollama run muse-glimmer

See our Ollama complete guide if you don’t have Ollama installed yet.

Transformers (Python)

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [{"role": "user", "content": "Explain what makes this model different from a standard dense LLM."}]
inputs = processor.apply_chat_template(
    messages, tokenize=True, return_dict=True, return_tensors="pt",
    add_generation_prompt=True, reasoning_strength="low"
).to(model.device)

outputs = model.generate(**inputs)

The same script runs unchanged on NVIDIA, AMD, or Intel GPUs, device_map="auto" handles accelerator selection.

vLLM (GPU server, higher throughput)

vllm serve meta-models/Muse-Glimmer-30B --model-impl transformers --tensor-parallel-size 4

Agent harness compatibility

Meta explicitly frames Muse Glimmer for “privacy-aware applications such as coding, document analysis, personal assistants, Claw- or Hermes-like setups”, and publishes a working OpenClaw configuration example that points the OpenClaw gateway at a Muse Glimmer inference endpoint over its OpenAI-compatible API. This is a documented integration pattern from Meta directly, not a theoretical claim.

Meta’s launch materials specifically demonstrate OpenClaw integration with worked examples (including agent-driven self-quantization and self-deployment demos). We did not find an equivalently detailed, step-by-step Hermes Agent setup guide in Meta’s own materials at the time of writing, only the general “Hermes-like setups” framing alongside the OpenClaw example. If you’re specifically committed to Hermes Agent rather than OpenClaw, the LFM2.5 setup guide remains the pairing with a fully documented, vendor-confirmed Hermes Agent walkthrough as of this writing. Muse Glimmer should work with Hermes Agent in principle (both consume OpenAI-compatible endpoints), but treat that as unverified against a specific worked example until Meta or Nous Research publishes one.

Limitations

• Safety tradeoffs are mixed, not uniformly better. Meta’s own benchmark table shows Muse Glimmer with a higher “violation” rate on CI Memories and a higher attack success rate on Siren AgentDojo compared to Gemma4-31B, meaning it’s more susceptible to certain prompt-injection-style attacks in Meta’s own testing. This is a real tradeoff of the model’s more permissive agentic capability, not a minor footnote.
• No independent benchmark verification yet. All comparative numbers above come from Meta’s own materials. Wait for third-party evaluation platforms to publish independent results before making a purchasing or deployment decision based on benchmarks alone.
• Fine-tuning requires real GPU infrastructure. Full fine-tuning needs 8x 80GB H100-class hardware. This is not a model you fine-tune on a laptop, even though inference and light LoRA work is more accessible.
• Community quantization ecosystem is still maturing. Meta’s own calibrated GGUF quants exist, but the broader third-party quantization landscape (comparable to what exists for Qwen or Llama models) will take time to mature.

FAQ

Is Muse Glimmer better than Qwen 3.8-27B?

Neither wins outright based on Meta’s own benchmark table (which compared against Qwen 3.6-27B, not 3.8-27B). Muse Glimmer leads on general agentic benchmarks (MCP Atlas, GAIA2); Qwen’s dense model line leads on Terminal-Bench and computer-use tasks. Choose based on your workload, not a single leaderboard number, and treat both sets of numbers as vendor-reported until independently verified.

Can I run Muse Glimmer on a single consumer GPU?

Yes, with quantization. Meta ships calibrated GGUF quants directly and llama.cpp has day-0 support. Full-precision BF16 inference is documented at requiring 1x 80GB H100-class hardware, but that figure is for full-precision workloads; a quantized GGUF build is the realistic path for consumer hardware, following the same pattern as other 27-30B dense models.

Does Muse Glimmer work with Hermes Agent?

Meta describes Muse Glimmer as suited for “Hermes-like setups” and publishes a fully worked OpenClaw integration example. We could not find an equally detailed, vendor-published Hermes Agent-specific walkthrough at the time of writing. It should work in principle since both are OpenAI-compatible-endpoint agent harnesses, but if you need a vendor-confirmed, tested Hermes Agent pairing today, see our LFM2.5-2.6B guide, which has a documented Hermes-specific setup from Liquid AI.

What license is Muse Glimmer released under?

Apache 2.0, with no monthly-active-user restriction (unlike some earlier Meta Llama licenses). This makes it fully permissive for commercial use.

Is Muse Glimmer the same as Muse Spark or Muse Code?

No. Muse Spark is Meta’s larger, paid model family, and Muse Code is Meta’s terminal coding agent built on Muse Spark. Muse Glimmer is a separate, smaller, open-weight model distilled from Muse Spark specifically for local deployment, it is not a rebrand or variant of either.

What’s the catch with Muse Glimmer’s more permissive agentic capability?

Meta’s own testing shows a higher violation rate on certain safety benchmarks (CI Memories) and a higher attack success rate on a prompt-injection benchmark (Siren AgentDojo) compared to Gemma4-31B. More capable agentic behavior appears to come with a real, measured safety tradeoff in Meta’s own numbers, not just marketing caution language.

Related Articles

• Qwen 3.8-27B Complete Guide
• NVIDIA Nemotron 3.5 Lightning: The Execution Model for AI Agents
• Running Hermes Agent Locally with LFM2.5-2.6B
• Muse Spark 1.1 Complete Guide
• Muse Code Complete Guide
• Best AI Models for Agents 2026