Meta's Superintelligence Labs released a 30-billion-parameter model called Muse Glimmer on August 10, 2026. The pitch is simple: it is built specifically for agents that run on your own machine, not theirs. Apache 2.0 license, weights on Hugging Face, and it fits in about 17GB of memory when quantized. That means a single 24GB consumer GPU or a recent MacBook can run it.
This is not another general-purpose chatbot. Meta trained it for agentic work specifically: function calling, multi-step reasoning, failure recovery, tool use across long workflows. The kind of thing you want when an agent is managing a schedule, debugging code, or pulling data from APIs on your behalf. And they trained it to fail better than most models, which is the part I find interesting.
What it actually is
Muse Glimmer is a 30B parameter model distilled from a larger model called Muse Spark using logit distillation. That is a specific technique: instead of just fine-tuning on Muse Spark's outputs, they trained Glimmer to match the probability distribution that Muse Spark assigned to each token at each step of generation. It is closer to copying the teacher's reasoning process than its answers.
Training happened in three phases. Pre-training used Muse Spark's logits over a similar data mix. Mid-training shifted to longer contexts with more agent-heavy reasoning traces alongside organic text. Post-training combined supervised fine-tuning with on-policy distillation and reinforcement learning across reasoning, coding, and agentic domains. That last part matters: RL on agent tasks is where a lot of current frontier model training is tight-lipped, and getting it right on a 30B model instead of a 671B one is harder, not easier.
The model accepts interleaved text and images through a dedicated perception encoder. So it can look at screenshots, charts, and documents, not just text. It also supports controllable reasoning effort, meaning you can dial the thinking depth up or down depending on whether you need speed or quality for a given task.
Performance vs. Gemma4-31B and Qwen3.6-27B
Meta benchmarked Muse Glimmer against Gemma4-31B and Qwen3.6-27B, the two strongest models in its weight class. The evaluation covers agentic task completion (DeepSearch QA, MCP-Atlas, tau-Bench, and SWE-Bench), tool use reliability, multi-step reasoning, and multimodal understanding. They also include safety and reasoning benchmarks to show the model is not ahead by skipping guardrails.
The blog post shows a comparison table, but it is an image so I cannot extract exact numbers from it here. Meta says the model "performs strongly for its size class." That is PR language for "competitive, sometimes ahead, sometimes behind." I would not take any single benchmark table as proof of superiority, especially when the publisher is also the one who ran the evaluation. The methodology report is linked on their page for people who want to check the setup.
What I can say: being in the same conversation as Gemma4-31B and Qwen3.6-27B on agent tasks at all is a reasonable claim for a model trained specifically for agentic use. General-purpose models have to spread their capacity across everything. A model that spends its training budget on function calling and multi-step recovery should win on those specific dimensions if the training worked. Whether it actually does in the wild is something we will find out from people deploying it over the next few weeks.
The two tricks that make it fit on consumer hardware
A 30B model at full precision needs over 55GB of memory. No consumer GPU has that. Meta applied two optimizations to make it practical.
The first is quantization. They use a technique called K-Quant-Dynamic to compress the model to roughly 4-bit precision, shrinking it to about 17GB. That leaves enough headroom for the KV cache, the image perception encoder, and the speculative decoding drafter to all live alongside the model within a 24GB or 32GB envelope. Meta validated this compression introduces minimal to no degradation on agentic tasks. That is a strong claim worth testing independently, but at the very least it means they did not just slap 4-bit quantization on as an afterthought.
The second is speculative decoding using a method called DFlash. The idea: instead of generating one token at a time, a small companion model proposes entire blocks of tokens. The main model verifies them in parallel, accepting the ones that are correct and correcting the ones that are not. The output quality is identical to standard generation, but the speed is significantly higher.
The speedup gap between NVIDIA and Apple Silicon is notable. A 3.1x speedup on an RTX 5090 versus 1.5x on an M4 Max suggests that speculative decoding benefits a lot from parallel verification throughput, which is what NVIDIA GPUs are built for. On Apple Silicon, the unified memory helps you fit the model, but the verification step is apparently less efficient. If you are picking hardware for local agents, that is a real performance difference, not just a marketing talking point.
Failure recovery is the part I keep thinking about
Most local models I have tried are bad at failing. They hit an error, produce garbage, or hand you the wrong output and move on as if nothing happened. Muse Glimmer was specifically trained for what Meta calls "failure recovery": when a tool call fails or returns an unexpected result, the model diagnoses the error and retries instead of halting.
This sounds small. It is not. Agent reliability is where local agents fall apart in practice. An agent that can make ten correct calls in a row but freezes on call eleven is useless for real work. An agent that makes eight correct calls, flubs the ninth, recognizes it flubbed the ninth, and fixes it before moving on is useful. The distance between those two is the distance between a demo and a product.
Whether Meta actually pulled this off at 30B scale is an open question. But the fact that they named it as a specific capability and trained for it tells me they understand where agent tooling actually falls apart. That is more than I can say for most model releases, which treat error handling as a scaffolding problem rather than a model problem.
Where to run it
Meta is working with the usual local inference stack. Optimized integrations for llama.cpp, MLX, and ExecuTorch are landing in the coming days. Ollama, LM Studio, and Unsloth are on the list for convenience installs. If you want to serve it at scale instead of running it locally, vLLM and SGLang are supported. Cloud partners like Together AI, Fireworks AI, and OpenRouter will also host it if you do not want to run it yourself.
For local deployment on Apple Silicon, MLX is the path. For NVIDIA GPUs, llama.cpp or direct CUDA with vLLM. For edge and mobile, ExecuTorch is the framework to watch. AMD, Arm, Dell, Intel, and NVIDIA are all listed as optimization partners, so expect platform-specific tweaks over the coming weeks.
The Zuckerberg context
This release did not happen in a vacuum. On the same day, Mark Zuckerberg gave a statement to the Financial Times attacking Meta's "closed" AI rivals and announcing Meta's return to open models. The framing is not subtle: Meta wants the developer community to treat Glimmer as proof that Meta is the open AI champion while companies like OpenAI and Anthropic keep their best models behind APIs.
I am skeptical of that framing because it is convenient. Every major tech company that opens a model also has a cloud API and an ad business and a data play. Open weights and open business practices are different things. But I am also not going to pretend the weights do not matter. A 30B model with Apache 2.0 licensing, multimodal input, agentic training, and speculative decoding that runs on a single GPU is a genuine contribution to the open ecosystem regardless of who released it.
What I am not sure about
Here is my honest read. Muse Glimmer looks well-designed for its stated purpose. The distillation recipe, the speculative decoding, and the failure recovery training all target real pain points in agent workflows. But I have a few reservations.
First, the benchmarks are in an image I cannot read in detail. Meta says "performs strongly against Gemma4-31B and Qwen3.6-27B" but does not publish the exact numbers in text form in the blog post. Their methodology report presumably has them, but the blog itself is vague enough that I cannot tell you if Glimmer wins on tau-Bench by 2 points or 15. Independent benchmarking will clarify this.
Second, 30B is still a big model by local standards. 17GB of quantized weights means a 24GB GPU is the minimum realistic target, or a Mac with 32GB+ of unified memory. That is not a Raspberry Pi story. It is a "decent desktop or laptop" story. The people who will get the most out of Glimmer right away are the ones already running 8B to 13B models locally, who have the hardware but now get a much more capable agent model in the same footprint.
Third, the distillation from Muse Spark raises a question Meta did not address in the blog post. Distillation can transfer capabilities, but it can also transfer biases, blind spots, and failure modes from the teacher. If Muse Spark is bad at a specific kind of reasoning, Glimmer may have inherited that weakness even if the benchmarks that Meta chose to evaluate did not surface it. This is not a criticism unique to Meta. It is the general problem with distilled models. But it is worth keeping in mind when you compare Glimmer to a model that was trained from scratch.
I also cannot help noticing that the DFlash speculative decoding speedup numbers are better on NVIDIA than Apple by a wide margin. If your primary device is a MacBook, the headline "runs on a Mac" is true, but the experience may be meaningfully slower than the benchmarks imply. Check real-world reports from MacBook users before buying hardware based on these numbers.
Bottom line
If you are already running local models and you want something explicitly built for agent workflows instead of chat, Muse Glimmer is the most interesting open weight release in that size class this year. The Apache 2.0 license means you can use it commercially without negotiating terms. The tool ecosystem support means you can likely be running it within an hour of clicking download.
If you are not already set up for local inference, this is not your entry point. Get comfortable with a 7B or 8B model first, figure out if your hardware and workflow suit local agents, then move up. Glimmer is a strong option in a specific niche for a specific audience.
I will be watching the independent benchmarks when they land. Until then, treat the performance claims with appropriate caution and the open weights with appropriate enthusiasm.