Muse Glimmer: The 30B Open Model Agencies Can Run on One GPU

Published August 11, 2026Updated August 12, 2026By ABD Legacy LLC
AI models / local vs API

On August 10, 2026, Meta released Muse Glimmer — a 30-billion-parameter, dense, open-weight model built by Meta Superintelligence Lab — the division led by former Scale AI CEO Alexandr Wang — and its first open-weights release. It is distilled from the closed frontier model Muse Spark. TechStartups reports Zuckerberg paired the launch with a 14-page essay urging the U.S. to remove barriers to open-source AI, and says Meta will open-source Muse Spark 1.2 next. For agencies, the interesting part is not the politics — it is that a model with competitive agentic and coding scores now runs on a single consumer GPU, with weights under the Apache 2.0 license.

That combination changes a core agency-stack assumption: that every agent run, eval pass, and code edit accrues per-token API charges. Muse Glimmer is the strongest signal yet that "local" is now a real option for agency workloads — with real trade-offs. Here is what's verified, when to go local vs hosted, and what it costs.

Same-day context: the open-source AI manifesto

Why Zuckerberg's essay matters for this model

Muse Glimmer did not ship in a vacuum. The same day, Zuckerberg published "The Future is for Everyone" (~6,500 words), arguing AI's defining question is access — "Will it be centralized and restricted to a few institutions, or will it be a tool that empowers everyone?" — and rejecting the closed-lab safety thesis: "The notion that AI is so dangerous that the only safe path is an extreme concentration of power seems inherently problematic." Bloomberg read the release as "challenging a vision of AI championed by startups like OpenAI and Anthropic PBC."

One distinction keeps the buyer's decision honest: open weights ≠ open source. Glimmer is downloadable and alterable, but as Bloomberg put it, users "won't have access to all the ingredients that went into making it." You can audit and patch what you run — but you own the risk, and nobody else patches your deployment. For the full comparison of what open vs closed means for tooling, privacy, lock-in, and compliance, see our guide to open source AI vs closed AI for agencies.

What Muse Glimmer is (verified specs)

The specifications below are from Meta's official model card and NVIDIA's local AI models blog — treat them as the authoritative numbers:

SpecVerified valueSource
Parameters30B dense (~29.6B total: 28B text decoder + ~1.8B ViT-G/14 perception encoder)Meta model card; NVIDIA
LicenseApache 2.0 (weights + BF16, 4-bit quants, DFlash drafter, encoder)Meta model card
Context window131,072+ tokens (NVIDIA: "120K+")Meta model card; NVIDIA
Quantized sizeUnder 20GB — official 4-bit K-Quant-17GB file is ~16.76 GBMeta model card; GGUF repo
HardwareSingle consumer GPU — 17GB quant targets 24GB VRAM; K-Quant-Dynamic targets 32GBMeta model card; NVIDIA; TechStartups
Speed>200 tok/s on RTX 5090 (74.9 baseline → 233.4 with DFlash speculative decoding, 3.1×)NVIDIA; Meta model card
Inputs/outputsMultimodal: text + image in, text outMeta model card

Meta's card lists intended uses that map almost directly onto agency work: local agents, function calling, local coding, and LLM-as-a-judge evaluation — and it names OpenClaw and Hermes Agent scaffolds as targets. On benchmarks it leads its size class on MCP Atlas (75.5), DeepSearch QA (74.6), SWE-Bench Pro (51.2), and AIME 2026 (94.7), per the model card.

Why it matters for local agents, coding, and evaluation

Three agency workloads change when a capable 30B model runs on local hardware:

None of this means "frontier on a budget." Muse Glimmer is not frontier-grade on the hardest reasoning (HLE 22.0, GPQA 83.5 — roughly size-class parity), and the official 17GB quant carries about 1.0% benchmark degradation vs full precision. It competes with the open-weight models already reshaping agency margins — not with GPT-5.6 Sol or Claude Opus 5 on deep reasoning.

Run it today: one command with Ollama

The fastest way for an agency to test the local claim is Ollama's official build, which launched the same day as the model. On a machine with ~18GB free, one command downloads the 30B model (128K context, text + image input) and serves it on localhost:

ollama run muse-glimmer

On Apple Silicon, the MLX engine build (muse-glimmer:30b-mlx, ~21GB) adds DFlash speculative decoding and image input — Ollama reports 1.5×–1.8× faster on Apple Silicon than without. Both builds work offline: no cloud infrastructure or network access required.

Where it gets interesting for agencies: Ollama's one-command launcher wires the model into the coding and agent tools your team already uses:

Muse Glimmer also exposes controllable reasoning strength — low / medium / high / xhigh — so you can spend compute on complex coding and agentic tasks (high or xhigh) and drop to lower strengths when speed matters more. That dial matters for agency cost engineering: it is a per-request quality/speed trade-off you control, not a fixed API tier.

Two more operational facts worth knowing before you quote it to a client: the model is trained on data from 100+ languages, and the model card's intended uses (local agents, function calling, local coding, LLM-as-a-judge) name OpenClaw and Hermes Agent scaffolds explicitly. Meta's full evaluation methodology is published at research.meta.ai/static/muse-glimmer-methodology.

Local vs hosted API: when to choose which

The decision is workload-shaped, not model-shaped. Use this as a starting framework:

Choose local (Muse Glimmer on one GPU)Choose hosted API
Sustained, high-volume eval / batch / coding workloads that run for monthsSpiky workloads that don't justify dedicated hardware
Client data must stay on-premises (NDA, HIPAA/SOC2-adjacent, credential handling)Client data can leave the building under the vendor's terms
You want predictable fixed cost and are amortizing hardware over 12-24 monthsYou want zero capex and pay-as-you-go flexibility
You have ops capacity to own uptime, updates, and security patchingYou want the vendor to own uptime, SLAs, and patching
Workload tolerates ~1.0% quant degradation and size-class reasoningWorkload needs frontier-grade reasoning on the hardest tasks

For most agencies the honest answer is hybrid: local for the high-volume grunt work (evals, triage, background agents, structured extraction), hosted frontier for client-facing complex work. That is the same routing discipline covered in our Muse Spark model-routing guide — the local tier just got dramatically cheaper to run.

Cost and operational implications

The cost argument for local is break-even, not free:

There is also a hosted fallback for bursts. Meta publishes no first-party API price for Glimmer, but third-party hosts already list the model: Together AI lists $0.35 per million input tokens and $1.50 per million output tokens ($0.04/M for cached input), and OpenRouter lists $0.30/$1.20 per million. That is roughly 10× cheaper than frontier API pricing — a reasonable "test it before you buy hardware" path, and a sensible burst lane for spiky workloads. The break-even math still favors local for sustained volume; hosted just removes the hardware commitment for evaluation.

There is also a strategic angle: agencies that run high-volume agent and eval workloads can cut OpEx and either improve margins or undercut competitors on price. If you resell tokens or bill hourly, this is the same margin story as open-weight coding models — the cost basis of the work just collapsed, and the play is to route, not rip out.

One honest caveat on the market: Muse Glimmer launched the same week as NVIDIA's Nemotron 3.5 Lightning (30B MoE) and alongside Qwen3.6-27B and Gemma4-31B as its benchmark comparison set. Four credible local 30B-class options in one week means downward pressure on what "cheap" means — locally and in API pricing. Do not make hardware decisions on one model; benchmark your own workloads.

Same-week launches, different lanes (Aug 10, 2026): the same day Meta shipped Muse Glimmer for local text agents, Microsoft shipped MAI-Image-2.6, now #2 on the Arena text-to-image leaderboard (Elo 1336, behind only OpenAI's GPT-Image-2). They are not competing products: Muse Glimmer is an open-weight 30B text model you run on one GPU, while MAI-Image-2.6 is a closed image-generation model for product mockups, ad creative, and branded visuals. And don't conflate Meta's own image model, Muse Image (Arena #5), with Muse Glimmer — one generates images, the other runs agents. For agencies quoting image-generation deliverables, see the AI automation agency services guide, which now covers MAI-Image-2.6 and the image-model cost spread.

What this means for your agency

Find an agency that builds AI stacks deliberately

Browse Vetted AI Agencies →

Or estimate your agency's AI costs with the AI agency pricing calculator — including the local-model strategy.

Frequently asked questions

What is Meta Muse Glimmer?

Muse Glimmer is an open-weight model released by Meta on August 10, 2026 and built by Meta Superintelligence Lab. It is a 30B dense model (~29.6B total parameters: 28B text decoder plus a ~1.8B ViT-G/14 perception encoder) licensed under Apache 2.0, with a 131,072+ token context window and an official 4-bit quantization that fits under 20GB. It is designed to run on a single consumer GPU and targets local agents, function calling, local coding, and LLM-as-a-judge evaluation.

Can my agency really run Muse Glimmer on one GPU?

Yes, per Meta's official model card and NVIDIA. Meta ships an official 4-bit K-Quant-17GB GGUF file (about 16.76 GB) targeting 24GB VRAM, with a K-Quant-Dynamic variant targeting 32GB. NVIDIA reports over 200 tokens/second on an RTX 5090 (233.4 tok/s with DFlash speculative decoding, 3.1x over baseline). The full context window plus encoder and drafter needs the 24-32GB envelope — not an 8GB card.

When should an agency choose a local model over a hosted API?

Choose local when you run sustained, high-volume workloads (evaluation, batch coding, background agents), when clients require data to stay on-premises, or when you want predictable fixed costs instead of per-token opex. Choose hosted API when workloads are spiky, you need frontier-grade reasoning on the hardest tasks, or you don't have the ops capacity to own uptime and security patching. The official 17GB quant carries about 1.0% benchmark degradation versus full precision.

What is the cost benefit of running Muse Glimmer locally?

After the one-time GPU hardware purchase (a 24GB-class consumer card for the 17GB quant), the marginal cost of inference collapses to electricity. That undercuts per-token API pricing for sustained agent, eval, and coding volume. The trade-offs: you own uptime, operations, and security patching, and the model is not frontier-grade on the hardest reasoning benchmarks.

Is Muse Glimmer free to use commercially?

Yes. Muse Glimmer is released under the Apache 2.0 license, covering the weights and all artifacts including the BF16 model, 4-bit quantizations, the DFlash drafter, and the perception encoder. Apache 2.0 permits commercial use, modification, and redistribution with attribution.

How do I run Muse Glimmer locally with Ollama?

One command: ollama run muse-glimmer. The official Ollama build is about 18GB with a 128K context window and text + image input, and it works offline. On Apple Silicon, use the MLX build (ollama run muse-glimmer:30b-mlx, ~21GB) for DFlash speculative decoding and image input. Ollama's launcher can wire the model into Claude Code, Codex, OpenCode, GitHub Copilot, Pi, OpenClaw, and Hermes Agent with commands like ollama launch claude --model muse-glimmer. The model also supports controllable reasoning strength (low / medium / high / xhigh) so you can trade speed for quality per request.

Is there a hosted API for Muse Glimmer?

Meta does not publish a first-party API price, but third-party hosts already serve the model: Together AI lists $0.35 per million input tokens and $1.50 per million output tokens ($0.04/M cached input), and OpenRouter lists $0.30/$1.20 per million. That is roughly 10x cheaper than frontier API pricing — useful for testing or burst workloads, while sustained volume still favors running the model locally.

Related reading

Sources