Model reference · open weights

Muse-Glimmer-assistant

LLMs meta-models Vision + text 1 build Open weights 27k dl/mo

Muse-Glimmer-assistant is an open-weight language model from meta-models. Muse-Glimmer-30B-assistant (BF16) weighs 5.1 GB; the smallest configuration that runs it is RTX 3060 12 GB.

For self-hosting, compare this build's requirements below with the GPU you plan to rent.

  • Muse-Glimmer-assistant is a 2.6B parameter lightweight drafter model developed by meta-models to accelerate text generation for the Muse Glimmer 30B system.
  • It uses block-diffusion to predict 16-token blocks in a single forward pass, allowing the main model to verify proposals in parallel for faster output.
  • The model supports a 131,072 token context length and is released under the Apache 2.0 license.

Summary of the meta-models/Muse-Glimmer-30B-assistant model card, 2026-10-01

What it is

Released bymeta-models
Released2026-08-09
Parameters2.6B
VRAM5.1 GB for the weights

What it runs on

Memory and cards for Muse-Glimmer-30B-assistant (BF16)

5.1 GBweights, file size
0 MBcache per 1K tokens
126 MBwindow cache per request
833 MBruntime overhead, at least
131,072 tokenscontext max
CardRequests at onceContext maxMemory
8K each32K each
RTX 3060 12 GB4545all 128K11.6 GB
RTX 4060 Ti 16 GB7575all 128K15.4 GB
RTX 3090 24 GB138138all 128K23.4 GB
RTX 4090 24 GB138138all 128K23.4 GB
RTX 5090 32 GB199199all 128K31.0 GB
L40S 48 GB302302all 128K44.0 GB
A100 80 GB574574all 128K78.2 GB
H100 80 GB404179all 128K78.1 GB
RTX PRO 6000 Blackwell 96 GB497221all 128K93.8 GB
DGX Spark (GB10) 128 GB unified578257all 128K107 GB
H200 141 GB760338all 128K138 GB
B200 180 GB982245all 128K176 GB
Memory needed at each load
Requests at once8K tokens each32K tokens each
16.1 GB6.1 GB
56.6 GB6.6 GB
87.0 GB7.0 GB
168.0 GB8.0 GB
3210.0 GB10.0 GB
6414.0 GB14.0 GB

One card, with vLLM's small-card settings.

From the model card

What meta-models says about Muse-Glimmer-assistant

Read the model card

Authors: Meta Superintelligence Lab Model Release Date: August 2026 License: Apache 2.0

[!NOTE] This model card is for the lightweight "drafter" model for Muse Glimmer 30B, based on DFlash. The DFlash block-diffusion model predicts entire blocks of 16 tokens in a single forward pass. The main model then verifies these proposals in parallel, accepting correct tokens and correcting wrong ones. This technique lets Muse Glimmer generate text significantly faster than standard token-by-token generation while producing identical output quality.

Muse Glimmer is a 30-billion-parameter causal language model with a dedicated perception encoder, distilled from Muse Spark and purpose-built for autonomous agentic tasks on consumer hardware. The model integrates multi-step reasoning, reliable tool use, multimodal understanding, and failure recovery into a single model that runs locally without requiring cloud infrastructure or network access.

Building effective agents requires key capabilities working together to achieve the user’s goals. Muse Glimmer is trained and evaluated on these capabilities:

  • End-to-end Agentic Task Completion. Muse Glimmer achieves strong success rates on full-task benchmarks including DeepSearch QA, MCP-Atlas, 𝛕3-Bench and SWE-Bench, which measure its ability to work within scaffolds, write and debug code, and resolve multi-turn requests from start to finish.
  • Reliable Tool Use. The model handles a wide range of function calls, invoking tools with precise schemas throughout extended workflows.
  • Multi-Step Reasoning. Muse Glimmer chains reasoning over long horizons, sustaining coherent plans across complex, extended workflows.
  • Failure Recovery. When a tool call fails or returns an unexpected result, the model diagnoses the error and retries rather than halt.
  • Multimodal Input and Reasoning. Through a dedicated perception encoder, the model accepts interleaved text and images. This enables agents to interpret screenshots, charts, and documents alongside conversation.
  • Scaffold Compatibility. Muse Glimmer works across OpenClaw, Hermes Agent, and other agentic orchestration patterns.
  • Controllable Effort. The model supports different reasoning strengths to select the right balance between quality and speed.
  • Multilingual. Muse Glimmer is trained on data from more than 100 languages.

Muse Glimmer-30B Model Overview

Model ArchitectureDense Causal Transformer with Perception Encoder
Total Parameters~29.6B
Language Model
ArchitectureDense Causal Transformer
Number of Parameters29.6B (including vision encoder)
Hidden dimension6656
Layers52
Attention pattern[Local, Local, Local, Global] repeating
Sliding window size2048
Gated attentionYes
Attention heads (Q / KV)32 / 2 (GQA ratio 16:1)
Head dimension128
FFN typeSwiGLU
FFN intermediate dimension19,968
Position encodingRoPE (θ = 500,000), local layers only
Perception encoder~1.8B param ViT-G/14, 50 layers, width 1536, patch size 14
Vocabulary size202,048
Tokenizer200,000 BPE tokens + 2,048 special tokens
Max visual tokens per image4,096
Context length131,072+
Supported modalitiesInput: text + image, Output: text
Training DataMultimodal content sourced from publicly available data, data provided by third parties and information from Meta's products and services, curated and enriched by external vendor networks and Meta personnel.
Knowledge cutoffJanuary 4, 2026

Optimized for Local Deployments

Muse Glimmer was optimized for local deployment, and designed to run at practical speeds on consumer hardware without sacrificing quality.

Fitting the Model on Your Device. We use quantization techniques to compress the model's weights to approximately 4-bit precision, shrinking the language model to under 20 GB. This leaves enough headroom for the model's KV cache, the perception encoder for image understanding, and the speculative decoding drafter to run simultaneously within a 24 GB or 32 GB envelope. Critically, we validated that this compression introduces minimum to no degradation on agentic tasks.

Full PrecisionK-Quant-DynamicK-Quant-17GB
% Degradation*-0.2%1.0%
Target Hardware64GB VRAM32GB VRAM24GB VRAM

* Degradation measured using an average on accuracy metrics across 15 common benchmarks

Faster Generation Through Speculative Decoding Muse Glimmer ships with a lightweight "drafter" model based on DFlash, a small companion network that proposes entire blocks of tokens at once. The DFlash block-diffusion model predicts entire blocks of 16 tokens in a single forward pass. The main model then verifies these proposals in parallel, accepting correct tokens and correcting wrong ones. This technique lets Muse Glimmer generate text significantly faster than standard token-by-token generation while producing identical output quality. We provide quantized drafter versions to incur a smaller memory overhead in the release.

ComponentSetting
Draft layers5
Block size16
AttentionSliding-window, 2048, all layers
Attention heads32 query / 8 KV (GQA)
Sequence length131,072
Hidden-feature layers5, uniform over target: {1, 13, 25, 37, 49} of 52

We measure the speed of our K-Quant-17GB model alongside the quantized DFlash drafter on MacBook M4-Max, M5-Max and on an Nvidia RTX-5090. The model is fast enough for fluid conversation and real-time agent interaction, all running entirely on your device.

| GPU | Baseline No-s

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms