Meta Muse Glimmer 30B: Benchmarks, Hardware, Pricing and How to Run It

Kingy Verdict

Muse Glimmer 30B is a serious launch-day option for local agents if you already own a 24GB or 32GB machine: Meta supplies calibrated GGUFs, vision and speculative-decoding components, a 131K context configuration and unusually broad agent evaluations. It is not a benchmark sweep, a zero-cost service or a fully reproducible open-source release; Qwen3.6-27B wins several practical agent and multimodal tests in Meta’s own table, while Glimmer’s real value still needs independent, like-for-like reproduction.

Kingy did not run a paid endpoint or download the roughly 19.8GB small-GGUF-plus-vision-plus-drafter stack for this launch analysis. We checked the official repository metadata and revisions, the model configuration, Meta’s seven-page evaluation report, the current integration guidance, the llama.cpp support change and public provider catalogs on August 10, 2026. No compatible llama.cpp binary was installed on our 24GB M4 Pro test machine, so performance, peak unified memory, time to first token and tokens per second below remain vendor-published, not Kingy measurements.

Muse Glimmer 30B key specifications

The most important correction to early launch chatter is memory. The main muse-glimmer-30B-kquant-17gb.gguf file is exactly 16,756,681,056 bytes, or 16.76GB decimal. That is not the total requirement. The optional vision projector is 1.40GB, the DFlash drafter is 1.63GB, and inference still needs a KV cache, runtime buffers, the operating system and context-dependent headroom. Meta’s defensible target is 24GB for K-Quant-17GB, 32GB for K-Quant-Dynamic and 64GB for full precision.

Why this American-developed model matters

Muse Glimmer comes from Meta Superintelligence Labs and Meta, a U.S. technology company. That provenance matters commercially because Qwen and DeepSeek have supplied much of the recent open-weight momentum. An Apache-licensed, locally runnable agent model from an American lab gives developers another jurisdictional and ecosystem option without forcing them into a closed API.

It also fits Meta’s stated political strategy. In “The Future Is for Everyone”, Mark Zuckerberg argues that the U.S. and its allies should lead the open-model ecosystem and that broad access can support individual empowerment, economic growth and national leadership. Those are Zuckerberg’s claims, not independently established outcomes. American origin does not make a model private, unbiased or secure by default. Privacy depends on whether inference actually stays local; security depends on the runtime, network exposure, tool permissions, model provenance and operational controls.

That distinction is especially important for an agent model. A local chatbot can be offline. An agent connected to email, files, a shell, a browser and calendars may transmit data through those tools even when its weights never leave the machine.

Open weights are not the same as fully open source

Meta publishes the BF16 weights, two official GGUFs, the vision projector and the DFlash drafter under Apache 2.0. That is unusually permissive for commercial modification and redistribution.

But the release does not include the complete training dataset, every data-cleaning decision or a reproducible training pipeline. Meta’s model card also links a separate Usage Policy covering prohibited uses and deployment responsibilities. “Open-weight” is therefore the precise term. Teams should have counsel review both the Apache license and the additional policy before shipping a commercial or regulated product.

Architecture, vision, context and reasoning

Muse Glimmer is dense: every token traverses the full language model. The official configuration uses 52 decoder layers with grouped-query attention and a repeating local/local/local/global attention pattern. The dedicated perception encoder is a roughly 1.8B-parameter, 50-layer ViT-G/14-style component. The model accepts interleaved text and images, and Hugging Face’s launch guide shows video as sampled frames, capped at 96 frames by its example processor. It does not natively generate images, video or audio.

The model’s configured maximum is 131,072 tokens. Treat that as a ceiling, not a promise that a 131K agent session will be cheap or reliable. Long context increases cache memory and prefill time, and agent traces are often full of duplicated tool output. Start at 8K or 16K, log failures, then expand only if the task earns the cost. Meta recommends temperature 1.0, top-p 0.95 and top-k 64, with high or xhigh reasoning for complex coding and agent work.

Muse Glimmer benchmarks versus Qwen3.6-27B and Gemma 4 31B

Every score below comes from Meta’s launch table, but the provenance changes row by row. “Meta-internal” means Meta ran the evaluation; it is not independent reproduction. “Vendor” means a competitor’s self-reported number. “AA” means Artificial Analysis. Higher is better unless a down arrow appears.

The honest reading is mixed. Glimmer leads many agentic and reasoning rows, including MCP Atlas, DeepSearch QA, GAIA2, SWE-Bench Pro, IFBench, AIME and both long-context tests. Qwen leads GDPVal, SkillsBench, OSWorld, SWE-Bench Verified, TerminalBench and most listed multimodal tests. Gemma leads GPQA, HLE and the lower-is-better safety rates.

Benchmark methodology audit: useful, but not apples to apples

Meta’s evaluation-methodology report is more candid than most launch posts, and it explains why the table is not a universal ranking:

• Meta selected the more favorable of a competitor’s self-reported score or its own reproduction, while using Artificial Analysis when all three models were covered.
• Glimmer and Gemma used top-k 64; Qwen used top-k 20 and switched to temperature 0.6 on GAIA2 and WildClawBench.
• GAIA2 used OpenClaw. WildClawBench also ran under an OpenClaw harness. SWE-Bench used Meta’s bash-and-file scaffold. TerminalBench used Terminus 2. Different scaffolds can materially change results.
• OSWorld used a Claude-style computer-action space for Glimmer and Qwen, but a Gemini-style interface for Gemma. The tested split excluded eight Google Drive tasks.
• ScreenSpot Pro used an iterative crop-and-zoom tool with up to ten verification rounds and three restarts, which is not plain single-shot grounding.
• OmniDocBench used a modified two-component score and simpler Hungarian matching instead of the official v1.6 MGAM method.
• Several graders were other models, including Gemini 2.5 Pro, GPT-5.4, gpt-oss-120b and Claude 4.6 variants.

These choices do not make the results useless. They make them scaffold-specific launch evidence. Reproduce the exact task, runtime, prompt, tool schema, sampling and model revision before buying hardware or committing an agent workflow.

Hardware and memory requirements

Which quantization should you download?

Choose K-Quant-17GB on a 24GB card or 24GB unified-memory Mac. It is Meta’s explicitly targeted configuration and the only sensible starting point when memory is tight. Use text-only first; add mmproj-kquant.gguf only for images and dflash-kquant.gguf only after confirming the model runs comfortably.

Choose K-Quant-Dynamic on 32GB-class hardware when you want Meta’s lower claimed average degradation: 0.2% versus 1.0% for the smaller build across 15 benchmarks. Those are Meta’s averages, not guarantees for your tasks.

Choose BF16 for reference-quality evaluation or fine-tuning, preferably on an 80GB accelerator. A nominal 64GB card leaves little margin once long context and runtime allocations arrive.

How to run Muse Glimmer with current official commands

These commands are documentation-verified against the August 10 Hugging Face integration guide; Kingy did not execute inference on the launch-day model.

Install the current unified llama.cpp binary:

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

Start the official GGUF behind a local OpenAI-compatible server:

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

Then open http://localhost:8080, or connect an agent to http://localhost:8080/v1. Enable the official DFlash drafter only after the baseline works:

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

For BF16 reference inference, use Transformers 5.15 or newer when the final release containing MuseGlimmerForConditionalGeneration is available:

python -m pip install --upgrade "transformers>=5.15" accelerate

from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "meta-models/Muse-Glimmer-30B"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(
    model_id, dtype="auto", device_map="auto"
)

Hugging Face’s day-one multi-GPU path is vLLM’s Transformers backend:

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

Best runtime, agent scaffold and evaluation harness

For local GGUF inference, llama.cpp is the best first choice because the official quants and DFlash path target it directly. For BF16 correctness checks, use Transformers. For multi-GPU service, use vLLM with the Transformers backend today; Meta mentions SGLang, but the day-one Hugging Face guide provides the concrete vLLM command.

For a personal agent, OpenClaw is the closest match to Meta’s GAIA2 and WildClaw evaluations. For local coding, OpenCode is the more natural scaffold to try, and Kingy’s coding-agent comparison explains the broader trade-offs. Do not treat scaffold compatibility as permission to give a model unrestricted shell, email or browser access. Use a workspace sandbox, least-privilege tools and human confirmation for irreversible actions.

For benchmarking, use each benchmark’s native harness. lm-evaluation-harness can help with conventional text evaluations, but it cannot reproduce agentic SWE-Bench, OSWorld, WildClaw, GAIA2 or TerminalBench by itself. Record the machine, accelerator, memory, OS, exact revision, artifact, quantization, runtime commit, context, reasoning level, sampling, DFlash state, peak RAM/VRAM, time to first token, tokens per second and test date.

Muse Glimmer pricing and the true cost of local AI

The downloadable weights have no per-token fee. That does not mean the system is free. You still pay for hardware, storage, electricity, cooling, administration, backups and the time required to secure an agent.

Meta named Together AI, Fireworks AI and OpenRouter as launch partners. On our August 10 check, we could not verify a public Glimmer-specific per-token price in the providers’ public catalogs; OpenRouter’s public models API did not list it. The correct price is therefore not announced, not a rate borrowed from Muse Spark or another 30B model. Hugging Face Inference Endpoints exposes an hourly quote only after you choose a region and GPU, so the bill depends on that configuration.

For local electricity, use a simple formula: average system watts / 1,000 x hours x electricity rate. A workstation averaging 250W for four hours consumes 1 kWh. At a hypothetical $0.15/kWh that is $0.15; at $0.30/kWh it is $0.30. Hardware depreciation and operator time will usually dominate casual home use.

If you are choosing a machine, start with Kingy’s local AI compatibility guide. Do not buy a 24GB system solely because a 16.76GB file exists; wait for independent peak-memory, long-context and DFlash measurements on the exact hardware.

Limitations, safety, privacy and usage policy

Muse Glimmer can hallucinate, mishandle a multi-step plan or invoke the wrong tool. Meta’s own Siren AgentDojo result shows a 28.4% prompt-injection attack success rate in that setup. That is not a production security guarantee. Tool-call allowlists, content isolation, outbound-network rules, audit logs and human confirmation remain essential.

Local execution can reduce data exposure, but only if the runtime does not phone home and connected tools do not upload content. Verify network behavior, bind the local API to loopback, require authentication before exposing it beyond the machine, and treat downloaded weights and community quants as supply-chain inputs. Meta also says the model is not intended for people under 18 and lists prohibited uses in its Usage Policy.

Who should use Muse Glimmer 30B?

Use it if you already have 24-32GB hardware and want a local coding, research or personal-agent model with vision, long context and a first-party GGUF path. It is particularly interesting for teams that want an American-developed Apache-licensed alternative in a field dominated by Chinese open-weight releases.

Skip it for low-memory laptops, turnkey production security, audio workflows or decisions that require independently reproduced benchmark leadership. Cloud users should also wait for stable, public Glimmer pricing rather than assuming self-hosting is automatically cheaper.

Muse Glimmer 30B FAQ

Is Muse Glimmer 30B a mixture-of-experts model?

No. It is a dense causal transformer with a dedicated perception encoder. The official card reports about 29.6B total parameters, including the roughly 1.8B vision encoder.

Can Muse Glimmer 30B really run in 17GB?

The smallest main GGUF file is 16.76GB decimal, but that is not total working memory. Meta targets 24GB hardware for that build after accounting for the cache, runtime and optional components.

What is the Muse Glimmer context window?

The official configuration is 131,072 tokens. A 262K claim would be an extension, not the native published configuration, unless separately documented and tested.

Is Muse Glimmer 30B free for commercial use?

The weights are downloadable under Apache 2.0 and have no per-token fee. Commercial teams still need to review Meta’s separate Usage Policy and pay their own hardware, hosting and operating costs.

What is the best way to run Muse Glimmer locally?

Start with the official K-Quant-17GB GGUF in llama.cpp on 24GB-class hardware. Validate text-only inference, then add the vision projector and DFlash drafter one at a time while measuring memory and latency.

Official sources

• Meta launch article
• Mark Zuckerberg launch post
• The Future Is for Everyone
• Official BF16 model card and weights
• Official GGUF repository
• Meta evaluation methodology
• Hugging Face integration guide
• Muse Glimmer Usage Policy
• llama.cpp support pull request
• Unsloth Muse Glimmer guide