Muse Glimmer 30B: Meta's Apache-Licensed Local Agent Model

For two years the question about running an agent locally was whether it was possible at all. With a crop of dense 27B to 31B models that fit on one consumer GPU, the question has become which of them to run, and on what terms. Muse Glimmer 30B, released by Meta on 10 August 2026, is a strong answer on the terms part and a mixed one on capability.

It is a distilled, open-weight counterpart to Meta's closed Muse Spark model, published under Apache 2.0. That licence is the first thing to understand, because it is a break from how Meta used to ship models.

What Meta actually released

The release is more than one checkpoint. Under Apache 2.0, Meta published the full-precision weights, two quantised versions, a speculative-decoding drafter and the perception encoder used for images. The training data and training code remain private.

Apache 2.0 has none of the monthly-active-user ceiling that the old Llama community licence carried. You can fine-tune it, embed it in a product and redistribute it. For teams that stayed away from Meta's earlier models because of licence review, that alone puts Glimmer back on the list. That is a meaningful difference from the custom licences common in this tier.

Dense 30B and the 24GB question

Glimmer is dense, not a mixture of experts, so every parameter is active on every token. The total is about 29.6B, made up of a roughly 28B text decoder and a roughly 1.8B vision encoder, across 52 layers that mix sliding-window and full attention with grouped-query attention. It accepts text and images, produces text, and OpenRouter lists a 131,072-token context window.

Memory decides where it runs:

• Full precision needs more than 55GB.
• Meta's dynamic quantisation targets 32GB of VRAM and reports an average accuracy loss of 0.2% across 15 benchmarks.
• The 17GB quantisation targets 24GB cards with a reported 1.0% average loss.

So a 24GB GPU or a 32GB-plus Apple Silicon machine is the realistic floor. An 8GB or 16GB laptop is out. Leave headroom for the KV cache, which grows with context; a 131K window is not free on a card that is already mostly full of weights. Best model for self-hosting works through that sizing in general.

The drafter is half the story

Dense models are slow to decode locally because every token touches every weight. Meta's answer is a drafter that proposes blocks of 16 tokens for the main model to verify in parallel; output is identical to normal generation. Meta's launch figures report decode on an RTX 5090 under llama.cpp rising from 74.9 to about 233 tokens per second, and smaller gains on M-series Macs. An independent run reported by The Register measured about 12 tokens per second on a DGX Spark without the drafter.

The gap between those numbers is the point. Without speculative decoding, Glimmer is usable; with it, on the right hardware, an agent loop feels responsive. Check that your serving stack supports the drafter before judging the model on speed, and measure on your own prompts: speculative speed-ups depend on how often the main model accepts the drafted tokens.

Where it beats Qwen 3.6 27B, and where it does not

The natural rival is Qwen 3.6 27B, a dense model of similar size. Meta's launch table, which is vendor-run and not independently verified, splits cleanly:

• MCP Atlas (agentic tool use): Glimmer 75.5, Qwen 3.6 27B 62.5, Gemma 4 31B 54.2
• AA-LCR (long-context reasoning): Glimmer 80.0, Qwen 73.3, Gemma 68.3
• SWE-Bench Verified: Glimmer 76.0, Qwen 77.2
• Terminal-Bench 2.1: Glimmer 51.7, Qwen 60.7
• OSWorld-Verified (computer use): Glimmer 65.9, Qwen 75.6

Meta also reports 51.2 on SWE-Bench Pro and 94.7 on AIME 2026. The reading: Glimmer is the better tool caller and long-document reader; Qwen is the better terminal and computer-use agent. For a local coding agent that lives in a shell, Qwen's lead on Terminal-Bench is the more relevant row. For an assistant that orchestrates many MCP tools over long documents, Glimmer's is.

Meta's own security numbers deserve a look too. On an AgentDojo prompt-injection test, attacks succeeded 28.4% of the time against Glimmer and 25.6% against Gemma 4, and Glimmer leaked more on a privacy test. A local agent with tool access needs guards regardless of which model you choose.

Distilled from a closed model

Glimmer was trained with logit distillation from Muse Spark, followed by agent-focused mid-training, supervised fine-tuning, on-policy distillation and reinforcement learning. In practice that means a small model shaped by a large one's output distribution, which tends to transfer style and tool habits well and deep knowledge less well. Meta has said Spark 1.2 weights would follow; until they do, the larger Muse Spark 1.2 is a hosted model and Glimmer is the open one.

The catalogue lists reasoning-effort control, so you can trade depth for latency per request. Provider support for that control varies, so check your host's documentation. On OpenRouter it is listed at $0.30 per million input tokens and $1.20 output at the time of writing, which is a reasonable way to test it before buying hardware.

Choosing between the local options

• Pick Glimmer for tool-heavy agents, long-document work and image input, when an Apache 2.0 licence matters.
• Pick Qwen 3.6 27B for terminal-driven coding agents and computer use.
• Look at Gemma 4 31B if science question answering or a lower prompt-injection rate is the priority.

Then run your own ten agent tasks on each, quantised the way you will actually deploy them. A 1% average quantisation loss can hide a much larger loss on the one capability you need.