On October 15, Meta released the weights of Muse Spark Open, an 816-billion-parameter model it calls “the most capable US open-weight model to date”. Within a day it was the most-discussed AI release of the week, and the obvious question followed: is it better than the Chinese open-weight models that have set the pace all year, GLM 5.3 from Z.ai and Kimi K3 from Moonshot AI?
The short answer is no, and the qualifier in Meta’s headline is the reason. On the independent Artificial Analysis index, Muse Spark Open scores 39, GLM 5.3 45 and Kimi K3 44. But the long answer is more useful: Muse Spark Open costs less than half as much per task as either rival, runs faster, reads audio and video, and leads both on tool use. This comparison puts every number the three vendors and Artificial Analysis have published side by side: independent scores, Meta’s benchmark table, cost per task, the GPU memory each model needs, and the license clauses that decide whether you can ship it.

Muse Spark Open vs GLM 5.3 vs Kimi K3 at a Glance
The specifications come from the Muse Spark Open model card, GLM 5.3 model card and Kimi K3 model card; scores, speed and prices from Artificial Analysis.
| Muse Spark Open | GLM 5.3 | Kimi K3 | |
|---|---|---|---|
| Vendor | Meta (USA) | Z.ai (China) | Moonshot AI (China) |
| Weights released | October 15 | August | July |
| Total parameters | 816B | 753B | 2.8T |
| Active per token | 42B | 40B | 104B |
| Experts per token | 8 of 256 | n/a | 16 of 896 |
| Input | Text, images, audio, video | Text | Text and images |
| Context window | 1M | 1M | 1M |
| Artificial Analysis Intelligence Index | 39 | 45 | 44 |
| Output speed (tokens per second) | 102 | 67 | 43 |
| Cost per Artificial Analysis task | $0.84 | $2.01 | $2.00 |
| API price per million tokens (input / output) | $1.25 / $4.25 | $1.40 / $4.40 | $3.00 / $15.00 |
| Released precision | BF16 and NVFP4 | FP8 | MXFP4 |
| Reasoning | Always on: low / medium / high / xhigh | low / high / max | Always on: low / high / max |
| License | Muse Model License | GLM 5.3 License (MIT-style) | Kimi K3 License |
Three rows explain most of what follows. Intelligence Index says the Chinese models are smarter. Cost per task says Meta’s is cheaper to run. Input says Muse Spark Open is the only one of the three that can listen to a voice note or watch a screen recording.
Muse Spark Open doesn’t win this comparison on intelligence. It wins on what intelligence costs: 39 points for 84 cents a task, against 44 or 45 points for about two dollars.
What Meta Actually Released
Muse Spark Open is the downloadable version of Muse Spark, the model family from Meta Superintelligence Labs that Meta has so far offered only through its own API. It is a mixture-of-experts model: 256 experts per layer, a router that picks 8 for each token, so about 42 billion of the 816 billion parameters do the work for any one token. It reads text, images, audio and video and writes text, with a 1-million-token context window. According to the model card, the training data covers more than 100 languages.
Meta built it for coding and agents. In the launch post, Muse Code, Meta’s coding agent, runs on Muse Spark Open entirely on two Mac Studios: it ships bug fixes and features to Ice Cubes, an open-source iOS Mastodon client, and drives DaVinci Resolve end to end, reviewing footage frame by frame. The Hugging Face announcement adds a browser agent that sees only screenshots, with no DOM or HTML.
Two details matter in practice:
- Reasoning can’t be switched off. You choose
low,medium,highorxhigh, and the default isxhigh. For simple tasks, setlowexplicitly or you pay for thinking you don’t need. - It is the big sibling of Muse Glimmer. Glimmer, released in August, is a small dense 30-billion-parameter model under Apache 2.0, built for running locally. Both share a tokenizer, and Spark Open is the largest Muse model you can download. The hosted Muse Spark versions and Meta’s flagship Muse Wonder stay behind Meta’s API.
Independent Benchmarks: What Artificial Analysis Measured
Vendor tables compare models on the benchmarks the vendor picked. Artificial Analysis runs the same ten evaluations on every model, including Terminal-Bench 4.0, Humanity’s Last Exam, GDPval-AA and AA-LCR, and combines them into one Intelligence Index. Its results at each model’s default reasoning setting:
| Artificial Analysis | Muse Spark Open (xhigh) | GLM 5.3 (max) | Kimi K3 (max) |
|---|---|---|---|
| Intelligence Index | 39 | 45 | 44 |
| Rank among 119 comparable models | 10 | 2 | 4 |
| Output tokens to run the index | 110M | 210M | 160M |
| Output speed | 102 tokens/s | 67 tokens/s | 43 tokens/s |
| Cost per Intelligence Index task | $0.84 | $2.01 | $2.00 |
Tenth place sounds worse than it is. Artificial Analysis groups 119 models as comparable to these three; the median score in that group is 19, so all three sit far above it. GLM 5.3 ranks second, Kimi K3 fourth.
In that group, only Xiaomi’s MiMo-V2.6-Pro scores higher than all three, at 46. So the precise version of Meta’s claim is the one in its headline: Muse Spark Open is the strongest open-weight model from a US lab. Meta’s own table backs that, with Nvidia’s Nemotron 3 Ultra at 23 and Inkling at 26.

Where Muse Spark Open Wins and Where It Loses
Meta’s model card compares Muse Spark Open with seven open-weight models, including Mistral Large 4, Beam and Qwen3.8. These are the rows for GLM 5.3 and Kimi K3:
| Meta’s benchmark table | Muse Spark Open | GLM 5.3 | Kimi K3 |
|---|---|---|---|
| MCP-Atlas (tool calling) | 89.2 | 84.2 | 82.3 |
| JobBench (agentic work tasks) | 61.8 | 61.4 | 54.3 |
| HLE-Diamond, no tools (reasoning) | 26.1 | 16.4 | 22.2 |
| AA-Omniscience (knowledge minus hallucination) | 25 | 14 | 20 |
| Toolathlon Verified | 72.8 | 73.0 | 76.5 |
| SciCode | 58.5 | 59.0 | 59.5 |
| HLE with tools | 61.0 | 62.5 | 56.0 |
| GPQA Diamond | 89.0 | 91.7 | 93.5 |
| Terminal-Bench 2.1 | 76.4 | 83.9 | 85.0 |
| DeepSWE 1.1 | 60 | 67 | 68 |
| SWE-Atlas-QnA | 58 | 59 | 66 |
| GDPval-AA v2 (Elo) | 1,401 | 1,653 | 1,537 |
The pattern is consistent. Muse Spark Open is strongest where an agent calls tools and reasons without them: it leads MCP-Atlas by five points, and on HLE-Diamond without tools it beats GLM 5.3 by almost ten. Its AA-Omniscience lead means it hallucinates less relative to what it knows. It is weakest where an agent writes and runs code for a long time: on Terminal-Bench 2.1 it trails Kimi K3 by almost nine points, and on DeepSWE by eight. On professional knowledge work (GDPval-AA) GLM 5.3 is far ahead.
On images, only Kimi K3 is a fair opponent, because GLM 5.3 doesn’t read them. Meta’s table splits that matchup: Muse Spark Open leads on ZeroBench (50.0 vs 41.0), SimpleVQA (73.6 vs 71.9) and IntPhys2 (68.3 vs 60.3), while Kimi K3 leads on BabyVision (85.7 vs 80.2), VideoMME v2 (65.4 vs 61.5) and OSWorld Verified computer use (84.8 vs 80.4).

The Harness Problem: Same Benchmark, Different Numbers
Look closely at Terminal-Bench 2.1. Meta ran every model in the same agent, Terminus 2, and reports 83.9 for GLM 5.3 and 85.0 for Kimi K3. The vendors’ own cards report 88.2 for GLM 5.3 and 88.3 for Kimi K3, both measured in Claude Code. The models didn’t change; the agent around them did.
That’s not a scandal, it’s how agentic benchmarks work: the harness is part of the result. Z.ai’s own card even lists Kimi K3 at 88.3 in Claude Code, matching Moonshot. It cuts both ways, too. Muse Spark Open’s 76.4 is also a Terminus 2 number, and Meta hasn’t published a Claude Code score. Two practical rules follow:
- Compare numbers from one table, never across tables. Meta’s table is internally consistent; mixing it with vendor cards isn’t.
- Test in your own agent. If your team runs Claude Code, opencode or Codex, the ranking you care about is the one inside that tool. My comparison of opencode, Codex and Claude Code explains why the harness changes so much.
The Real Price: Tokens Written, Not Price per Token
On price lists, Muse Spark Open and GLM 5.3 look almost identical: $1.25 against $1.40 per million input tokens, $4.25 against $4.40 per million output tokens. Kimi K3 is clearly more expensive at $3.00 and $15.00. Yet Artificial Analysis measured the same work at $0.84 for Muse Spark Open and $2.01 for GLM 5.3.
The difference is how much each model writes. To complete the Intelligence Index, GLM 5.3 produced 210 million output tokens, Kimi K3 160 million and Muse Spark Open 110 million. With always-on reasoning, the thinking tokens are most of that, and you pay for every one. Cache discounts add a little: 88% for Muse Spark Open against 81% for GLM 5.3.
That changes how to read model prices. A cheaper price per token means little if the model thinks twice as long; the number that predicts your bill is cost per finished task on your own workload. The same logic decides whether Claude Haiku 5.5, Sonnet 5.5 or Opus 5.5 is cheaper for a given job.
Three caveats before you plan around $0.84:
-
None of the three is cheap. Artificial Analysis puts the median price of comparable models at $0.43 per million input tokens and $1.59 per million output tokens. Muse Spark Open is the cheapest of these three, not of the market.
-
Prices depend on the host. The figures above are Together AI’s for Muse Spark Open and the vendors’ own APIs for GLM 5.3 and Kimi K3. Fireworks, Groq, Baseten, Modal, Nebius and OpenRouter also host Muse Spark Open with their own prices and limits; Groq, for example, caps the context at 131,072 tokens instead of 1 million.
-
Speed is provider speed. 102 tokens per second is what Artificial Analysis measured through the API. On your own hardware, throughput depends on the GPUs and the serving stack.
What It Takes to Self-Host Each Model
All three are open-weight, but “open” covers very different hardware budgets. Mixture-of-experts models must keep every expert in memory, even though each token only uses a few, so total parameters decide the memory and active parameters decide the speed.
| Self-hosting | Muse Spark Open | GLM 5.3 | Kimi K3 |
|---|---|---|---|
| Released weights | NVFP4 and BF16 | FP8 | MXFP4 (quantization-aware trained) |
| Memory for the weights | ≥700 GB (NVFP4), 2 TB (BF16), per Meta | ~753 GB at FP8 (my arithmetic) | ~1.56 TB checkpoint |
| Smallest datacenter setup | 1 node of 8× B200 (NVFP4), 8× H200 for 1M context | 1 node of 8× H200 (my estimate) | More than 8× B200; 8× B300 or two nodes (my estimate) |
| On a Mac | 2× Mac Studio M5 Ultra, 512 GB each (Meta); 3-bit on one 512 GB M3 Ultra at ~21 tokens/s | Community quantizations only | Not realistic |
| Serving engines | SGLang, vLLM, TensorRT-LLM, Transformers, MLX, llama.cpp, Unsloth | SGLang, vLLM, TokenSpeed, Transformers, KTransformers, Unsloth, Ascend NPUs | vLLM, SGLang, TokenSpeed |
Where a cell says “my arithmetic” or “my estimate”, it’s weights at the released precision divided by GPU memory: 8× H200 gives 1,128 GB, 8× B200 1,440 GB. The KV cache and activations come on top. For Muse Spark Open, Hugging Face calculates about 250 KB of KV cache per token in BF16, or 266 GB for a full 1-million-token context. That’s why the 8×H200 endpoint is the one Hugging Face recommends for the full window.

The Mac Studio story is real but narrow. Two 512 GB Mac Studios with M5 Ultra hold the whole model in unified memory, and Hugging Face measured 21 tokens per second for a 3-bit version on a single M3 Ultra. That works for one developer at a time, not for a team. Apple’s 512 GB M5 Ultra configuration also isn’t on sale yet, so for now a rented GPU node or an API is the practical route. For what quantization does to quality, and when 3-bit is still acceptable, see my guide to quantization; for choosing a serving stack, vLLM vs Ollama.
Licenses: The Fine Print That Decides Commercial Use
All three licenses start like MIT: free to use, copy, modify, fine-tune and redistribute. Each one then adds conditions, and they differ more than the benchmarks do.
| License clause | Muse Spark Open | GLM 5.3 | Kimi K3 |
|---|---|---|---|
| Free commercial use | Yes, with conditions | Yes | Yes, with conditions |
| Attribution in your product | Always: “Built with Muse Spark Open” in the UI, docs, website or settings | Copyright notice in copies only | “Kimi K3” on the UI above 100M monthly users or $20M monthly revenue |
| Model-as-a-service threshold | Above $20M annual revenue: separate agreement with Meta | Above $10 billion annual revenue: Z.ai security review | Above $20M annual revenue: separate agreement with Moonshot |
| Download gate on Hugging Face | Legal name, date of birth, company details | None | None |
The practical reading:
- GLM 5.3 is the most permissive. Its only real condition applies to companies selling model access with more than 10 billion dollars in revenue. For everyone else it behaves like MIT.
- Muse Spark Open asks for visible credit everywhere. Every product that uses it must show “Built with Muse Spark Open” somewhere, and the license counts any model trained, fine-tuned or distilled with its outputs as a derivative under the same terms. A Usage Policy is part of the license; it rules out military and ITAR-related uses, operating critical infrastructure, and use by people under 18.
- Kimi K3 sits in between. Internal use is exempt, and so is use through Moonshot’s official products or certified inference partners.
The model-as-a-service clauses matter if you resell inference: an AI platform, an API reseller, a SaaS that exposes raw model access. If you embed the model inside your own product’s features, all three licenses exempt you.
Safety: Fewer Jailbreaks, More Refusals
Meta added extra safety post-training to the open version, and its model card measures the difference against the same rivals:
| Meta’s safety evaluations (lower is better) | Muse Spark Open | GLM 5.3 | Kimi K3 |
|---|---|---|---|
| StrongREJECT v2, adaptive jailbreaks | 0.5 | 62.9 | 66.6 |
| FORTRESS adversarial risk score | 5.8 | 28.2 | 26.7 |
| FORTRESS over-refusal score | 17.4 | 3.2 | 2.7 |
The first two rows say Muse Spark Open is far harder to jailbreak. The third row is the price: it refuses benign requests five to six times as often as the Chinese models. Meta also reports that Muse Spark Open refused 99.2% of cyber-misuse jailbreaks on its internal benchmark, against 75.5% for Kimi K3.
GLM 5.3 sits at the other end. Z.ai writes that as it scaled post-training, “cyber capability developed faster than we expected”, and reports state-of-the-art results on CyberGym vulnerability discovery (84.5). For a red team, that is a feature; for a customer-facing assistant, it means your own guardrails carry more of the load. Whichever you pick, Meta’s advice applies to all three: deploy the model inside a system with guardrails, and keep a human confirmation step before irreversible actions.
Which One Should You Use?
| If your priority is… | Choose | Why |
|---|---|---|
| Agents that mostly call tools and APIs | Muse Spark Open | Highest MCP-Atlas and JobBench scores, fastest, cheapest per task |
| Audio, video or screen recordings as input | Muse Spark Open | The only one of the three that reads audio and video |
| A strict jailbreak profile for a public-facing app | Muse Spark Open | Lowest jailbreak scores in Meta’s evaluation, at the cost of more refusals |
| Long autonomous coding sessions | Kimi K3 | Best Terminal-Bench, DeepSWE and SWE-Atlas scores |
| The smartest open model with the simplest license | GLM 5.3 | Highest Intelligence Index, MIT-style license, fits one 8×H200 node |
| Security research and vulnerability work | GLM 5.3 | Strongest published cyber results of the three |
| A model one developer can run at home | Muse Spark Open | Officially supported on Mac Studio with MLX; GLM 5.3 needs community quantizations, Kimi K3 doesn’t fit |
If none of these is decisive, run your own top 20 tasks through all three on a hosted API before you buy hardware. At these prices that costs less than an hour of an engineer’s time, and it’s the only benchmark that uses your harness, your prompts and your definition of done.
The Bottom Line
Muse Spark Open is the strongest open-weight model from a US lab, and Meta’s headline is precise about that. It isn’t the strongest open-weight model: GLM 5.3 and Kimi K3 score higher on the independent index and clearly higher on long coding tasks. What Meta built instead is the most efficient of the three. It answers in about half the tokens, runs faster, costs about 2.4 times less per task, reads audio and video, and is the hardest to jailbreak.
That makes the choice simple to state. If the work is coding, Kimi K3 or GLM 5.3 will do it better. If the work is agents calling tools at scale, or anything multimodal, Muse Spark Open will do it well enough for much less. Check the license before you ship: the “Built with Muse Spark Open” notice is not optional.
See how the European open-weight models compare in my comparison of Mistral Large 4, Kolibri and Beam, including the hardware each one needs.






From the community
Discussion on Mastodon & Bluesky
Replies to this article from the open web, pulled in live. No ads, no tracking scripts.
Reply there — it shows up here automatically.