Muse Glimmer 30B: The New Local AI Agent

Most AI agents run somewhere in a data center. You send a request, a cloud processes it, and an answer comes back. That dependency is so normal in 2026 that most developers stopped questioning it.

Meta just questioned it.

On August 10, 2026, Meta Superintelligence Labs released Muse Glimmer, a 30-billion-parameter open agentic model designed to run on a Mac or PC with a single consumer GPU. No cloud required. No API bill accumulating in the background. No internet connection needed. A full planning, tool-calling, self-checking agent that lives on your device and works while your laptop is offline.

Muse Glimmer arrives under the Apache 2.0 license, the company's first fully open release since it succeeded its open-weight Llama family in April with the proprietary Muse Spark. It launches with a more permissive license than Llama ever carried.

Why Local Agents Matter Now

Running a model locally used to mean accepting a severe capability trade-off. Small models that fit on a GPU were not capable enough to run real agent tasks. Large models that could handle agents required server-grade hardware.

The open source community has shown that smaller models, when trained effectively, can approach frontier-level performance on targeted tasks. Muse Glimmer is optimized for these local use cases.

The practical implications are significant. A local agent has access to personal context — your files, your schedule, your messages — without that data leaving your device. Privacy-sensitive workflows become viable. Always-on personal automation becomes viable. Teams in regulated industries that cannot send data to external APIs now have a real option.

Muse Glimmer is a dense 30-billion-parameter model built specifically for always-on local agent workflows, the opposite design goal from Muse Spark's cloud-scale reasoning.

Architecture: How a 30B Model Fits in 24 GB

  full precision vs K-Quant-Dynamic vs K-Quant-17GB by accuracy degradation and target hardware memory

The architecture of Muse Glimmer makes specific choices to hit the local hardware target without giving up agentic capability.

Muse Glimmer is a dense causal transformer with a dedicated perception encoder. Total parameters are roughly 30B, including the vision tower. Grouped-query attention uses 32 query heads and 2 KV heads. Attention repeats a Local, Local, Local, Global pattern with a 2,048 sliding window. RoPE is applied to local layers only, with theta 500,000. The vision side is a 1.8B ViT-G/14 perception encoder accepting up to 4,096 visual tokens per image. Context length is 131,072 tokens, vocabulary is 202,048 tokens, and the knowledge cutoff is January 4, 2026.

The local and global attention alternation is worth understanding. Local attention with a 2,048-token sliding window handles the bulk of processing at low cost. Global attention layers, placed every fourth block, handle long-range dependencies across the full context. This design keeps per-token compute manageable while preserving the coherent long-horizon planning that agent tasks require.

Quantization: From 55 GB to Under 20 GB

At full precision, a 30-billion parameter model would require over 55 GB of memory. Meta uses 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 working memory, the perception encoder for image understanding, and the speculative decoding drafter to run simultaneously within a 24 GB or 32 GB envelope. Meta validated that this compression introduces minimal to no degradation on agentic tasks.

Speculative Decoding: The DFlash Drafter

Muse Glimmer ships with a lightweight drafter model based on DFlash, a small companion network that proposes entire blocks of tokens at once. The main model then verifies these proposals in parallel, accepting correct tokens and correcting wrong ones. This lets Muse Glimmer generate text significantly faster than standard token-by-token generation while producing identical output quality.

  DFlash speculative decoding speed chart

The numbers are real: DFlash speculative decoding increases Muse Glimmer decode speed by 3.1 times on RTX 5090, 1.8 times on M5 Max, and 1.5 times on M4 Max. On an RTX 5090, a 3x speed improvement on a 30B model is the difference between an agent that feels like a conversation and one that feels like a batch job.

How Meta Trained It

The training pipeline has three distinct phases, each targeting a specific capability gap.

Pre-training used Muse Spark's outputs via logit distillation, leveraging a similar data mix as the teacher. Mid-training extended to longer-context, more agent-heavy data with richer reasoning traces, alongside organic data. Post-training combined supervised fine-tuning with a mix of on-policy distillation and reinforcement learning across general, reasoning, coding, and agentic domains.

The distillation from Muse Spark is the key architectural decision. A 30B model trained only on standard data would not reach the reasoning depth required for real agent tasks. By distilling from a much larger teacher model, Muse Glimmer inherits reasoning patterns that would otherwise require many more parameters to develop independently.

Meta also trained Muse Glimmer to retry tasks that it fails to complete on the first attempt. Some models stop running if they encounter an obstacle while processing a prompt. Muse Glimmer is trained to diagnose the error and retry rather than halt. Failure recovery is not a feature most model cards mention. For production agents running unattended, it is the difference between a completed task and a stuck pipeline.

What Muse Glimmer Can Do

Muse Glimmer is trained and evaluated across end-to-end agentic task completion, reliable tool use, multi-step reasoning, failure recovery, multimodal input and reasoning, scaffold compatibility, controllable effort, and multilingual support across more than 100 languages.

The multimodal input deserves attention. The model accepts interleaved text and images, producing text output, and supports more than 100 languages with a context length of 131,072 tokens. That combination lets an agent interpret screenshots, charts, and documents while simultaneously reasoning about text and invoking external tools.

Audio is not supported. Video is processed as individual frames, not as a native video stream. These are the honest limits of a 30B model optimized for local hardware.

Use cases Meta lists specifically: desktop agents that read screenshots, coding agents, schema-based function calling, document and chart understanding, synthetic data generation, and LLM-as-a-judge evaluation.

Benchmark Results: Where Glimmer Wins and Where It Does Not

  benchmark comparison

Meta compares Muse Glimmer against Gemma4-31B and Qwen3.6-27B in thinking mode. It leads on MCP Atlas at 75.5, against 54.2 and 62.5. It also leads on DeepSearch QA at 74.6, Gaia2 at 43.3, and SWE-Bench Pro at 51.2. Reasoning scores follow: AIME 2026 at 94.7, IFBench at 77.0, AA-LCR at 80.0.

Qwen3.6-27B stays ahead on OSWorld-Verified at 75.6 versus 65.9, and also leads Terminal-Bench 2.1 at 60.7 and SWE-Bench Verified at 77.2. The pattern is consistent. Muse Glimmer wins on agentic orchestration and reasoning. It trails on computer-use and terminal work.

The story is honest. Muse Glimmer is the best 30B model for tool-calling agents, search, and multi-step reasoning. It is not the best for autonomous computer use or terminal-heavy coding. Teams choosing this model should know which category their workflow falls into.

On safety, the Siren AgentDojo attack success rate is 28.4 with utility 94.2. Meta states the model does not meet the Frontier AI definition in its Advanced AI Scaling Framework, and rates chem/bio, cyber, and loss-of-control risk at moderate or lower.

How to Run Muse Glimmer Locally

Via Ollama (easiest setup):

ollama pull muse-glimmer:30b
ollama run muse-glimmer:30b

Via llama.cpp (fastest local inference):

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make

./llama-cli \
  -m muse-glimmer-30b-q4_k_m.gguf \
  -n 2048 \
  --ctx-size 131072 \
  -p "You are a local agent. Plan and execute the following task: summarize all PDF files in my Downloads folder."

Via Hugging Face Transformers:

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "meta-models/Muse-Glimmer-30B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

messages = [
    {
        "role": "user",
        "content": "Search my documents for mentions of Q3 revenue and summarize the findings."
    }
]

inputs = tokenizer.apply_chat_template(
    messages,
    return_tensors="pt"
).to(model.device)

outputs = model.generate(inputs, max_new_tokens=1024)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Via Together AI or Fireworks AI (no local setup):

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_TOGETHER_API_KEY",
    base_url="https://api.together.xyz/v1"
)

response = client.chat.completions.create(
    model="meta-models/Muse-Glimmer-30B",
    messages=[
        {"role": "user", "content": "Analyze this chart and identify the revenue trend."}
    ]
)
print(response.choices[0].message.content)

Muse Glimmer is available on Hugging Face and runs through Ollama, LM Studio, Unsloth, llama.cpp, ExecuTorch, MLX, vLLM, and SGLang. Third-party API access is available through Together AI, Fireworks AI, and OpenRouter. Meta is also working with AMD, Arm, Dell, Intel, and NVIDIA to optimize performance across devices.

Hardware Requirements

The 24 GB minimum is a real constraint. RTX 4090 owners are at the floor. M4 Max and M5 Max Macs with 32 GB unified memory are the comfortable target hardware. Anything below 24 GB VRAM will need further quantization with quality trade-offs.

Conclusion

Muse Glimmer is not a compromise. It is a deliberate design target: the most capable agentic model that fits on a consumer GPU, trained specifically to plan, use tools, recover from failures, and read images, all without phoning home to a cloud.

It arrives under Apache 2.0, Meta's most permissive open license to date, making it fully usable for commercial products, fine-tuning, and redistribution without the community license restrictions that limited Llama.

The benchmark results are honest about the trade-offs. Muse Glimmer leads on MCP Atlas at 75.5, DeepSearch QA at 74.6, and AIME 2026 at 94.7, but trails Qwen3.6-27B on computer use and terminal benchmarks. For teams building search agents, document automation, coding assistants, and personal AI workflows, the trade-off lands in the right place.

The era of cloud-dependent agents is not over. But for the first time in 2026, a model capable enough to run real agentic tasks fits on a Mac. That changes the calculus for every team that has been waiting for local AI to become practical rather than a demo.

Muse Glimmer is practical. It is available today. The weights are on Hugging Face right now.

FAQs