Meta Muse Spark 1.2 and Muse Glimmer 30B for MCP: Strengths, Benchmarks and Trade-offs

Meta released two models within a week of each other in August 2026, and the interesting thing is the relationship between them. Muse Spark 1.2 is a closed, API-only reasoning model with a million-token context window. Muse Glimmer 30B is an Apache 2.0 open-weights model distilled from Spark that runs on a single consumer GPU. One is the teacher, the other is the student, and for anyone building on MCP the student is arguably the more interesting release.

This guide covers what each model actually is, what the published benchmarks say about tool calling, and — just as importantly — which questions the public record does not answer yet.

The benchmark that matters for MCP

Most model launches give you MMLU and a coding score, neither of which tells you whether the model will drive your MCP server competently. Both Muse models are unusual in carrying a number on MCP-Atlas — a benchmark built by Scale AI specifically to measure Model Context Protocol tool use.

It is worth knowing what that benchmark actually tests, because it is not simple function calling. MCP-Atlas runs 1,000 tasks across 36 real MCP servers and 220 tools, at three to six tool calls per task. Models have to discover the right tool from a limited set, call it with correct parameters, handle errors, coordinate across servers, and synthesise the results into an answer. That is a far closer proxy for production agent work than a single-shot function call, and it is the reason these scores are worth more than the usual launch-day table.

Muse Spark tops the public leaderboard

On Scale AI's published leaderboard, Muse Spark 1.1 ranks first at 88.1%. The company it keeps is the striking part:

Model	MCP-Atlas pass rate
Muse Spark 1.1	88.1%
Claude Opus 5 (xhigh)	85.8%
Gemini 3.5 Flash (high)	83.6%
Claude Fable 5	83.3%
Kimi K3 (max)	82.3%
Claude Opus 4.8 (max)	82.2%

Two caveats matter, and they are not small. The leaderboard was last updated in April 2026, so the ranked entry is Spark 1.1, not the 1.2 release this guide covers — and Glimmer, which launched in August, is not on it at all. Read the ranking as strong evidence that the Muse line is genuinely good at MCP work, not as a verified score for the exact build you are calling today.

What Meta reports for Glimmer

Glimmer's numbers come from Meta's own launch materials rather than the independent leaderboard, so treat them as a vendor comparison. The comparison set is at least the honest one: the two open models most people would otherwise run locally. Note the conditions Meta publishes alongside them — Glimmer at High Reasoning, Gemma4-31B and Qwen3.6-27B in Thinking Mode. These are all best-effort configurations, not defaults, which is a point we will come back to.

Benchmark	Muse Glimmer 30B	Qwen3.6-27B	Gemma4-31B
MCP-Atlas	75.5	62.5	54.2
DeepSearch QA	74.6	71.1	61.7
SWE-Bench Pro	51.2	50.2	36.9
SWE-Bench Verified	76.0	77.2	66.6
τ²-Banking	23.5	16.7	15.1
GAIA2	43.3	40.0	36.4
TerminalBench 2.1	51.7	60.7	43.4
OSWorld-Verified	65.9	75.6	58.5

The pattern in that table is the honest part of the picture, and it is sharper than "Glimmer wins." Glimmer's advantage is specifically protocol-shaped agentic work: discovering tools, invoking schemas correctly across a long workflow, and recovering when a call fails. On MCP-Atlas the gap over Qwen is 13 points, and on τ²-Banking it is a relative rout.

But Qwen3.6-27B beats it on SWE-Bench Verified (77.2 to 76.0), on TerminalBench 2.1 (60.7 to 51.7) and on OSWorld-Verified (75.6 to 65.9) — and those last two are not close. The reading that fits all of it: Glimmer is tuned for calling tools through a protocol, not for driving a terminal or a desktop. If your agent's job is "use my MCP server correctly," that is the axis it wins on. If your agent's job is "operate a computer," Qwen is the stronger open model at this size.

If your workload is "call my tools in the right order and do not mangle the arguments," that is the tension worth knowing about.

For rough calibration: if Meta's 75.5 were directly comparable to Scale's scale, it would land Glimmer around the GLM 5.1 and Claude Opus 4.6 band (75.6% and 76.8%) — remarkable for a 30B model you can run at home. The two measurements may not be strictly comparable, so treat that as a sense of scale rather than a ranking.

Muse Glimmer 30B, in detail

Glimmer is a dense causal transformer — not a mixture of experts — at roughly 29.6B parameters, and that total includes a 1.8B ViT-G/14 perception encoder for vision. The published shape is 52 layers, a hidden dimension of 6,656, and SwiGLU feed-forward blocks at 19,968 intermediate width.

Two architectural choices stand out for anyone running it:

• Grouped-query attention at a 16:1 ratio — 32 query heads against 2 key/value heads. That is an aggressive ratio, and it is what keeps the KV cache small enough for long agentic sessions on consumer memory.
• A repeating [Local, Local, Local, Global] attention pattern with a 2,048-token sliding window. Three cheap local layers for every global one, which is again a memory-shaped decision rather than a quality-shaped one.

Context is 131,072 tokens by default, extendable to 262,144. It accepts interleaved text and images through the perception encoder, so screenshots, charts and documents are all in scope.

The license is Apache 2.0, which is genuinely permissive — this is not a bespoke community license with a user-count clause attached.

How it was trained, and the one claim worth testing

Meta describes three phases: logit distillation from Muse Spark during pre-training on comparable data distributions; a mid-training phase on extended-context, agent-focused data with enriched reasoning traces; and post-training that blends supervised fine-tuning with on-policy distillation and reinforcement learning across general, reasoning, coding and agentic domains.

Buried in that is the most concrete and most checkable claim Meta makes about tool use: "when a tool call fails or returns an unexpected result, the model is trained to diagnose the error and retry rather than halt."

That is unusually falsifiable for launch-day copy, and it is the behaviour that separates a model you can leave running from one that needs a human every time an endpoint hiccups. It is also trivial to test — point the model at a server that deliberately returns errors and watch whether it diagnoses and retries, or gives up and apologises. Do that before you trust it with a long workflow.

It actually runs on your machine

At full precision Glimmer needs more than 55GB. Quantized to about 4-bit it drops under 20GB, which leaves headroom for the KV cache, the perception encoder and speculative decoding inside a 24GB or 32GB budget. Meta reports "minimal to no degradation on agentic tasks" from that compression — worth verifying on your own tools, but a meaningful claim given how much of the appeal rests on it.

Meta also ships DFlash speculative decoding: a lightweight drafter proposes blocks of tokens and the main model verifies them in parallel, accepting what is right and correcting what is not. Output quality is identical by construction; the measured speedup is 3.1x on an RTX 5090, 1.8x on an M5 Max and 1.5x on an M4 Max.

Runtime support at launch covers Ollama, LM Studio, llama.cpp, MLX, ExecuTorch, vLLM and SGLang. For MCP specifically this matters more than it looks: an MCP server plus a local model means tool calls that never leave the machine, which is a real answer for teams whose tools touch data that cannot go to a cloud endpoint.

The number nobody puts in a headline

Meta also publishes safety results, and one row deserves attention from anyone exposing tools to a model. On Siren AgentDojo, a prompt-injection benchmark, Glimmer records a 28.4% attack success rate at 94.2 utility. Gemma4-31B is better at 25.6% (utility 90.8); Qwen3.6-27B is worse at 40.3%.

Lower is better, and none of these are comfortable. Roughly one in four injection attempts lands against the best of the three. If your MCP server returns any content that originated outside your control — search results, file contents, third-party API responses — that content reaches the model, and these numbers are the empirical odds that it can steer it. Model choice mitigates the risk; it does not remove it. The controls that matter still live on your side of the boundary.

Muse Spark 1.2, in detail

Spark is a different animal. It is closed-weights and API-only, and its headline is a 1,048,576-token context window with roughly 131,072 tokens of output. It accepts text, images, video, audio and PDF, and returns text.

For agent builders the relevant capabilities are structured output, parallel function calling and configurable reasoning effort. Meta describes it as designed for multi-agent workflows in either role — a primary agent that plans and delegates, or a subagent executing in parallel — and it leans on planning, goal conditioning and context compaction to hold direction through long tasks.

The workloads it is pitched at are multi-file refactors, extended debugging sessions and whole-repository generation. That is a coding-agent profile, and Meta shipped a coding agent called Muse Code alongside it.

The cost shape is unusual

Spark 1.2 is priced at $1.25 per million input tokens and $4.25 per million output. Ordinary chat-sized requests are inexpensive. But a million-token context window is an invitation to send enormous inputs, and a 200,000-token prompt costs $0.25 in input alone before the model writes a word.

This is worth internalising if you are budgeting agent runs: with most models, cost tracks roughly with how much work the model does. With a 1M-context model, cost tracks with how much context you chose to send, and that is a decision you control at design time. Compaction is a feature for a reason.

What the public record does not tell you

Here is the gap, stated plainly, because a lot of coverage papers over it.

Meta has not published the tool-calling wire format for either model. The developer pages and the model card both assert reliable tool use and precise schema invocation, but neither specifies the serialization — whether tool calls are emitted as JSON blocks, whether there is a bespoke delimiter scheme, how parallel calls are framed. The vLLM and SGLang examples simply use an OpenAI-compatible API surface.

Practically, that means:

• Routed through a provider like OpenRouter, both models present as OpenAI-shaped function callers, which is the same translation path used by every non-Anthropic model in a typical MCP client.
• Claims you may read about how these models handle deeply nested arguments, or how their translation layer differs from other vendors', are not currently supported by published documentation. Treat them as untested until you have run your own schemas.

This is exactly the sort of thing worth measuring against your own server rather than taking on faith, which is the entire premise of pointing a live client at your endpoint and watching what comes back.

Documented quirks and gotchas

These are from Meta's own materials and the community runtimes, not speculation:

• Reasoning effort is not cosmetic, and the benchmarks prove it. Glimmer exposes low, medium, high and xhigh, and every number in Meta's comparison table was produced at High Reasoning (with the rival models in Thinking Mode). Meta recommends high or xhigh for agentic and coding work. Evaluate at low effort and you are simply not testing the model those numbers describe.
• Sampling defaults are specific: temperature 1.0, top_p 0.95, top_k 64. Carrying over a temperature 0.2 habit from another model is a real source of "it did worse for me" reports.
• No audio on Glimmer. Spark takes audio; Glimmer does not. If your pipeline assumes parity between the two, that assumption breaks.
• Video is processed as individual frames on Glimmer, which is not explicitly optimized for video.
• NVFP4 quantization is not working — flagged as a work in progress in the community runtime docs at launch. Use a supported quant.
• Quantized inference shows minor quality differences in edge cases, per the model card. For agentic tool selection, edge cases are the interesting part.
• Language coverage is broad but uneven — trained across 100+ languages, with degradation outside the strongly-supported set.

Which one should you point at your MCP server?

The choice is unusually clean, because these models are not competing with each other:

• Choose Glimmer when you want a model you can self-host, when tool calls must stay on your own hardware, or when you are benchmarking whether an open 30B is good enough to replace a frontier model on your specific tools. The MCP-Atlas number says it deserves the audition.
• Choose Spark 1.2 when the task genuinely needs the context — whole-repository work, long debugging sessions, multi-agent orchestration where a planner holds a large working set — or when you want parallel function calling across many tools at once.

The distillation relationship is the useful mental model. Glimmer inherits Spark's agentic behaviour in a package you can run locally; Spark keeps the scale, the context and the modalities that will not fit on a laptop.

Testing this against your own server

Benchmarks are aggregate. Your server has specific tool names, specific descriptions and specific argument shapes, and those are what determine whether a model selects the right tool and fills it in correctly.

The fastest honest test is to connect the model to your real endpoint and watch the tool calls: which tool it picks, what arguments it constructs, and what it does when a call returns an error. A model that scores well on an agentic benchmark and still fumbles your particular nested schema is a result you want before you ship, not after.

You can run both Muse models against your own MCP server in the browser on the test your MCP server with Meta Muse page — no local install required, and no Meta account.

FAQ

Is Muse Glimmer really open source?
The weights are released under Apache 2.0 and hosted on Hugging Face, which is a genuinely permissive license — commercial use, modification and redistribution are all allowed without a user-count threshold or a bespoke acceptable-use addendum.

Can Muse Glimmer run an MCP server locally with no network access?
Yes. Quantized to roughly 4-bit it fits under 20GB and runs through Ollama, LM Studio, llama.cpp, MLX, vLLM and others. Paired with a locally-running MCP server, the entire loop — prompt, tool call, tool result — stays on your hardware.

Is Muse Spark 1.2 open-weights like Glimmer?
No. Spark is closed and available through the API only. Glimmer is the open model, and it is distilled from Spark rather than being a smaller checkpoint of it.

Which Muse model is better at MCP tool calling?
Spark, on the evidence available. Muse Spark 1.1 ranks first on Scale AI's independent MCP-Atlas leaderboard at 88.1%, ahead of Claude Opus 5. Glimmer's 75.5 is Meta's own reported figure and is not on that leaderboard, so the two numbers are not strictly comparable — but nothing in the published record suggests the distilled 30B beats its teacher. Glimmer's case is that it gets close enough to matter while running on your own hardware.

How does Muse Glimmer compare to Qwen3.6-27B and Gemma4-31B?
Glimmer leads clearly on agentic and MCP benchmarks (75.5 vs 62.5 and 54.2 on MCP-Atlas) and modestly on SWE-Bench Pro, but Qwen3.6-27B edges it on SWE-Bench Verified at 77.2 to 76.0. The pattern is that Glimmer is tuned for tool use and long tasks rather than raw single-shot code editing.