Muse Glimmer and the 30B Open-Weights Ceiling

Roughly 30 billion parameters of Meta's newest model are sitting on Hugging Face under an Apache 2.0 licence, free to download, with no waitlist and no key to request. Meta AI announced Muse Glimmer and published the weights on the same day, August 10, 2026, positioning the model for local use on consumer GPUs. The demos are agent tasks run end to end on the machine in front of you, including one in which the agent discovers a Home Assistant instance on a home network and builds dashboards against it.

Nothing about the download is gated. Apache 2.0 is the permissive end of the open-weights range, and the model is sized to start on a card most people bought for something other than running a language model.

The arrangement behind that generosity runs across most of this summer's open releases. A lab measures the VRAM already sitting in machines people own, builds a model that fits inside it, publishes those weights on announcement day, and keeps the rung above them on a metered endpoint. Each release arrives as its own piece of good news. Sorted by the hardware they target rather than by the lab that shipped them, they line up.

30B, and the five open releases before it in the same memory class

Dates below are when each model entered our directory, which tracks the announcement within a day or two.

• Cohere North Mini Code, June 15. Apache 2.0, 30B total with 3B active in a mixture-of-experts layout, 256K context, built for agentic coding.
• PrismML Bonsai 27B, July 15. Apache 2.0, 27B multimodal, shipped with ternary and 1-bit variants explicitly so it runs on a phone or a laptop.
• Thinking Machines Inkling Small, July 31. 276B MoE with 12B active and a 1M-token context. Large on paper, sized on the active path.
• Mistral Shieldstral, August 5. A 3B Apache 2.0 multimodal safety classifier whose headline spec is that it self-hosts on one 16GB GPU.
• Liquid AI LFM2.5, August 6. 2.6B open weights for on-device agents, with tool calling and no hosted API at all.
• Meta Muse Glimmer, August 10. 30B, Apache 2.0, consumer GPUs, local agent loops.

Meta's own ladder makes the division explicit. Muse Spark 1.1 shipped with a paid model API in July, and Spark 1.2 carries a $0.10 per million input and $0.20 per million output tier that is priced on the condition that Meta trains on the code you send it, as we covered at the time. The discount is the data trade. Glimmer is the one you download instead, and the pricing question in the headline has a short answer: nothing, plus whatever your electricity and your GPU cost you.

2.8T of open weights, published in July

The strongest case against all of this is that the open frontier has no ceiling on it whatsoever, and the evidence is recent. Moonshot published weights for Kimi K3, a 2.8-trillion-parameter mixture-of-experts model, in July, and it went out framed as a challenge to the closed frontier rather than as a companion to a paid tier. Alibaba has pledged open weights for the Qwen 3.8 line, which runs to 2.4T, though our own entry still records that release as announced and not yet confirmed. On the same reading, the small releases are demand-driven rather than defensive: most people asking for open weights want something they can start tonight, and a 30B model that runs on the card already in the machine is worth more to them than a 2.8T model they will never host.

That case is right about who is publishing large weights, and it explains the size choice as service rather than strategy. It also skips what the two groups do not have in common. The labs publishing at trillion scale are not selling a per-token API to Western developers as their core business, so the weights they release do not undercut a price list. The labs shipping the 27B-to-30B class, Meta and Mistral and Cohere among them, all sell a hosted tier, and the model they open is consistently one or two rungs below it. A consumer-card size target is a decision about what customers are allowed to own outright, taken by the party that also sells them the rung above.

Three consequences, heaviest first

The heaviest one is that your local capability ceiling is now set by someone's product ladder rather than by your hardware budget. Buying a second GPU does not raise it, because there is no next-tier open model from the same labs to put on the extra memory. You can spend your way to more speed and more context, not to a better model, unless you switch to a Chinese frontier release and accept the hosting problem that comes with it.

Second, the privacy property that makes local agents worth the trouble holds only inside the chosen tier. Glimmer's demos are exactly the sensitive case: an agent with access to your home network, your devices, your files. Any task the 30B tier cannot complete gets routed to a hosted model, and your data leaves the machine at that moment. The boundary of the guarantee is the boundary of the model's competence, and a lab sets that boundary.

Third, and lightest, launch coverage compares the wrong things. A 30B local release gets measured against frontier APIs in the first wave of writeups, where it will lose in ways that predict nothing about how it performs on the job it was built for. The comparison worth having is Glimmer against North Mini Code and Bonsai 27B on tool-calling reliability across long agent loops. Look for that head-to-head before you take the agentic framing on trust.

4 bits per parameter, and what still will not fit

The standard answer to everything above is that the ceiling is temporary. Quantization keeps improving, sparse architectures keep cutting the active parameter count, and hosted open-weight endpoints cover whatever your desk cannot. All three are weaker than they sound.

Half a byte per parameter puts a trillion-parameter model in the hundreds of gigabytes of weights alone, which is an order of magnitude past any desktop, and 4-bit is already the aggressive end of what preserves quality. Sparsity cuts compute per token rather than resident memory: Inkling Small activates 12B, and you still have to hold all 276B somewhere. Hosted endpoints solve the memory problem by handing back the two things local inference was chosen to avoid, a metered bill and a network hop with your data on it.

What you can act on today is smaller and more concrete. Glimmer's weights are on Hugging Face under Apache 2.0, and per the Apache Software Foundation's licence text that permits commercial use and redistribution if you keep the notice. Ollama and LM Studio will both pull a quantized build onto a machine you already have, and Osaurus covers Apple Silicon through MLX. Check your card's VRAM before you download anything, because a 30B model at 4 bits is about 15GB of weights before you add context and overhead, and that single number decides whether the thing starts.