Meta's Muse Glimmer Runs a 30B Agent Model on Your GPU

Meta Superintelligence Labs has published the technical report and Apache 2.0-licensed weights for Muse Glimmer, a 30-billion-parameter model designed for long-running agent workflows on workstation-class hardware. It targets developers who need local tool use, coding, multimodal input, and long context without sending every prompt or tool result to a cloud API.

Quantization brings 30B within 24 GB

A 30B model stored with 16-bit weights requires about 60 GB, or 55.9 GiB, before accounting for the key-value cache and other runtime allocations. Meta uses roughly 4-bit weight quantization to reduce Glimmer’s reported model footprint to less than 20 GB, making deployment possible on a 24 GB GPU or a Mac with sufficient unified memory.

Meta reports a 1.0% degradation from quantization, although that figure depends on the evaluation metric and calibration data. The release includes BF16 weights for higher-precision deployment, GGUF k-quants for common local runtimes, and ExecuTorch builds for supported devices.

A sub-20 GB weight file does not guarantee access to the full 120K-plus context window on a 24 GB GPU. Long prompts expand the key-value cache, while the runtime, vision encoder, tool harness, and speculative decoder consume additional memory. Developers should measure the usable context length with their selected quantization, batch size, and inference engine.

DFlash cuts latency inside tool loops

Agent loops amplify autoregressive decoding costs because the model repeatedly generates reasoning tokens, structured arguments, and follow-up actions. Glimmer’s DFlash companion model uses speculative decoding to propose blocks of tokens. The main model verifies those proposals in parallel, accepts valid tokens, and replaces rejected ones.

Actual throughput will vary with prompt length, output length, quantization, drafter acceptance rate, runtime, and memory bandwidth. Agent latency also includes tool execution, prompt processing, and repeated prefill work, so token generation speed represents one part of end-to-end performance.

Muse Spark supplies the training signal

Meta distilled Glimmer from Muse Spark, its larger proprietary model, through pre-training, mid-training, and post-training stages. During logit distillation, the student learns from the teacher’s probability distribution over possible next tokens. That distribution carries more information than training solely on the teacher’s selected output.

Mid-training used long-context sequences with reasoning traces, interleaved text and images, and multi-step tool trajectories. Post-training added supervised fine-tuning, reinforcement learning, agent-focused data, and on-policy distillation. In the on-policy stage, Glimmer generates trajectories from its current behavior and receives teacher supervision on those examples, keeping training closer to the states it encounters during deployment.

The clearest comparison is MCP Atlas

Meta evaluates Glimmer in thinking mode on benchmarks centered on tool use, research, general agent tasks, and software engineering. The published table provides a complete three-model comparison for MCP Atlas; competitor results are absent from the other listed rows.

Glimmer leads the reported MCP Atlas comparison by 13 points over Qwen3.6-27B and 21.3 points over Gemma4-31B. The remaining scores show Glimmer’s reported performance on each benchmark but do not establish a cross-model ranking. Production evaluations should reproduce the prompting, tool definitions, inference settings, and completion criteria used in the report.

Local, private agents are the main fit

Meta tuned Glimmer for long-horizon reasoning, structured tool calls, failure recovery, coding, and multimodal reasoning. The company also reports support for more than 100 languages and compatibility with agent frameworks such as OpenClaw.

• Repository agents: Inspect code, edit files, run tests, and iterate on failures without uploading a private codebase.
• Multimodal assistants: Process screenshots, diagrams, and video frames alongside text and tool results.
• Private automation: Work with personal files, internal documents, or local services under an organization’s own access controls.
• Offline workflows: Continue operating in disconnected or restricted environments.
• Evaluation systems: Run local model-as-judge pipelines with predictable infrastructure costs.

Glimmer uses a dense architecture, so every decoder parameter participates in each forward pass. That layout avoids expert-routing machinery and can make latency and memory behavior easier to predict on one device. It also requires computation across the full decoder for every generated token.

Apache 2.0 simplifies commercial use

The Apache 2.0 license permits commercial use, modification, and redistribution, includes an express patent grant, and requires preservation of applicable notices. Meta previously released Llama weights under custom community terms and kept Muse Spark proprietary, so Glimmer gives deployers a more familiar legal foundation for products and internal systems.

Deployers remain responsible for third-party components, training-data concerns, runtime licenses, model outputs, and regulations that apply to their use case. The model license also does not replace security controls around tools, credentials, file access, or generated code.

Local inference shifts the engineering trade-offs

Glimmer brings several cloud-agent capabilities into a memory range available on high-end consumer hardware. Local inference can keep sensitive data on site, support offline operation, and reduce usage-based API costs. Operators assume responsibility for capacity planning, updates, monitoring, power consumption, and tool security.

The reported SWE-Bench Pro score of 51.2 supports evaluating Glimmer for coding agents, while the DFlash results indicate that speculative decoding can make repeated tool loops more practical. Selection still depends on the team’s repositories, prompts, tool schemas, latency targets, and acceptable quantization loss.

Checks to run before deployment

1. Measure total memory use. Include weights, the key-value cache, vision inputs, runtime buffers, the drafter, and the agent framework.
2. Benchmark the intended format. Compare BF16 and quantized builds on representative tasks, since headline quality figures may hide workload-specific regressions.
3. Test complete workflows. Record task success, tool-call accuracy, recovery behavior, wall-clock latency, and cost instead of relying only on tokens per second.
4. Constrain tool access. Validate arguments, sandbox code execution, limit credentials, and require approval for destructive operations.
5. Verify framework support. Confirm that the runtime handles Glimmer’s chat template, multimodal inputs, tool schema, context length, and DFlash integration.
6. Review license obligations. Preserve required notices and audit every bundled runtime, library, and model artifact separately.