What Meta actually shipped
- A 30B agent model under Apache 2.0 — released 10 August 2026, weights on Hugging Face at
meta-models/Muse-Glimmer-30B. Apache 2.0 is an OSI-approved permissive licence, a different legal object from the Llama community licences Meta shipped previously. - Built for agent work, not chat — multimodal input through a dedicated perception encoder, tool use and function calling, multi-step reasoning with failure recovery, 100-plus languages, variable reasoning-effort levels.
- Quantised to roughly 4-bit — the K-Quant-17GB variant keeps weights under 20 GB, with minimal to no degradation on agentic tasks by Meta's own account.
- DFlash speculative decoding — 3.1x on an RTX 5090, 1.8x on an M5 Max, 1.5x on an M4 Max.
- No published context window — for an agent model, the most consequential missing number in the release.
The number that matters is 24 to 32 GB, not 30B
Parameter counts have stopped being interesting on their own. What determines whether a model changes your architecture is whether it fits in memory you already control — and the marketing-friendly figure and the operational figure are not the same.
At full precision the model needs over 55 GB: a multi-GPU box, and no laptop in normal circulation. Quantised to approximately 4-bit, the K-Quant-17GB build keeps the weights under 20 GB. But weights are not the whole residency. You also need the KV cache, which for an agent accumulating tool results across a long trajectory is no rounding error; the perception encoder, resident if you want the multimodal input the model advertises; and the DFlash drafter. The realistic envelope is 24 to 32 GB.
| Variant | Weights | Realistic total envelope | Hardware that fits |
|---|---|---|---|
| Full precision | Over 55 GB | Over 55 GB plus runtime overhead | Multi-GPU server or a very large workstation |
| K-Quant-Dynamic | Approximately 4-bit; no single size figure published | Falls between the other two rows | Size it yourself — Meta has not published the figure |
| K-Quant-17GB | Under 20 GB | 24–32 GB with KV cache, perception encoder and drafter | 24 GB-plus discrete GPU, or a 32 GB unified-memory Mac |
Meta's claim across those variants is minimal to no degradation on agentic tasks. That is stronger than it sounds, because quantisation damage surfaces in exactly the places agents live: instruction adherence over many turns, structured output that has to parse, tool-argument precision. It is also a claim made by the party with the most to gain from it. Treat it as a starting hypothesis and verify it on your own traces — our guide to picking and quantising a small model for on-device use covers the measurement discipline, and the method applies at 30B.
What "runs on a laptop" actually means
It means a well-specified laptop, and it is worth being blunt rather than letting the phrase do unearned work. A 32 GB unified-memory Mac clears the bar. A 16 GB machine — still the modal developer laptop in offices in Bengaluru and London alike — does not. On the PC side you need 24 GB or more of discrete GPU memory: a workstation card, not a thin-and-light. If your fleet is standard-issue 16 GB corporate hardware, running Muse Glimmer locally is a procurement decision, not a download.
Do not size your deployment on the 17 GB weight figure. The KV cache grows with trajectory length, and agent trajectories are long by definition — a loop that reads a file, calls three tools, fails once and retries holds far more state than a single-turn chat. Budget the 24 to 32 GB envelope, then measure your own worst case before promising anyone it fits.
The licence is the second story, and it is not a small one
Precision matters here. The correct general term for what Meta has published is open-weight: you get the weights, not the training data or the pipeline. But on the licence itself, Apache 2.0 is an OSI-approved permissive open-source licence, and applying it to weights is materially different from what Meta did with the Llama family. When we covered Llama 4's open-weight multimodal release, the weights carried a community licence with an acceptable-use policy and a monthly-active-user threshold above which you needed a separate agreement from Meta. Apache 2.0 carries none of that, and no clause that turns your success into a renegotiation.
For anyone who has taken a model choice through legal review, that difference is the whole conversation. Apache 2.0 means the review takes an afternoon, and the model can be redistributed inside your own product, shipped in a container to a customer, or forked and fine-tuned without a downstream permission question.
This is Meta shipping in two directions at once. Muse Glimmer arrives with permissive weights while Muse Spark 1.1, which we covered as Meta's first paid model API, continues as a commercial product — and Mark Zuckerberg has said Meta will open the weights for Muse Spark 1.2 as well, per Meta's launch announcements. Charge for the frontier tier, give away the tier that seeds an ecosystem.
DFlash: why the speed-ups vary so much by hardware
DFlash is Meta's speculative-decoding implementation. A lightweight drafter model proposes entire blocks of tokens at once, and the main model verifies those proposals in parallel rather than generating one token at a time. When the drafter is right you get several tokens for roughly the cost of verifying one; when it is wrong you discard the rejected block and continue. Correctness is preserved either way. Our explainer on speculative decoding covers the acceptance-rate mechanics.
The reported numbers are 3.1x on an RTX 5090, 1.8x on an M5 Max and 1.5x on an M4 Max. That spread is not noise. Speculative decoding converts a memory-bandwidth-bound problem into a compute-bound one — spending arithmetic on parallel verification to avoid repeated weight reads. A discrete GPU with large headroom between compute throughput and memory bandwidth has that arithmetic going spare; Apple's unified-memory parts have a different balance and the returns are thinner. Budget your latency against your actual silicon, not the best number in the table.
The drafter has to be resident too, so DFlash trades memory for speed. On a 24 GB card already close to its limit with the K-Quant-17GB weights and a long KV cache, enabling speculative decoding can push you into paging and end up slower. Measure end-to-end tokens per second at your real trajectory lengths, not on a short prompt — the crossover point moves with context length.
The benchmark table is Meta's own
Meta says Muse Glimmer performs strongly against Gemma4-31B and Qwen3.6-27B, and highlights DeepSearch QA, MCP-Atlas, τ-Bench and SWE-Bench, though it published comparison figures for only some of them. Per Meta's published comparison table, as reported in launch coverage, the model scores 75.5 on MCP Atlas, 74.6 on DeepSearch QA and 51.2 on SWE-Bench Pro, against 36.9 for Gemma4-31B and 50.2 for Qwen3.6-27B. We have not independently verified any of those figures, and at the time of writing neither has anyone else.
| Benchmark (Meta-reported) | Muse Glimmer 30B | Gemma4-31B | Qwen3.6-27B |
|---|---|---|---|
| MCP Atlas | 75.5 | Not published in the table | Not published in the table |
| DeepSearch QA | 74.6 | Not published in the table | Not published in the table |
| SWE-Bench Pro | 51.2 | 36.9 | 50.2 |
Read the SWE-Bench Pro line carefully, because it is the most honest thing in the release. A 1.0-point margin over Qwen3.6-27B is not a lead; it is a tie with better presentation. The 14-point gap over Gemma4-31B is real if the numbers hold, but the model Meta needs to beat is the one a point behind it — and we have already covered Qwen 3.6 27B running frontier-grade coding on a single 24 GB GPU. Muse Glimmer's advantage over that incumbent is not the score. It is the licence, the perception encoder and DFlash.
Every article here is written by a Verified Builder. Want your name on the next one?
AI Tech Connect lists AI engineers, founders and researchers across India and the UK — and the people hiring browse it to find them. Adding your profile is free.
Become a Verified Builder →Where a 30B local model genuinely wins
High-volume cheap loops, and the unit economics of a foreign-currency bill
Agent loops are not one call. A single user-facing task might fan out into forty model invocations — plan, select tool, parse result, decide, retry, summarise — most of them individually trivial. Paying frontier-API rates for the trivial 90% is how agent products end up with negative gross margin. Move that 90% local and the marginal cost of a call goes to roughly zero above fixed hardware cost.
That maths lands differently depending on where you sit. A Bengaluru team billing a domestic customer in rupees while paying for API calls in dollars carries a currency mismatch on every invocation, and the exchange rate is not a line item it controls. A one-off 24 GB card converts an unbounded dollar-denominated variable cost into a fixed rupee-denominated one — a better shape for anyone who has to forecast, and the same holds from São Paulo to Lagos. Our framework for deciding between self-hosting and an API sets out the break-even calculation.
Privacy-bound and data-residency workloads
The second win is regulatory, and it is the cleanest because it does not depend on any benchmark being right. A UK team processing personal data under UK GDPR has a transfer question the moment inference leaves its own infrastructure: where does the processor sit, what is the transfer mechanism, what does the DPA say, who signs off. On-prem inference does not answer that question — it deletes it. The data never leaves, so there is no transfer to assess.
The same structure applies to Indian teams under the DPDP framework, to client material held under an NDA that forbids third-party processing, and to the large body of enterprise work where the blocker was never regulation but a security team that will not approve an egress path. Apache 2.0 matters here, because it lets you ship the model into a customer's own environment without a licensing conversation.
Offline, edge and unreliable-connectivity work
The third win is the least fashionable and the most durable. Field engineering, ships, factory floors, rural deployment — anywhere a site survey involves the phrase "intermittent connectivity" — cannot depend on a round trip to a data centre. The planned ExecuTorch integration points squarely at this class of deployment, alongside llama.cpp, MLX, vLLM and SGLang. Those integrations are the difference between weights and a usable runtime: as we noted when llama.cpp became a genuine agent harness, the tooling around local models has matured faster than the models this year.
"The interesting question is never whether the local model is as good. It is which fraction of your calls actually need the good model. We found it was about one in twelve — everything else was routing, extraction and short summaries that a 30B handles fine. The router was two days of work and it took the API bill down by an order of magnitude."
— Prem Kumar Kora, Verified Builder · Chennai, IndiaWhere it will still lose to a frontier API
Being honest about this is what makes the case above credible. Four places where a 30B local model will disappoint you.
Long-horizon reasoning. Multi-step plans that hold a goal stable over dozens of turns and recover from compounding errors remain the clearest capability gap between model tiers. Meta's failure-recovery claim is welcome but unquantified, and failure recovery is precisely the behaviour that degrades first under quantisation.
The hardest coding tasks. A 51.2 on SWE-Bench Pro means roughly half the tasks are not solved. For routine refactors that is fine. For the gnarly tail — the ones your senior engineers escalate to each other — it is not, and no amount of reasoning-effort tuning closes a gap of that size.
Anything needing a large context. Meta has not published a context window. We are not going to guess at one, and neither should you: measure it on your own traces, and treat any workload depending on a large window as unsupported until Meta publishes a figure. For an agent model whose context grows with every tool result, this is the most awkward omission in the release.
Peak-load serving. An API absorbs your traffic spikes; a GPU under your desk does not. The moment you need concurrency you are running a serving stack with batching and queueing, and that operational cost is work the API price was quietly paying for.
What to do this week
The useful next step is not to migrate anything. It is to instrument what you already have and count what fraction of your model calls are genuinely hard. Most teams have never measured this and are consistently surprised — the trivial calls dominate, and they are the ones paying frontier rates. From there the pattern that works is a router, not a replacement: keep the frontier API as the escalation path, send the easy majority local, set an explicit quality gate on the boundary. Pull the K-Quant-17GB build, run it against your own recorded trajectories rather than a public benchmark, and check the two failure modes that actually break agents — malformed tool arguments and instruction drift over long turns. If Meta's minimal-degradation claim holds on your traces, you have a real architectural option. If not, you learned that in an afternoon and lost nothing but the download.
What Muse Glimmer changes is not the state of the art. It is the licence, the memory envelope, and the fact that both landed in the same release. A permissively licensed agent model that fits on hardware a team already owns removes two separate blockers at once, and that combination is rarer than either half.