On 10 August 2026, Meta Superintelligence Labs put the weights of a 30-billion-parameter agentic model on Hugging Face under Apache 2.0. The model is called Muse Glimmer, and the interesting number is not the parameter count. It is 17 GB.

That is the size of the quantized variant the team ships for people who want the whole stack, language model plus image encoder plus speculative decoding drafter, to sit inside a single consumer GPU. At full precision the same model needs more than 55 GB, which puts it out of reach of every card a normal developer owns. Compressed to roughly 4-bit, the language model drops under 20 GB, and the 17 GB build leaves room for everything else that has to live in VRAM at the same time.

The release covers open weights, developer docs and quantized builds aimed at 24 GB and 32 GB machines.

Muse Glimmer is a distillation of the larger Muse Spark. Pre-training used logit distillation against the teacher's outputs on a similar data mix; mid-training pushed longer contexts and agent-heavy traces; post-training mixed supervised fine-tuning with on-policy distillation and reinforcement learning across general, reasoning, coding and agentic tasks. It takes interleaved text and images through a dedicated perception encoder, covers more than 100 languages, exposes a controllable effort setting so you can trade quality for latency, and is meant to drop into existing orchestration scaffolds rather than demand its own.

The memory budget nobody plans for

Every team that tries local inference for the first time makes the same mistake. They look up the quantized weight file size, compare it to their VRAM, see headroom, and start writing code. Then the agent runs a twelve-turn tool loop with a screenshot in the context and the whole thing either spills into system memory or dies.

Weights are only one line in the budget. The KV cache grows with context length and it grows fast in agent workloads, because agents accumulate tool output rather than discarding it. A perception encoder for image understanding is a second resident model. A speculative decoding drafter is a third. Muse Glimmer's release includes quantized drafter builds specifically to keep that overhead small, which tells you the team hit the same ceiling everyone else does.

Three quantization targets, each aimed at a different memory envelope, with measured degradation on agentic tasks.

We plan this the boring way now: budget weights, then multiply your worst-case context by your KV cache cost per token, then add the encoder and drafter, then leave 15 percent slack. If the sum exceeds your card, either cap context in the scaffold or move to the smaller quant. Discovering this in production, with an agent that only fails on long sessions, is a bad afternoon.

The speedup depends on your machine, not the technique

Muse Glimmer ships with a drafter based on DFlash. Instead of producing one token per forward pass, the small companion network proposes a block of tokens and the main model verifies them in parallel, keeping what is correct and fixing what is not. Output quality is unchanged. Only the wall clock moves.

How much it moves varies more than most people expect. Measured with the 17 GB quant and the quantized drafter, the gain is about 3.1x on an RTX 5090, 1.8x on an M5 Max and 1.5x on an M4 Max.

Same model, same drafter, three machines, three very different payoffs.

The spread is not noise. Speculative decoding trades compute for memory traffic: you verify several candidate tokens in a single pass, so the technique rewards hardware with spare arithmetic throughput relative to its bandwidth. A discrete card with 1,792 GB/s of GDDR7 and a large compute budget has that spare capacity. Unified-memory laptops have a flatter ratio, so verification eats into the gain. If you are sizing a fleet, benchmark on the machine your users actually have. A vendor's 3x is somebody else's 1.5x.

Reading the benchmark table honestly

The comparison set is Gemma4-31B and Qwen3.6-27B, and the tasks span agentic completion, coding, multimodal, reasoning and safety. End-to-end suites include DeepSearch QA, MCP-Atlas, 𝛕-Bench and SWE-Bench.

Size-class comparison across the capability groups an agent actually needs.

Take the scores as directional. In our experience the number that predicts whether an agent survives a real workday is none of these: it is recovery behaviour. A model that gets a tool schema slightly wrong and then diagnoses the error message and retries beats a model with two points more on a coding benchmark that stops dead on a 422 response. Muse Glimmer is explicitly trained for that retry loop, and it is worth building your own harness around your own tools to check whether the training held. Ten of your real API calls, half of them deliberately returning malformed payloads, will tell you more than any leaderboard.

Why a local agent is worth the trouble here

Cloud inference is cheap per token until it is not. An always-on agent that watches a folder, drafts replies and reconciles records makes thousands of calls a day, most of them boring. Push that to a hosted endpoint from Accra and you pay three times: for tokens, for the round trip to a data centre several hundred milliseconds away, and in reliability whenever the link to your provider degrades. We have watched a working prototype become unusable for a week for exactly that third reason.

The hardware maths is less rosy than the model release implies. An RTX 5090 carries a $1,999 list price and has been trading far above it through 2026, in the $4,300 to $5,000 range in several markets, which is real money for a small studio. A used 24 GB card in the $800 to $1,000 band is the pragmatic entry point, and it is precisely the envelope the smaller quantized build targets. Amortised over a year of continuous agent traffic, one card still beats a metered endpoint for the same workload, and the client data never leaves the office.

The wider point is that the local tier now has a proper option. Weights under Apache 2.0 mean you can fine-tune with something like TorchTitan and ship the result inside a product without a licence conversation. Serving paths run from llama.cpp, MLX and ExecuTorch on device up to vLLM and SGLang on a server, with the usual hosted providers if you want to prototype before buying silicon.

Our next step is unglamorous: wire the 17 GB build into an existing scaffold behind the same interface we use for hosted models, run a fortnight of production traffic through both, and compare completion rate, median latency and cost per resolved task. If the local path holds within a few points on completion while cutting the per-task bill, the default flips, and a lot of architecture diagrams get simpler.