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

Hardware and setup evidence rechecked October 13, 2026; original model evaluations date to August 12. 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. ¹²

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. ¹³⁴⁵

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. ¹⁶

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 full-cycle 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. ¹⁷

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. ⁶⁸⁹

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. ¹⁶¹⁰

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. ¹¹¹

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

October evidence: Meta’s GGUF card distinguishes ~17GB text-only, ~19GB with vision and ~20GB including the optional drafter for its smaller pack. These are vendor approximations for model components and working context, not verified peak unified memory on your Mac. Official pack.

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. ¹

Use the specific GGUF files, not an abstract “30B” fit: Meta’s official GGUF repository provides the file sizes below. The totals are vendor estimates for weights plus a working context, not measured peak Mac unified memory.

Meta GGUF configuration	Text GGUF	With vision	With vision + DFlash	Meta hardware target
KQuant-17GB · Q4_K_M	16.8GB	~19GB	~20GB	24GB
KQuant-Dynamic · Q4_K_XL	19.7GB	~22GB	~23GB	32GB

The vision projector is a separate 1.4GB file; the optional speculative decoding drafter adds 1.6GB. Loading only the text GGUF does not enable images. Actual headroom depends on configured context, your Mac’s shared operating-system memory and concurrent processes. These figures cover Meta’s GGUF pack and do not automatically transfer to Ollama’s MLX runtime or other conversions. Meta file inventory

24 GB

This is the smallest official target tier. It makes a 30B multimodal agent plausible on a single workstation-class 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. ¹²¹³

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. ¹⁴

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. ¹⁵

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. ¹¹⁶¹⁷

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. ¹¹²

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). ¹

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. ²

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. ⁴⁵

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. ¹⁴
• 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. ¹⁸

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. ⁸

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

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

llama.cpp: the published, reproducible GGUF route

The official Meta GGUF repository documents precise requirements omitted from the original launch overview. llama.cpp b10353 or later is required; older builds do not recognize the architecture. In the official pack, the 16.8GB KQuant 17GB file is the text model; image interpretation requires a separate 1.4GB mmproj perception projector. An optional 1.6GB DFlash drafter consumes further memory. The dynamic Q4_K_XL text variant is 19.7GB. These are file sizes, not Mac peak-memory measurements.

For an Apple-Silicon smoke test, install a sufficiently recent llama.cpp, download the specific model and run the vendor-documented text route:

brew install llama.cpp
llama-cli --version
llama-cli -hf meta-models/Muse-Glimmer-30B-GGUF:Q4_K_M -c 4096 --jinja

For a reproducible image test, first download the separate vision projector. Meta’s official GGUF card documents hf download; use a virtual Python environment for its tooling:

python3 -m venv .venv-glimmer
source .venv-glimmer/bin/activate
python -m pip install --upgrade huggingface_hub
hf download meta-models/Muse-Glimmer-30B-GGUF \
  --local-dir Muse-Glimmer-30B-GGUF \
  --include 'Muse-Glimmer-30B-KQuant-17GB-Q4_K_M.gguf' \
  --include 'mmproj-Muse-Glimmer-30B-Q4_K_M.gguf'

Put a non-sensitive test image at photo.png, then use the documented multimodal llama.cpp path (build b10353 or newer):

llama-mtmd-cli \
  -m Muse-Glimmer-30B-GGUF/Muse-Glimmer-30B-KQuant-17GB-Q4_K_M.gguf \
  --mmproj Muse-Glimmer-30B-GGUF/mmproj-Muse-Glimmer-30B-Q4_K_M.gguf \
  -ngl 99 -c 4096 --jinja \
  --image photo.png -p 'Describe this image briefly.'

The text-only GGUF cannot analyze pictures by itself. This test requires both llama-mtmd-cli and mmproj, while --jinja activates the model’s bundled chat template. Avoid custom stop sequences that terminate at <|eom|>: that marker ends a message, not the complete turn, and can break tool calling. These are instructions adapted from Meta’s documentation, not a claim of an independently executed Mac test.

One serving trap: with llama-server, the -c context budget is divided across -np parallel slots. Four slots and 131,072 total tokens mean about 32,768 tokens per slot, not 131,072 per agent. Record per-slot context and macOS Activity Monitor memory pressure before comparing with a DFlash-enabled run. Meta’s reported DFlash gains are vendor benchmarks; neither this guide nor the SVGs claim an independently measured M-series gain.

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. ⁹

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. ¹⁴

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. ¹²¹³

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. ¹⁹

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.

Connect Muse Glimmer to a local Hermes Agent on a Mac

Unlike Meta Muse Wonder, Muse Glimmer publishes weights for local on-device inference. Muse Wonder is a hosted cloud model with separate API and subscription products; the shared Muse brand does not imply equivalent weights, usage terms or privacy guarantees.

A practical detail absent from most model comparisons: Meta’s official GGUF model card explicitly documents using Hermes Agent with a local OpenAI-compatible llama.cpp server, without a paid cloud inference key. The commands below adapt that vendor-documented setup; we did not execute a fresh Hermes integration or benchmark during our review. ⁷

1. Start a bounded, loopback-only local inference server

brew install llama.cpp
llama-server -hf meta-models/Muse-Glimmer-30B-GGUF:Q4_K_M \
  -a muse-glimmer-30B --jinja -c 4096 -np 1 \
  --host 127.0.0.1 --port 8080

Check that you have llama.cpp b10353 or later. Meta’s smaller GGUF targets 24GB of unified memory, not a verified peak RAM requirement on every Mac. The -hf flag may fetch model weights over the network the first time; test fully offline operation only after downloading all required files. Capture the exact file and revision digest for repeatable performance comparisons. -c 4096 -np 1 keeps the first test to 4,096 context tokens for a single slot; downloading the model may take substantial disk space. The model’s template needs --jinja, while 127.0.0.1 keeps the server off your LAN by default. ⁷

2. Verify the API before changing a Hermes profile

In another terminal, check the advertised model ID and send a synthetic request:

curl -fsS http://127.0.0.1:8080/v1/models
curl -fsS http://127.0.0.1:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"muse-glimmer-30B","messages":[{"role":"user","content":"Reply OK only."}],"max_tokens":64}'

Only after a successful smoke test, configure the intended Hermes profile. Back up existing model settings first: changing these keys may otherwise replace your current global provider configuration.

hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default muse-glimmer-30B

The hermes config set keys match Meta’s documented Hermes integration pattern. The Hermes model ID must match the server alias; reconcile the /v1/models result with -a if needed. For vision you additionally need the 1.4GB mmproj encoder and a compatible multimodal serving route; the above is a text-first agent smoke test, not proof that all vision or DFlash features work. ⁷

3. Evaluate agent reliability without granting unnecessary access

Start with three synthetic, non-sensitive tasks: a schema-valid tool call, a trivial edit in a scratch directory, and a correct short summary. Repeat each three times, and measure accepted outcomes, bad tool arguments, latency, and memory pressure. Grant file, shell, browser, and cloud access only as independently required. Local model inference does not guarantee that an agent’s tools keep data on-device.

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. ¹

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. ⁴²⁰

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.

Mac-specific verification before downloading 30B weights

Check the exact Meta model card and the official GGUF repository before selecting quantization and a serving runtime. A 24GB target is not a guarantee of comfortable 131K-token serving. The model’s attention cache, loaded vision projector, macOS and competing processes consume additional memory; check Activity Monitor under the actual context load.

For a valid local-versus-Qwen comparison, choose one fixed set of image and text prompts with expected factual answers, a few schema-checked tool tasks and a coding task with executable tests. Record both complete failures and successes, prompt/response tokens, time to first token, decode speed, model-file digests, runtime commit and Mac chip/Unified Memory. Report results as your measurements only when you actually ran the procedure. DFlash deployment and vendor benchmark charts are not automatically reproducible in every macOS runtime.

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.

Local setup is covered in the Ollama guide, and memory planning in the unified memory guide.

Source register and limitations

Model specifications originate from the vendor model card; provider prices, external benchmarks and community builds are attributed to their respective authors. This is not an independently repeated Mac performance evaluation.

Footnotes

1. Meta: Muse Glimmer base model card ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸ ↩⁹ ↩¹⁰ ↩¹¹ ↩¹²

2. Meta Research: evaluation methodology ↩ ↩²

3. Meta Research: launch announcement ↩

4. Artificial Analysis: independent Muse Glimmer review ↩ ↩² ↩³ ↩⁴

5. Artificial Analysis: Muse Glimmer model scores ↩ ↩²

6. Hugging Face: Muse Glimmer release engineering ↩ ↩² ↩³

7. Meta: official Muse Glimmer GGUF, Mac and Hermes setup ↩ ↩² ↩³ ↩⁴

8. Ollama: Muse Glimmer 30B model and MLX tag ↩ ↩²

9. PyTorch: ExecuTorch Muse Glimmer deployment ↩ ↩²

10. Sebastian Raschka: architecture notes ↩

11. Meta: Perception Models encoder ↩

12. AMD: local Muse Glimmer hardware and LM Studio ↩ ↩² ↩³

13. LM Studio: Muse Glimmer model integration ↩ ↩²

14. vLLM: Muse Glimmer serving recipe ↩ ↩²

15. Independent Mac mini 16GB Muse Glimmer experiment ↩

16. vLLM: DFlash algorithm guide ↩

17. arXiv: DFlash paper ↩

18. WildClawBench: agent benchmark repository ↩

19. OpenRouter: Muse Glimmer model pricing ↩

20. Qwen: Qwen3.6 27B model card ↩