Muse Spark Open vs Muse Wonder: One You Can Download, One You Can Only Rent

Meta put Muse Wonder on the market on October 12, 2026 and put M​use Spark Open on Hugging Face three days later, on October 15. They are not two versions of the same product. Muse Wonder is a closed frontier model you reach through an API or a subscription; M​use Spark Open is a gated download that arrives as 816 billion parameters of mixture-of-experts weights, a licence, and a hardware decision. Comparing them on a leaderboard is therefore the wrong first move, because the leaderboard measures capability and the thing that separates them is who owns the machine. This piece works through both — the measured gaps, what they cost per unit of work, and the four situations in which the answer flips — using the numbers that are actually published, with a note wherever a number is a vendor claim rather than a measurement.

Three days apart, and not in the same category

The release order matters more than the release dates. Muse Wonder shipped first as two checkpoints: muse-wonder-1.0, served on Meta's Model API and inside Muse Code, and muse-wonder-full-1.0, which Meta sells only through a Muse Code subscription and does not expose as an API model. M​use Spark Open shipped next as a single artefact: a BF16 checkpoint and an NVFP4 build behind an access-controlled repository, a model card, a technical report, and the Muse Model License. One of those is a service. The other is a file.

Everything downstream follows from that. A closed model's price is whatever the vendor says it is, and its capability can be revised by the vendor at any time. An open model's price is a capital number — the GPUs, the power, the engineer — and its capability is what your serving stack can extract from it. So the useful comparison is not "which scores higher," which is not close, but "which of these two costs you less to reach the capability you need," which depends entirely on what you already own and what you are allowed to do with the weights.

Both models take text, images, speech and video in and produce text out, and both advertise a context window of 1,048,576 tokens. That is where the resemblance ends.

The scoreboard as it stands today, not as you remember it

Artificial Analysis reworked its Intelligence Index, and the current version is v5.0.1, which incorporates nine evaluations: AA-Briefcase v1.1, AutomationBench-AA, Terminal-Bench 4.0, FrontierCode-AA 2.0, AA-Omniscience v1.1, GDP.pdf, HLE-Diamond, CritPt v2 on its hard subset, and Terminal-Bench-Science 0.1. That matters for this comparison because any figure you read about either model before this revision is not on the same scale as the figures below. Both entries were re-scored inside the same suite, so the gap between them is comparable even though their absolute values are not comparable to older numbers you may have seen for either.

On that revision, M​use Spark Open (Xhigh) scores 25 against a median of 23 among other open-weight models of similar size — above average, but not by much. Muse Wonder (Max) scores 44 against a median of 40 among models in a similar price tier. Nineteen points is not a rounding difference, but it is also not the whole story, because the two medians describe two different comparison sets: one is a small class of same-size open models, the other a broader and more expensive tier. What the pair does establish cleanly is that each model is above its own peer group, which is a more useful statement than a rank and considerably harder to game.

The per-evaluation rows say the same thing with more resolution. Each line below carries both sides on the same dimension, in the same order, so they can be read as a pair rather than as two separate claims.

• Index, v5.0.1 — M​use Spark Open 25 at Xhigh effort, against a class median of 23; Muse Wonder 44 at Max effort, against a class median of 40

• AA-Briefcase v1.1 (agentic knowledge work, Elo) — 1,278.7 for M​use Spark Open; 1,658.7 for Muse Wonder

• AutomationBench-AA (agentic SaaS workflows) — 0.497 for M​use Spark Open; 0.681 for Muse Wonder

• Terminal-Bench 4.0 — 0.081 for M​use Spark Open; 0.520 for Muse Wonder

• FrontierCode-AA 2.0 — 0.076 for M​use Spark Open; 0.240 for Muse Wonder

• HLE-Diamond — 0.263 for M​use Spark Open; 0.390 for Muse Wonder

• CritPt v2, hard subset — 0.295 for M​use Spark Open; 0.505 for Muse Wonder

• GDP.pdf, all-pass — 0.186 for M​use Spark Open; 0.306 for Muse Wonder

• Terminal-Bench-Science 0.1 — 0.019 for M​use Spark Open; 0.257 for Muse Wonder

• AA-Omniscience v1.1 accuracy — 25.8 for M​use Spark Open; 25.1 for Muse Wonder, and the hallucination rate runs the other way: 28.0% for M​use Spark Open against 20.9% for Muse Wonder

Two rows deserve a sentence each. Terminal-Bench-Science at 0.019 against 0.257 is the widest proportional gap on the sheet, and Terminal-Bench 4.0 at 0.081 against 0.520 is the widest on the workload both models are actually marketed for — an agent that runs commands. If that is your use case, this is close to the whole argument. The Omniscience pair is the one place the cheaper model holds its ground: on knowledge accuracy the two are within a point, and the thing that separates them is not how much they know but how readily they invent an answer when they do not — roughly one in 3.6 responses for M​use Spark Open against one in 4.8 for Muse Wonder.

One caveat on all of it. These are evaluator numbers, not vendor numbers, which makes them the stronger of the two kinds of evidence available. They are still one lab's harness on a suite that was itself revised this cycle, and several of these evaluations are new enough that their scoring will keep moving. Treat the direction as sound and the third decimal place as noise.

Parameter counts, and where the record simply stops

M​use Spark Open publishes its size as part of being open: 816 billion total parameters with roughly 42 billion active per token, 62 decoder layers, 256 experts per mixture-of-experts layer with 8 selected per token, and experts held in 4-bit NVFP4 in the shipped quantised build with some layers left in bf16. The 42-billion-active figure is the one that matters for serving, because it sets how much weight has to be read for every token generated, and it is the reason the model can be served on eight GPUs at all.

For Muse Wonder, the corresponding number is not on the record we can verify. Artificial Analysis marks it as proprietary and its technical specification panel lists reasoning, input modality, output modality and context — with no total or active parameter row at all. We are not going to infer a parameter count from a price or from a benchmark, and we are not going to repeat one we cannot point at. What can be said is directional: a 44-index closed model on a $4/$20 rate card is serving something substantially larger than a 42-billion-active open model, and every serving cost it carries is somebody else's capital rather than yours.

The cheap model is also the fast one, which is the surprise

Price and speed usually trade against each other. Here they run in the same direction, and that is the most decision-relevant finding on either page.

• Output speed — 169 tokens per second for M​use Spark Open; 118 tokens per second for Muse Wonder

• Time to first answer token — 13.81 seconds for M​use Spark Open; 25.19 seconds for Muse Wonder

• Time per Index task — 6.6 minutes for M​use Spark Open; 13.6 minutes for Muse Wonder

• Output tokens used in the Index run — 90.6 million for M​use Spark Open; 113 million for Muse Wonder, against a median of 72.8 million for comparable models

Read the last two lines together and the mechanism is obvious. Muse Wonder is a reasoning model in the strict sense: it works longer, produces more tokens, and takes roughly twice the wall-clock time per task. M​use Spark Open, at Xhigh effort, is leaner — it generated fewer output tokens than the median comparable model, which is unusual for a reasoning configuration and is a genuine mark against the assumption that more thinking is always more capability. The 169 against 118 figure is a hosted-endpoint measurement including time to first token, so it is a statement about the deployed endpoints rather than about the silicon underneath either model.

The practical consequence is that the price gap is wider than the rate card suggests, because you pay per token and Muse Wonder emits more tokens per task. Which brings us to the only number that compares two models honestly across different prices and different verbosity: cost per task.

What a task actually costs on each

Artificial Analysis computes the cost of running its whole evaluation suite and divides by task count, weighting each evaluation by its contribution to the Index. That gives a like-for-like figure that already absorbs the verbosity difference.

• Cost per Index task — $2.02 for M​use Spark Open; $6.95 for Muse Wonder

• Blended list price, 3:1 input to output — $2.00 per million tokens for M​use Spark Open; $8.00 per million for Muse Wonder

• Cache read — $0.15 per million tokens for M​use Spark Open, an 88% discount; $0.20 per million for Muse Wonder, a 95% discount

The headline rate card is $1.25 in and $4.25 out against $4.00 in and $20.00 out, so the output price differs by 4.7× and the input price by 3.2×. The realised per-task cost differs by 3.4× rather than 4.7×, which is the verbosity and cache effects doing their work: Muse Wonder's 95% cache discount is steeper than M​use Spark Open's 88%, and heavy caching pulls its effective cost back toward the cheaper model's. If your workload is cache-friendly — long shared system prompts, repeated documents — the rate card overstates the gap. If it is not, the per-task number is the one to plan against and the rate card understates nothing.

Divide each per-task cost by its Index score and you get a third number, which is mine rather than the evaluator's: about eight cents per index point for M​use Spark Open against about sixteen cents for Muse Wonder. That is the cleanest statement of the trade. You are paying roughly twice as much per unit of measured capability for the closed model, and what you receive for the premium is nineteen index points and a lower hallucination rate.

The licence is a cost line the rate card hides

M​use Spark Open's terms are the Muse Model License, and two of its clauses change what "free weights" means in a business plan.

The first is the model-as-a-service clause. If you provide third parties access to the model as a product or service over an API and your aggregate gross revenue from that exceeds twenty million US dollars in any consecutive twelve-month period, you must notify Meta and enter a separate written agreement before continuing. Embedding the model in your own product is carved out; reselling it is not. A team that intends to become an inference provider on top of these weights should read that clause before writing the architecture document, not after.

The second is attribution: the licence requires "Built with M​use Spark Open" to be displayed prominently in the interface of any product using the model or a derivative, or in its documentation, site or settings. That is a small tax and an unconditional one, and it appears exactly where a product decision gets made — the about screen.

What the licence gives plainly is the part that justifies the download: fine-tuning, distillation, merging, publishing, sublicensing and selling derivatives, with Meta claiming no ownership of outputs. Muse Wonder offers none of that. You cannot fine-tune a hosted checkpoint, you cannot merge it into a domain model, you cannot run it airside, and you cannot fix a behaviour by retraining it. The premium you pay for Muse Wonder buys capability and buys you out of the operational burden; it also buys you out of every option that requires touching the weights.

One mechanical point that catches people: the download itself is gated. The repository is access-controlled, the request form asks for legal name, date of birth and organisation with corporate identifiers, and cannot be edited after submission. Budget a queue, not a click.

Where the megakernel changes the arithmetic

There is a third number in this comparison that neither rate card contains, and it arrived yesterday from outside Meta. On November 11, 2026 the SGLang team published a megakernel for M​use Spark Open — one resident kernel per layer instead of roughly 1,450 launches per decode step — and measured decoding going from 517 to 1,109 tokens per second on eight GB300s. That is a 2.1× improvement on the same weights, the same precision, and the same numerics, achieved purely in software.

Put that next to the hosted figures and the shape of this decision changes. A rented endpoint answers at 169 tokens per second; a hand-built eight-GPU stack running research kernels answers at 1,109. The second number is batch-size one, on one GSM8K request, median of 20 steps, and nobody outside the authors has reproduced it — so it is a ceiling you might reach, not a throughput figure you can put in a capacity plan. But it establishes the asymmetry that defines this pair: the closed model's serving efficiency is Meta's to improve and yours to wait for, while the open model's serving efficiency is a function you can attack with your own engineers.

For a team with GPUs already paid for, that asymmetry is worth more than nineteen index points in the workloads where the open model is close. For a team without them, it is worth nothing, because the 1,109 figure arrives attached to an eight-GPU node you would have to buy.

Four situations, four different answers

The comparison resolves cleanly once you name the constraint, and the constraint is almost never the benchmark.

If you are shipping a product this quarter and the work is hard reasoning, long-horizon agentic tasks, or anything where a terminal benchmark gap of 0.081 against 0.520 is the shape of your problem, the answer is Muse Wonder and it is not close. You are paying $6.95 per task for a model that finishes the task, and the alternative is paying $2.02 per task for one that frequently does not.

If you are running high-volume, latency-sensitive work where an answer at 169 tokens per second with a first token in 13.8 seconds is acceptable and one at 118 tokens per second with a first token in 25.2 seconds is not, the answer is M​use Spark Open even before you consider price — and the price then makes it a 3.4×-cheaper answer. The 28% hallucination rate is the thing to design around: ground it, cite it, or verify it downstream.

If you have data that cannot leave your infrastructure, or a regulator who wants to see the weights, or a domain where fine-tuning on your own corpus is the entire value proposition, the comparison is over. Muse Wonder cannot be that, and no amount of index points changes it. M​use Spark Open can, and the licence explicitly permits the fine-tune, the merge and the redistribution.

If you already own a training cluster with GB300-class nodes, the open model's economics are not the rate card at all — they are the marginal cost of the GPUs you have already amortised. That is the case where 1,109 tokens per second matters, where the megakernel work is directly actionable, and where the twenty-million-dollar model-as-a-service clause is the one piece of paperwork standing between a side project and a business.

The case that does not resolve is the one people ask about most: a small team that wants frontier capability and also wants cheap. It cannot have both from this pair. What it can have is a cascade — a cheap model for the majority of traffic and the expensive one for the residue — and that is a routing decision rather than a model decision.

What we route, and what we do not

Neither of these two models is on OrcaRouter. There is no meta/muse-wonder entry and no meta/muse-spark-open entry in the catalogue, and we are not going to describe either as available through us. M​use Spark Open is a download and a licence; Muse Wonder is Meta's own endpoint and a subscription.

What we do carry from the same lab is the M​use Spark line: Muse Spark 1.2 and Muse Spark 1.1. That matters for exactly one of the four situations above — the cascade. A routing layer is where the "cheap model for most traffic, expensive model for the residue" answer stops being an architecture diagram and becomes configuration: one API across 200+ models, with the provider's list price passed through at 0% markup, so a Meta price cut lands on your bill the same day rather than at the next contract renewal, and automatic failover plus a routing DSL that moves traffic between models by configuration rather than by a code change and a deploy.

For the open-weights half of the comparison, the honest version is that no router helps. The weights are yours, the GPUs are yours, the kernel is yours, and the only route to the 1,109 number is an engineer with a profiler.

When this comparison goes stale

• Muse Wonder Full reaching an API. The higher-scoring checkpoint is currently walled inside a subscription, so the Muse Wonder in this comparison is the API model at 44, not the Full checkpoint Meta reports separately. If Full opens an endpoint, the capability gap widens and the cascade argument gets harder.

• An independent reproduction of the megakernel numbers. One team's 2.1× at batch size one is a ceiling; a second team matching it at a real batch size turns it into a self-hosting case with numbers attached.

• A price move on either side. M​use Spark Open's hosted rate is $1.25/$4.25 and Muse Wonder's is $4.00/$20.00, and a single vendor announcement could compress or invert the 3.4× per-task gap. This is the cheapest thing on the list to change and the most likely to.

• A fine-tune that closes the gap. Nineteen index points is a large deficit for a derivative to recover, and the open model's licence is what makes the attempt legal. If a domain tune on M​use Spark Open lands near the median of Muse Wonder's class on the specific evaluations your product cares about, the premium stops being justified for that product.

Until one of those moves, the summary is short. Muse Wonder is the more capable model and you rent it by the token. M​use Spark Open is the less capable model and you own it outright, along with the GPUs, the licence clauses, the hallucination rate, and — as of this month — a public recipe for making it twice as fast.