Meta Muse Glimmer 30B: Full Review

Muse Glimmer is Meta Superintelligence Labs' answer to a specific gap: everything the company had shipped since Muse Spark 1.1 and Muse Spark 1.2 in 2026 was closed, cloud-hosted and billed by the token. Glimmer inverts that: it is a 30B dense model, distilled down from the larger closed Muse Spark using logit distillation during pre-training, released with downloadable weights under the permissive Apache 2.0 licence, and explicitly engineered to fit on a single consumer GPU rather than a data-centre rack.

The pitch is narrower than "another frontier model": Meta is positioning Glimmer for always-on local agents that handle coding, tool use, scheduling and file work directly on your device, without every request leaving your machine. That is a meaningfully different product category from a chat model, and the benchmark suite Meta chose to publish reflects it - agentic tool-use and multi-step reasoning benchmarks dominate, rather than the general knowledge tests that headline most model launches.

• Best for: local coding agents, function calling, LLM-as-judge evaluation pipelines, and always-on personal-agent workflows that need to stay on-device.
• Headline numbers: 35 on the Artificial Analysis Intelligence Index, best result on 12 of 24 rows in Meta's own Gemma4-31B/Qwen3.6-27B comparison table, runs in roughly 17-20GB at 4-bit quantisation.
• Defining trait: a distilled open-weight sibling of the closed Muse Spark model, purpose-built to run entirely on one consumer GPU.
• Main caveat: Qwen3.6-27B still leads on harder coding and computer-use benchmarks, and Artificial Analysis recorded a high hallucination rate on its AA-Omniscience test.

Muse Glimmer's relationship to the rest of the Muse family is the single most important thing to understand about it. Meta's own research blog describes Glimmer as distilled from Muse Spark - the closed, proprietary flagship that debuted in April 2026 and was later updated into the coding-focused Muse Spark 1.2 - using logit distillation during pre-training. In plain terms, Meta trained the smaller 30B model to mimic the output distribution of its much larger closed sibling, rather than training Glimmer from scratch as an independent model.

That makes Glimmer something genuinely new for Meta's release strategy in 2026: not a return to the old Llama playbook of shipping frontier-scale weights outright, and not a continuation of Muse Spark's fully closed, API-only model either, but a third lane - a deliberately smaller, distilled, open-weight product built around a specific constraint (fits on one consumer GPU) rather than around raw capability. Muse Spark itself remains closed and more capable; Glimmer trades some of that capability away in exchange for being something you can actually own and run yourself.

Glimmer is a dense causal transformer, not a Mixture-of-Experts design - a deliberate choice for a model meant to run predictably on fixed consumer hardware rather than exploit distributed accelerator memory. Meta's published model card lists roughly 29.6 billion total parameters, including a dedicated perception encoder of around 1.8 billion parameters that handles image input alongside text. The core network runs 52 layers in a repeating local-local-local-global attention pattern: three sliding-window ("local") attention layers for every one full ("global") attention layer, a hybrid design that keeps compute manageable at long context while still letting the model attend across its full window periodically. Grouped-query attention uses 32 query heads against just 2 key-value heads, a 16:1 ratio that meaningfully shrinks the KV cache Meta says needs as little as 1.8GB at minimum, a detail that matters directly for how much context you can afford on a memory-constrained consumer GPU.

Context length runs to 131,072 tokens (128K) and beyond, output is text-only despite the multimodal image input, and Meta lists a knowledge cutoff of 4 January 2026. Training data is described in Meta's model card as "multimodal content sourced from publicly available data, data provided by third parties and information from Meta's products and services, curated and enriched by external vendor networks and Meta personnel" - broadly the same sourcing language Meta has used for prior Muse and Llama releases, without a more granular breakdown of proportions or provenance.

The other notable engineering investment is inference speed on exactly the hardware Meta expects people to actually use. Alongside the base weights, Meta shipped a speculative-decoding drafter it calls DFlash, plus two official quantisation recipes: a "K-Quant-Dynamic" build tuned for 32GB GPUs with roughly 0.2% degradation from full BF16 precision, and a more aggressive "K-Quant-17GB" build that fits in around 17GB with about 1% average degradation across Meta's internal 15-benchmark suite - the difference between "needs a 32GB workstation GPU" and "fits on a well-specced consumer laptop" being almost entirely down to that quantisation work rather than a smaller model.

Local agentic coding

Meta built Glimmer around "end-to-end agentic task completion" rather than one-shot code generation: multi-step reasoning chains, tool use across a session, and explicit failure recovery when a step goes wrong. In practice that means running Glimmer inside an agent harness such as OpenCode, where it can plan a task, execute tool calls against real local services, watch the results, and adjust course - the same pattern Claude Code, Codex and Muse Code use, but running entirely on-device rather than calling out to a hosted API for every step. Meta's own demo material shows Glimmer working through a genuinely mundane real-world task inside OpenCode: discovering a Home Assistant instance on a home network, identifying an A/V receiver entity, and building a working control dashboard from scratch, tracking its own progress against a running to-do list as it goes.

Function calling and tool use

Reliable function calling is one of Glimmer's stated design priorities, and it shows up directly in the benchmark selection: Meta and independent evaluators both lean heavily on agentic tool-use tests (MCP Atlas, tau-cubed-Banking, DeepSearch QA) rather than static Q&A benchmarks. That focus makes sense for the target use case - a model that is going to be calling calendar APIs, file-system tools and search functions unattended needs to get the call syntax and argument structure right far more consistently than a model that is mostly generating prose.

LLM-as-judge evaluation

Meta also positions Glimmer explicitly as an LLM-as-judge model - something you run locally to grade, filter or rank the outputs of other models or of your own pipeline, rather than only as a generation model in its own right. Running the judge model on the same machine as the pipeline it is evaluating removes a network round-trip and a per-call cost from what is often a very high-volume workload (grading thousands of candidate outputs during synthetic data generation or RL training, for instance), which is a genuinely practical reason to want a smaller, fast, locally-hosted judge rather than routing every evaluation call to a hosted frontier model.

Always-on local agents

The most distinctive framing in Meta's launch material is "always-on": a Glimmer-powered agent that stays resident on your device, watching for triggers, and acting continuously rather than being invoked per-request. Multilingual support across 100+ languages, adjustable reasoning effort, and scaffold compatibility with existing agent harnesses (Ollama, LM Studio, llama.cpp, MLX, ExecuTorch, vLLM and SGLang were all listed as day-one partners) all point the same direction: this is meant to be infrastructure you install once and leave running, not a model you call occasionally through an API console.

Multimodal input and inference speed

The dedicated 1.8B-parameter perception encoder means Glimmer can reason over screenshots, diagrams and photos alongside text, which matters directly for an on-device agent - reading a screenshot of a settings panel, a chart in a PDF, or an error dialog is a routine part of the kind of computer-use and coding-agent work Meta is targeting, even though the model's own output remains text-only. Meta paired that capability with real attention to inference speed on the exact machines people were expected to test it on: the DFlash speculative-decoding drafter is reported to speed up generation by roughly 3.1x on an RTX 5090, 1.8x on a MacBook with M5-Max, and 1.5x on M4-Max, figures that matter far more for a model meant to run continuously in the background than they would for an occasional cloud API call, where network latency dominates regardless of local decode speed.

Meta's own launch materials compare Glimmer against two similarly-sized open rivals: Gemma4-31B and Qwen3.6-27B. Independent analysis of that full 24-row table found Glimmer posts the single best result on 12 of the 24 rows, beating Gemma4-31B on 19 of 24 and Qwen3.6-27B on 14 of 24. That is a genuinely strong showing for a model built primarily for on-device deployment rather than raw leaderboard position, but it is not a sweep, and the pattern of wins and losses is informative in its own right.

On agentic and tool-use benchmarks, Glimmer's strengths are clear and consistent: MCP Atlas 75.5 versus Qwen3.6-27B's 62.5, DeepSearch QA 74.6 versus 71.1, and tau-cubed-Banking (a tool-use benchmark simulating banking-agent tasks) around 23.5-24%, ahead of Qwen's 16.7%. These are precisely the categories Meta optimised for, and the margins are wide enough that they look like a genuine capability difference rather than noise.

On harder coding and computer-use benchmarks, the picture flips. Terminal-Bench 2.1: Glimmer 51.7% against Qwen3.6-27B's 60.7% and Gemma4-31B's 43.4% - Glimmer beats Gemma comfortably but trails Qwen by nine points. SWE-Bench Verified: Glimmer 76.0% versus Qwen's 77.2%, a near-tie that still favours Qwen. SWE-Bench Pro: Glimmer scores 51.2%. Independent write-ups summarising the full comparison note that Qwen3.6-27B remains ahead specifically on OSWorld-Verified and SkillsBench too - the two benchmarks that most directly test sustained, real desktop computer-use rather than agentic tool-calling in a more constrained environment.

Artificial Analysis, which runs its own independent evaluation against live model weights rather than relying on vendor-reported numbers, placed Glimmer at 35 on its Intelligence Index - 21 points above Llama 4 Maverick (14), Meta's last major open-weights release, and close to Kimi K2.5 in reasoning mode (36) while trailing Qwen3.6-27B in reasoning mode (38) by three points and sitting 5 points above Gemma4-31B in reasoning mode (30) despite a similar parameter count. Artificial Analysis frames the standout fact as efficiency: Glimmer's score is achieved with roughly 33 times fewer parameters than some of the larger reasoning models it sits alongside on that index.

On real-world work tasks, Artificial Analysis's GDPval-AA v2 evaluation put Glimmer at 953 Elo, just below the 1,000 Elo human baseline - a genuinely respectable result for a 30B model designed to run on a laptop, though it means the model is not yet reliably matching human performance on the mixed professional-work tasks that benchmark covers. The one figure worth flagging clearly as a caveat is AA-Omniscience, Artificial Analysis's hallucination-focused knowledge test: Glimmer scored -33 on the -100 to 100 scale, corresponding to a hallucination rate in the region of 82% on hard knowledge questions where the model does not actually know the answer. That is a meaningfully higher hallucination rate than the frontier tier, and worth weighing carefully against any always-on agent use case that involves factual claims rather than tool-mediated actions.

Muse Glimmer's weights are downloadable now from Hugging Face (meta-models/Muse-Glimmer-30B, with an instruction-tuned Muse-Glimmer-30B-assistant variant also listed) under the Apache 2.0 licence - the most permissive licence Meta has attached to a major model release, with no field-of-use restrictions of the kind that limited earlier Llama releases. Day-one support spans the major local-inference ecosystem: Ollama, LM Studio, Unsloth, llama.cpp, MLX (for Apple Silicon) and ExecuTorch for on-device deployment, plus vLLM and SGLang for server-style self-hosting. Third-party hosts including Together AI, Fireworks AI and OpenRouter also listed Glimmer at launch, for anyone who wants the open weights' flexibility and pricing without managing their own GPU.

Artificial Analysis separately tracks an "Openness Index" that scores how genuinely open a release is beyond just the licence text - covering things like whether training data, code and evaluation methodology are also disclosed. Glimmer scored 44 on that index, putting it level with DeepSeek V4 Flash, GLM-5.2 and Ling 3.0 Flash: a real improvement in licensing permissiveness over Meta's recent closed Muse Spark releases, but not a return to the fullest transparency standard some open-weight labs have set.

There is no licence fee and no per-token charge to Meta for using Muse Glimmer - the weights are free to download, free to run, and free to modify under Apache 2.0. That is a genuine and meaningful difference from every closed Muse Spark release, and from most frontier-tier competitors. But "free" only describes the software; it says nothing about the hardware it needs to run on.

If you self-host, the real cost is capital expenditure on a suitable machine: a MacBook Pro with an M4-Max or M5-Max chip and sufficient unified memory, or a PC with an Nvidia RTX 5090 or similar 24-32GB consumer GPU, both configurations Meta specifically tested. Realistic street prices for hardware in that class run from roughly £1,500 for an entry-level configuration up to £4,000 or more for a fully specced Mac Studio or RTX 5090 workstation - a one-off cost rather than a recurring one, and hardware many developers already own for other reasons. Electricity to run the GPU is the only genuinely ongoing cost, and it is small relative to any comparable cloud API bill for equivalent usage volume.

For anyone who would rather not manage local inference at all, the third-party hosts that picked Glimmer up at launch (Together AI, Fireworks AI, OpenRouter) offer it at standard per-token API pricing, typically a fraction of what a closed frontier model like Muse Spark or Claude charges, since Glimmer's smaller size and open weights let multiple providers compete on the same underlying model rather than one vendor setting a monopoly price.

There is a third option worth naming explicitly: a machine you were always going to own anyway. Anyone shopping for a new MacBook Pro or a gaming PC in the second half of 2026 already has M4-Max, M5-Max or RTX 5090-class hardware on their shortlist for reasons that have nothing to do with AI - video editing, game development, 3D rendering. For that buyer, Glimmer's genuine marginal cost is close to zero: the GPU spend was happening regardless, and Glimmer simply becomes one more thing that hardware can do. That framing does not hold for someone buying a GPU purely to run this one model, where the honest comparison is against however many months of API credits an equivalent budget would buy from a hosted provider instead.

• Not a universal win over Qwen3.6-27B: Qwen still leads on Terminal-Bench 2.1, SWE-Bench Verified, OSWorld-Verified and SkillsBench - harder coding and real computer-use benchmarks where Glimmer's agentic-tool-use focus does not fully translate.
• High hallucination rate on hard knowledge: Artificial Analysis's AA-Omniscience evaluation recorded roughly an 82% hallucination rate on questions the model does not actually know the answer to - a real concern for an "always-on" agent that may be trusted with factual tasks.
• Capped by its distillation lineage: Glimmer is deliberately smaller and weaker than the closed Muse Spark it was distilled from; anyone who needs Muse Spark's full capability still has to pay for the closed API.
• Limited independent safety disclosure: Meta has not published red-teaming or dangerous-capability evaluation documentation comparable to what Anthropic, OpenAI or Google DeepMind attach to equivalent releases, which matters more, not less, for a model marketed for unattended local agent use.
• Real hardware floor: "runs on a consumer GPU" still means a specific, relatively recent and relatively expensive one (M4-Max/M5-Max or an RTX 5090-class card); it is not a model that runs meaningfully on older or budget hardware.
• Text-only output: despite accepting image input through its perception encoder, Glimmer only generates text, not images or other modalities.

Against its own closed sibling, the proprietary Muse Spark 1.2, Glimmer is deliberately a step down in raw capability in exchange for being genuinely yours to run: no per-token bill, no data leaving your machine, no dependency on Meta's API staying available. Against Qwen3.6-27B, the closest like-for-like open-weight rival at roughly the same parameter count, the comparison is a genuine trade-off rather than a clean win for either side - Glimmer leads on agentic tool-use and general reasoning, Qwen leads on harder coding and computer-use benchmarks. Against Gemma4-31B, Glimmer's advantage is much clearer and more consistent, winning on 19 of Meta's 24 published comparison rows.

Against GLM 5.3, a much larger open-weight model from Z.ai built for a different niche (frontier-adjacent coding and cybersecurity work at datacentre scale), Glimmer is not really a direct competitor - it occupies the "runs on your laptop" end of the open-weights market rather than the "beats the closed frontier on hard benchmarks" end GLM 5.3 is chasing. Qwen 3.8 Max, Alibaba's much larger 2.4-trillion-parameter flagship, sits in a similar "bigger, more capable, not locally-hostable on consumer hardware" category. The honest framing is that Glimmer competes on a different axis entirely: not "which model scores highest" but "which model can you actually run entirely on your own machine, for free, today."

It is also worth placing Glimmer against Meta's own history rather than only against rivals. Llama 3.1's 405-billion-parameter flagship needed a multi-GPU server to run at all; Glimmer is roughly 13 times smaller and runs on a single card, at a level of agentic capability Llama 3.1 was never evaluated against because the agentic-benchmark category barely existed at the time. That trajectory - open weights getting smaller, more efficient and more agent-focused release over release, even as Meta's flagship model line becomes fully closed - looks less like a retreat from open source and more like a deliberate specialisation: closed weights for the model Meta wants to sell access to, open weights for the model Meta wants running on as many personal devices as possible.

Worth using now if you already own or are willing to buy hardware in the M4-Max/M5-Max or RTX 5090 class, and your workload is genuinely agentic - local coding agents, tool-calling pipelines, LLM-as-judge evaluation at volume, or a personal automation agent you want kept entirely on-device for privacy reasons. The Apache 2.0 licence and broad day-one tooling support (Ollama, LM Studio, vLLM and friends) make it a low-friction evaluation if you already have the hardware.

Worth skipping or waiting on if your workload is dominated by the specific benchmarks where Qwen3.6-27B still leads (harder coding, sustained computer-use), in which case Qwen remains the better open-weight pick at a similar size; if you do not already have suitable local GPU hardware and are not planning to buy any, a hosted API (including Muse Spark itself, or a rival closed model) is simpler than building a local inference stack for one model; or if your use case involves unattended factual claims where the AA-Omniscience hallucination rate is a real risk rather than an acceptable trade-off.

Muse Glimmer is a genuinely useful, honestly-scoped release: a 30B distilled model that does not pretend to beat the frontier, but does deliver on its actual promise of running a capable agentic model entirely on a single consumer GPU, under a fully permissive licence, at zero licensing cost. The agentic tool-use numbers back up Meta's stated focus, and the DFlash speculative-decoding work and aggressive quantisation recipes show real engineering effort went into making it practical on real hardware, not just theoretically small.

What it is not is a Qwen3.6-27B killer across the board, and it is not yet accompanied by the kind of independent safety documentation that would make "always-on personal agent" an unqualified recommendation rather than a capability with real, unresolved trust questions attached. Judge Glimmer on the axis Meta actually built it for - local, on-device, agentic - and it is one of the more credible releases of the category. Judge it as a general-purpose frontier model and it was never trying to be one.