TL;DR: Meta released Muse Glimmer on August 10, 2026 — a 30B dense, Apache 2.0, agent-trained model whose 4-bit build fits a 24GB GPU. It is now the strongest orchestration model you can run locally, but on pure coding benchmarks Qwen3.6-27B still edges it out. Day-one Ollama support is Apple-Silicon-first; NVIDIA and AMD support is still in pre-release.

	Muse Glimmer 30B (local)	Qwen3.6-27B (local)	DeepSeek V4-Flash (API)
Best for	Agentic loops, tool-heavy Cline tasks, multimodal input	Raw coding and terminal work	Cheapest capable cloud backend
Price / Cost	Free weights, 24GB GPU (Apache 2.0)	Free weights, 24GB GPU	$0.14/M input, $0.28/M output
The catch	XML “ATEM” tool calls need runtime parser support; NVIDIA Ollama support still pre-release	Weaker on MCP/orchestration benchmarks	Price hike announced, no date yet

Honest take: If you already own a 24GB card, pull Muse Glimmer this week — its tool-calling reliability in agent loops is the real story, and Apache 2.0 means zero license anxiety for client work. If you’re deciding whether to buy a GPU to run it, don’t: at DeepSeek V4-Flash’s current $0.14/M, the API costs less per month than the electricity the GPU burns.

Meta went closed-source with Muse Spark in July — we covered what that did to Llama-based BYOK stacks — and the community wrote Meta off as an open-weights vendor. One month later it shipped the opposite signal: Muse Glimmer, a 30B open-weights model under Apache 2.0, distilled from the closed Muse Spark teacher and trained end-to-end for the agent loop — long-horizon reasoning, tool calling, failure recovery, coding, and image understanding. The Hacker News thread hit the front page within hours of the August 10 drop.

This guide covers what actually matters for putting it behind Cursor, Cline, or Claude Code: which quantization fits which GPU, the tool-call format quirk that decides whether your agent loop works at all, and the honest cost math against a cloud API. Everything below was verified August 11, 2026 against Meta’s announcement, the Hugging Face model card, and Ollama’s release notes; the recurring sandbox note applies — several official pages were cross-verified through search summaries and GitHub sources because direct fetches are blocked in this environment.

What Muse Glimmer actually is

Muse Glimmer is a dense ~29.6B-parameter text decoder (52 layers, hidden size 6656) with a separate ~1.8B vision encoder bolted on — so it takes screenshots and diagrams as input, which matters more for agent workflows than it sounds. Trained context is 128K, and the deployed configuration advertises a 131K-token window. Weights are BF16 at roughly 55–60GB, and Meta ships its own quantized variants rather than leaving that to the community:

Variant	Size	Meta’s stated target
K-Quant-17GB	~17GB	24GB GPUs (RTX 3090/4090)
K-Quant-Dynamic	~18–20GB loaded	32GB+ GPUs and unified-memory Macs
BF16 full precision	~55–60GB	64GB+ (multi-GPU or M-series Max/Ultra)

Distribution is broad on day one: meta-models/Muse-Glimmer-30B on Hugging Face plus a GGUF repo, with support rolling out across Ollama, LM Studio, llama.cpp, vLLM, SGLang, and hosted API access via Together AI, Fireworks AI, and OpenRouter. Unsloth’s GGUF conversions go smaller still — their UD-Q4_K_XL is 15.9GB.

Two things separate this from the usual mid-size drop. First, the license: Apache 2.0, not a Llama-style community license — commercial BYOK use in paid client work is unambiguously clean. Second, DFlash: a block-diffusion speculative-decoding drafter (an ICML 2026 paper) that proposes 16-token blocks which the main model verifies in parallel. Meta measured 3.1× faster decoding on an RTX 5090, 1.8× on an M5 Max, and 1.5× on an M4 Max — lossless, same outputs. Structured output like code is exactly where block drafting shines, and the drafter ships inside the quantized bundles, which is why the memory envelope (model + KV cache + vision encoder + drafter) is engineered to close at 24GB.

The tool-calling gate: ATEM, not JSON

Before wiring anything into Cline, understand the one architectural quirk that decides whether the agent loop works: Muse Glimmer does not emit OpenAI-style JSON tool calls. It emits channel-scoped reasoning plus XML-style ATEM tool-call blocks (<atem:function_calls>), and runtimes need a dedicated muse_glimmer parser to translate that into the OpenAI-compatible tool_calls field your editor expects.

What this means in practice:

• Ollama v0.32.7+ ships the parser — the library page lists chat, thinking, and tool calling as supported capabilities, and Ollama’s announcement explicitly positions the model to “power Claude Code, Codex, and more” coding agents.
• vLLM needs the muse_glimmer tool-call and reasoning parser flags set at serve time; miss them and every tool call arrives as raw XML text in the content field.
• Random community quants are a gamble. Within 24 hours of release, an oMLX issue documented a third-party 4-bit checkpoint that never produced <atem:function_calls> at all — the model emitted its reasoning block, then terminated. Root cause was a quantization made with a pre-fix toolchain that corrupted embedding normalization; the same runtime with the mlx-community 4-bit checkpoint or Meta’s official GGUF worked correctly. The failure mode also cut decode speed from ~38 to ~9–12 tokens/second on an M3 Ultra.

The lesson from that issue generalizes: if Muse Glimmer “refuses to use tools” in your setup, suspect the checkpoint and the parser before you suspect the model. Pull Meta’s official tags or unsloth’s GGUFs, not week-one community conversions.

Ollama setup — and the NVIDIA asterisk

Ollama added Muse Glimmer in v0.32.7, released the same day as the model. The tags that matter:

$ ollama pull muse-glimmer:30b-q4_K_M          # 18GB — 24GB GPUs
$ ollama pull muse-glimmer:30b-q4_K_M-dflash   # 20GB — 4-bit + speculative drafter
$ ollama pull muse-glimmer:30b-q8_0            # 31GB — 32GB+ setups
$ ollama pull muse-glimmer:30b-q8_0-dflash     # 33GB

Now the asterisk, and it’s a big one this week: v0.32.7 runs Muse Glimmer through Ollama’s MLX engine — Apple Silicon first. NVIDIA and AMD support lands in v0.32.8, which as of August 11 is still a pre-release (v0.32.8-rc0, tagged August 10). On a Mac with 24GB+ unified memory you’re fully supported today. On an RTX 4090 your options are: run the pre-release, serve the official GGUF through llama.cpp or LM Studio (both listed as day-one paths, and the GGUF is confirmed working on llama.cpp), or wait the presumably short interval until v0.32.8 goes stable.

Once the model runs, pin the context window before pointing an agent at it. Ollama’s VRAM-scaled default context silently breaks agentic tools — on a 24GB card the default is 32K, and Cline’s system prompt plus file context will blow through that:

$ OLLAMA_CONTEXT_LENGTH=65536 ollama serve

The 131K advertised window is a KV-cache budget question at 4-bit on 24GB: the 17GB-class quants leave roughly 5–6GB for cache, which is why one early RTX 4090 report of the full 130K window fitting in 19.3GB relied on aggressive cache management. Treat 64K as the realistic agent-mode ceiling on a 24GB card and be pleasantly surprised if you get more.

Wiring it into Cline

Cline’s cleanest path is the Ollama provider, or OpenAI Compatible if you’re serving via llama.cpp/vLLM:

1. Cline settings → API Provider → Ollama (or OpenAI Compatible)
2. Base URL: http://localhost:11434/v1
3. Model ID: muse-glimmer:30b-q4_K_M-dflash (or whichever tag you pulled)
4. In the model settings, set the context window to match your OLLAMA_CONTEXT_LENGTH pin

Because the runtime translates ATEM calls into OpenAI-format tool calls, Cline’s agentic loop — read file, edit, run command, observe, retry — works without Cline knowing anything about the format underneath. And the retry part is where Muse Glimmer is genuinely differentiated: Meta trained it to diagnose failed tool calls and retry rather than halt, which is precisely the failure mode that kills long Cline sessions on most local models. Our Goose + Ollama guide documented how much agent reliability hinges on exactly this behavior.

For Claude Code, the one-command Ollama route applies unchanged — Ollama’s Anthropic-compatible endpoint serves Muse Glimmer to Claude Code the same way it serves any other tool-capable model, and Ollama’s own announcement names Claude Code as a target workload.

Wiring it into Cursor

Cursor’s BYOK story is unchanged from our Cursor + Ollama guide: override the OpenAI base URL (http://localhost:11434/v1), add muse-glimmer:30b-q4_K_M-dflash as a custom model name, and Chat and Cmd+K route to your machine. Two caveats carry over exactly: Tab autocomplete stays on Cursor’s proprietary cloud model no matter what you configure, and Cursor’s agent mode against custom endpoints remains the least reliable of the three integrations here — Cline is the better host if agentic work is the point.

The benchmark story: orchestrator first, coder second

Meta published a comparison table against the two obvious rivals in the ~30B open-weight class, Gemma4-31B and Qwen3.6-27B. These are vendor-reported numbers — treat them accordingly — but the pattern is honest enough that Meta left the losses in:

Benchmark (Meta-reported)	Muse Glimmer 30B	Qwen3.6-27B	Gemma4-31B
MCP Atlas (tool orchestration)	75.5	62.5	54.2
DeepSearch QA	74.6	—	—
GAIA2	43.3	—	—
SWE-Bench Pro	51.2	—	—
SWE-Bench Verified	76.0	77.2	—
Terminal-Bench 2.1	trails	60.7	—
OSWorld-Verified	65.9	75.6	—
AIME 2026	94.7	—	—

Read the split for what it is. Muse Glimmer dominates the benchmarks that measure being an agent — multi-step tool orchestration (a 13-point MCP Atlas lead over Qwen), research loops, long-horizon task completion. Qwen3.6-27B keeps the crown on the benchmarks that measure writing and shipping code in a terminal — SWE-Bench Verified, Terminal-Bench, OSWorld. If your Cline sessions are mostly “implement this function, run the tests, fix the failures,” Qwen3.6 remains the stronger pick at the same VRAM. If your sessions lean on MCP servers, web research, multi-file coordination, or screenshot input — Muse Glimmer is the first local model in this class trained specifically for that shape of work, and it’s also a stronger sub-agent brain than the 12B-class models we’ve covered for smaller cards.

The cost math: don’t buy a GPU for this

The queue question every local-model article has to answer: at what volume does a 24GB GPU beat the cheapest capable API? Right now the answer is more lopsided than usual.

DeepSeek V4-Flash — still the default budget BYOK backend, and recently updated — costs $0.14/M input (cache-miss), $0.28/M output, with cache hits at $0.0028/M, verified against current pricing pages today. A heavy solo Cline habit of 500K tokens/day (400K in, 100K out), assuming zero cache hits, is:

• API: (0.4M × $0.14) + (0.1M × $0.28) = $0.084/day ≈ $2.52/month
• Local RTX 4090: ~350W under inference load × 2 hours of active generation/day = 0.7kWh × $0.1883/kWh ≈ $0.13/day ≈ $3.95/month in electricity alone — before amortizing an ~$1,800 card

The electricity bill exceeds the API bill. Even at 10× that token volume, the API is ~$25/month while the GPU adds ~$450 in hardware amortization over its first year. There is no realistic solo-developer volume where a new 24GB GPU purchase pays for itself against V4-Flash’s current prices.

The reasons to run Muse Glimmer locally are the other ones: your code can’t leave the machine, you want zero rate limits on always-on agents (Meta’s explicit “always-on local agent workflows” pitch), you need offline capability, or you already own the card — in which case the marginal cost really is pocket change. One forward-looking note: DeepSeek announced on August 6 that a significant API price increase is coming, with no figure or date yet. A 5× hike changes this table meaningfully; we’ll re-run the math when numbers land. For GPU selection by VRAM tier, our sister site’s local model VRAM guide covers the hardware side, and if you’re weighing Ollama itself against alternatives, aifoss.dev’s Ollama review is the deep dive.

If you do go shopping: a used RTX 3090 hits the 24GB floor at the lowest price, and the RTX 4090 buys roughly double the token throughput plus headroom for the dflash drafter at longer contexts.

Where it breaks

Three failure modes to know before you commit an afternoon:

The pre-release window (this week). NVIDIA/AMD Ollama users are on v0.32.8-rc0 or a llama.cpp detour until the stable release lands. If your stack is “Ollama stable + RTX card,” today you’re one rc-install away, and rc builds have their own risks in an agent stack you leave running overnight.

Broken third-party quants. The oMLX issue above won’t be the last. The symptom signature — model reasons, then stops without calling tools, at degraded speed — means a bad checkpoint, not a configuration error. Official tags first.

VRAM pressure at agent context. 18GB of weights + 64K of KV cache + the vision encoder + the drafter is a tight fit on 24GB. If you see silent CPU fallback and single-digit tokens/second, it’s the same class of problem as Ollama not using your GPU — check ollama ps for a 100% GPU layer split before blaming the model, and drop to the 17GB-class quant or a 48K context if you’re spilling.

FAQ

Does Muse Glimmer support standard OpenAI function calling? Not natively — it emits XML-style ATEM tool-call blocks. Ollama (v0.32.7+), LM Studio, and vLLM (with the muse_glimmer parsers) translate these to OpenAI-format tool_calls, so Cline and Cursor work normally through those runtimes. Raw API access to an unparsed endpoint will hand you XML.

Can I use it commercially in client work? Yes. Apache 2.0 — no Llama-style acceptable-use policy, no user-count clause. This is Meta’s most permissive model license to date.

Is it better than Qwen3.6-27B for coding? For plain code generation and terminal-driven SWE tasks, no — Qwen3.6-27B scores higher on SWE-Bench Verified (77.2 vs 76.0, Meta’s own table) and Terminal-Bench. For tool-heavy agentic sessions, MCP orchestration, and anything involving images, Muse Glimmer is the stronger pick.

What Mac do I need? The 4-bit builds want ~20GB of memory headroom, so a 32GB unified-memory M-series machine is the practical floor; Meta measured DFlash speedups on M4 Max and M5 Max. Apple Silicon is currently the best-supported Ollama path, not the afterthought.

Will it run on a 12GB or 16GB card? Not usefully. The smallest credible build is unsloth’s 15.9GB UD-Q4_K_XL, which still needs KV cache on top. On 12–16GB cards, stay with the 12B class — our Mellum 2 guide covers that tier.

Recommended Gear

• RTX 3090 — cheapest 24GB entry point for the K-Quant-17GB build
• RTX 4090 — 24GB with roughly 2× the inference throughput and DFlash headroom

Sources

• Introducing Muse Glimmer — Meta AI Research (official announcement)
• meta-models/Muse-Glimmer-30B — Hugging Face model card
• Muse Glimmer — Ollama library (tags, capabilities)
• Ollama releases v0.32.7 / v0.32.8-rc0 — GitHub
• Muse-Glimmer-30B-oQ4e tool calling broken — jundot/omlx issue #2589
• unsloth/Muse-Glimmer-30B-GGUF — Hugging Face
• Meta AI Releases Muse Glimmer — MarkTechPost (benchmark table)
• Meta returns to open source with Muse Glimmer — VentureBeat
• DeepSeek API pricing (V4-Flash current rates) — BenchLM.ai
• Muse Glimmer HN discussion

Last verified August 11, 2026. Pricing, model availability, and runtime support change frequently — verify current state before building on any of it.