Muse-Glimmer-30B

Updated
21.08.2026
Thinking
Tools
Vision
Reasoning
Code
Multilingual
Web

Muse Glimmer 30B is Meta's agent model for consumer hardware: 30B dense with a vision encoder, quantized to fit a 24 GB card.

At a glance

  • License: Apache 2.0
  • Parameters: 29.6B dense, 52 layers, including a 1.8B vision encoder
  • Context length: 131,072 tokens
  • Modalities: text and image input
  • Minimum hardware: 16 GB VRAM at AD-IQ3_M, 24 GB for AD-Q4_K_M

Overview

Muse Glimmer 30B is an agent model from Meta Superintelligence Lab, distilled from Muse Spark and released in August 2026 under Apache 2.0. Meta built it for autonomous agent work on consumer hardware, so the design target was a machine you own rather than a cluster you rent.

SpecificationMuse Glimmer 30B
Total parameters29.6B, including the vision encoder
ArchitectureDense causal transformer with a perception encoder
Layers52
AttentionSliding window of 2,048 tokens on three of every four layers
Perception encoderViT-G/14, about 1.8B parameters
Context window131,072 tokens
ModalitiesText and image input, text output
Speculative decodingDFlash drafter ships with the model
Release dateAugust 2026
LicenseApache 2.0

That attention layout is what keeps the KV cache small enough for the vision encoder and the DFlash drafter to sit alongside the weights in a 24 GB envelope. Meta reports that its own 4-bit compression costs 0.2% accuracy against full precision on a 15-benchmark average.

Muse Glimmer 30B benchmarks

Meta's launch numbers, from the model card, put Glimmer in high-reasoning mode against the thinking modes of Gemma 4 31B and Qwen3.6-27B:

Muse Glimmer 30BGemma 4 31BQwen3.6-27B
MCP Atlas
Tool use over MCP servers
75.554.262.5
DeepSearch QA
Multi-step web research
74.661.771.1
SWE-Bench Pro
Real-world software engineering, harder split
51.236.950.2
SWE-Bench Verified
Real-world software engineering tasks
76.066.677.2
TerminalBench 2.1
Agentic terminal-use tasks
51.743.460.7
AIME 2026
Advanced mathematical reasoning
94.789.294.1
GPQA Diamond
Expert-level science questions
83.585.784.2
OSWorld-Verified
Computer-use agent tasks
65.958.575.6

Glimmer takes tool use, web research and maths, and gives up terminal and computer-use tasks to Qwen3.6-27B. The pitch is a 30B agent that stays inside a 24 GB card with its vision encoder and drafter loaded, not a model that wins every row.

Muse Glimmer 30B hardware requirements

The system requirement to check is memory. We quantized the model from the original weights and published the builds as AtomicChat/Muse-Glimmer-30B-GGUF.

MemoryBuild to pickFile size
16 GBAD-IQ3_M14.9 GB
24 GBAD-Q4_K_M19.1 GB
32 GBAD-Q5_K_M22.7 GB
48 GB and upAD-Q6_K28.3 GB

Add the vision projector on top if you want image input, and leave headroom for the DFlash drafter if you run speculative decoding. Neighbouring files differ by a gigabyte or two, so when two builds both fit, take the larger one.

How to run Muse Glimmer 30B in Atomic Chat

Atomic Chat is a free local app for macOS, Windows and Linux. It includes a Hugging Face model browser and a built-in chat, with no manual llama.cpp build required.

  1. Download Atomic Chat for your platform and open it.
  2. Search for Muse-Glimmer-30B in the model browser and open Download Options.
  3. Pick the build that fits the memory you have, then start a chat.

To point it at real tools once it is running, follow our guide to running AI agents locally, or connect it to your apps with MCP connectors.

Its closest rival at this size is Ornith-1.5-35B-A3B, which is ahead on coding and behind on MCP tool routing. For the wider field see the best local LLMs for coding.

License

Muse Glimmer 30B is released under Apache 2.0, which permits commercial use, modification and redistribution with no royalties. That is unusually permissive for a Meta model release and it applies to the perception encoder and the DFlash drafter shipped with it.

Get the weights from Hugging Face

huggingface-cli download meta-models/Muse-Glimmer-30B
# our GGUF build:
huggingface-cli download AtomicChat/Muse-Glimmer-30B-GGUF Muse-Glimmer-30B-AD-Q4_K_M.gguf
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Muse-Glimmer-30B",
    "messages": [{"role": "user", "content": "Read this screenshot and file the bug."}]
  }'
from transformers import AutoProcessor, AutoModelForImageTextToText

model_id = "meta-models/Muse-Glimmer-30B"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(model_id, torch_dtype="auto", device_map="auto")

messages = [{"role": "user", "content": [{"type": "text", "text": "What does this chart show?"}]}]
inputs = processor.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
print(processor.decode(model.generate(**inputs, max_new_tokens=1024)[0]))
import OpenAI from "openai";

const client = new OpenAI({ baseURL: "http://localhost:8000/v1", apiKey: "local" });
const res = await client.chat.completions.create({
  model: "Muse-Glimmer-30B",
  messages: [{ role: "user", content: "Call the weather tool and summarise the result." }],
});
console.log(res.choices[0].message.content);
Desktop
macOS
(M1 or better)
Download
Windows
(x64)
Download
Linux
(x86_64)
Download

Frequently asked questions

Muse Glimmer 30B is a 29.6B dense model with a built-in vision encoder from Meta Superintelligence Lab, distilled from Muse Spark and released in August 2026 under Apache 2.0. It is built for agent work: tool calls, multi-step reasoning and recovery when a tool fails.

Our AD-Q4_K_M build is 19.1 GB, so a 24 GB card runs it with room for the vision projector. AD-IQ3_M fits 16 GB at 14.9 GB, and AD-Q6_K at 28.3 GB is the near-reference build.

Yes. It ships under Apache 2.0, so commercial use, modification and redistribution are allowed with no fee.

Yes. It carries a ViT-G/14 perception encoder of about 1.8B parameters and accepts interleaved text and images, which is what lets an agent read a screenshot or a chart instead of only text.

DFlash is a small companion model that proposes a block of 16 tokens in one pass, which the main model then verifies in parallel. It raises tokens per second and leaves the output identical.