Model reference · open weights

Muse-Glimmer

LLMs meta-models Vision + text 7 builds Open weights 591k dl/mo

Muse-Glimmer is an open-weight language model from meta-models. Muse-Glimmer-30B (BF16) weighs 59.6 GB; the smallest configuration that runs it is H100 80 GB.

  • Muse-Glimmer is a 29.8-billion-parameter multimodal language model developed by Meta Superintelligence Lab for autonomous agentic tasks on consumer hardware.
  • It features a dedicated perception encoder for image and text input, supports a context length of over 131,072 tokens, and is trained on data from more than 100 languages.
  • The model is released under the Apache 2.0 license.

Summary of the meta-models/Muse-Glimmer-30B model card, 2026-10-01. The estimate below is for another build of the family.

What it is

Released bymeta-models
Released2026-08-09
Parameters29.8B
VRAM59.6 GB for the weights

What it runs on

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

59.6 GBweights, file size
13 MBcache per 1K tokens
245 MBwindow cache per request
2.2 GBruntime overhead, at least
131,072 tokenscontext max
CardRequests at onceContext maxMemory
8K each32K each
RTX 3060 12 GB … L40S 48 GB
6 smaller cards
———
A100 80 GB4624all 128K78.2 GB
H100 80 GB259all 128K78.1 GB
RTX PRO 6000 Blackwell 96 GB6122all 128K93.8 GB
DGX Spark (GB10) 128 GB unified9234all 128K107 GB
H200 141 GB16260all 128K138 GB
B200 180 GB24761all 128K176 GB
2× L40S 48 GB
tensor parallel
6735all 128K44.0 GB a card
4× RTX 4090 24 GB
tensor parallel
3518all 128K23.4 GB a card
4× RTX 3090 24 GB
tensor parallel
3518all 128K23.4 GB a card
4× RTX 5090 32 GB
tensor parallel
7840all 128K31.0 GB a card
2× H100 80 GB
tensor parallel
18769all 128K78.1 GB a card
Memory needed at each load
Requests at once8K tokens each32K tokens each
162.1 GB62.4 GB
563.5 GB65.2 GB
864.6 GB67.2 GB
1667.4 GB72.7 GB
3273.1 GB83.6 GB
6484.4 GB105 GB

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

Builds

Sizes, precisions & builds

BuildParamsPrecisionWeightsSmallest setup
Muse-Glimmer-30B ↗ 29.8BBF16 59.6 GBH100 80 GB
Muse-Glimmer-30B-GGUF ↗
packaged by unsloth
16 builds: GGUF 1.6 GB … BF16 55.7 GB
—GGUF 15.9 GB2× RTX 3060 12 GB
Muse-Glimmer-30B (above) ↗
packaged by unsloth
29.8BBF16 59.6 GBH100 80 GB
Muse-Glimmer-30B-FP8-block ↗
packaged by RedHatAI
29.8BFP8 34.4 GBL40S 48 GB
Muse-Glimmer-30B-unsloth-bnb-4bit ↗
packaged by unsloth
29.8BINT4 22.2 GB2× RTX 4060 Ti 16 GB
Muse-Glimmer-30B-INT4 ↗
packaged by RedHatAI
8.0BINT4 22.2 GB2× RTX 4060 Ti 16 GB
Muse-Glimmer-30B-NVFP4 ↗
packaged by nvidia
19.8BNVFP4 24.7 GB2× RTX 4060 Ti 16 GB

From the model card

What meta-models says about Muse-Glimmer

Read the model card

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

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.

GPUBaseline No-speculation (tok/s)Avg* with DFlash Speculation (tok/s)Speedup
Nvidia RTX 509074.9233.43.1x
Apple M4 Max23.737.81.5x
Apple M5 Max26.650.21.8x

* Average across a diverse prompt set. Measurements done with batch size 1 and greedy decoding. M4/M5 measurements were done using ExecuTorch, and RTX using llama.cpp.

Benchmarks

We evaluated Muse Glimmer across a bro

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