Ripple 65B Preview vs Muse Wonder: What 20× the Price Actually Buys

There is exactly one benchmark that Ripple 65B Preview and Muse Wonder both published, at the same version, with numbers you can put in the same sentence: DeepSWE 1.1. Meta's Muse Wonder reports 78.8. Ricursive's Ripple 65B Preview reports 44.3. That is a 34.5-point gap on software-engineering agent work, and it is the only clean comparison the two launches offer — everything else is either a different benchmark revision or a column with a dash in it.

So the question is not whether Muse Wonder is better at that task. It plainly is, on the labs' own numbers. The question is whether it is better by enough to justify costing roughly twenty times as much on input and thirty-three times as much on output. That is a real decision with a real answer, and it is not the same answer for every workload.

Why DeepSWE 1.1 is the fair fight

Both labs ran version 1.1 of the same evaluation. Neither has published a re-run by a third party, so both numbers carry the same caveat — they are vendor-reported and unreproduced — and that symmetry is what makes the comparison usable. When two claims are equally self-interested, the gap between them is still informative.

Contrast that with Terminal-Bench, where the two labs are not on the same exam at all. Ripple reports 80.5 on Terminal-Bench 2.1. Meta reports Muse Wonder Full at 57.1 on Terminal-Bench 4.0, a later and harder revision. Anyone lining those up to declare Ripple the winner is comparing a model that sat the 2024 paper with one that sat the 2026 one. Meta's own framing is careful here and Ricursive's launch thread was not.

One more caution on the Meta side: the company's JobBench table claims 75.3 for Muse Wonder Full against 30.8 for standard Muse Wonder, a 44-point gap that no independent evaluator has reproduced. Treat internal benchmark tables from any lab as marketing until someone outside the building runs them.

What the price difference actually is

Muse Wonder is $4.00 per million input tokens and $20.00 per million output tokens, with cached input at $0.20. Ripple 65B Preview is listed at $0.20 and $0.60 on its first hosted endpoint — a number to hold loosely, since Ricursive has published no rate card and that endpoint serves a 16,384-token context against a 1M advertised window. Even taking the listing at face value, the ratio is 20× on input and 33× on output.

Per-token ratios flatter small models and mislead about real bills, so here is the arithmetic on a workload you might actually run. Say your coding agent emits 50 million output tokens a month and reads 200 million input tokens doing it.

• On Muse Wonder: 200 × $4.00 = $800 input, plus 50 × $20.00 = $1,000 output. Total $1,800 a month.

• On Ripple 65B Preview at the listed rate: 200 × $0.20 = $40 input, plus 50 × $0.60 = $30 output. Total $70 a month.

• The difference: $1,730 a month, or roughly $20,760 a year, for the same nominal token count.

Now the part the spreadsheet misses. If Ripple fails a task one time in three and you retry it, your effective output volume rises by half. Two retries and you have doubled it. The break-even is not subtle — Ripple can be thirty-three times less efficient per token and still cost less — but the failure mode is worse than the bill. A coding agent that fails a third of its tasks does not just cost more; it costs you the engineer who has to notice, unwind and re-run the work. Price the supervision, not only the tokens.

Artificial Analysis puts Muse Wonder (Max) at $6.95 per index task on its live model page — a more honest unit than dollars per million, and one with no equivalent for Ripple, because nobody has run it through a standard task set.

What Meta is charging for, beyond the weights

Muse Wonder is a closed model with an unusually broad input surface: text, images, video, audio and PDFs in, text out, over a 1,048,576-token context with a 131,072-token output ceiling. It runs always-on reasoning with six selectable effort levels, supports parallel tool calls and structured outputs, and exposes two features with no equivalent on Ripple's card at all — Active Memory, which carries context across conversations, and Active Focus, which is designed to hold a long task together without drifting.

Whether you care depends entirely on the shape of your workload. If your agent has to read a screenshot of a failing test, transcribe a customer call and reconcile it against a PDF invoice in one pass, none of Ripple's benchmark scores help you, because Ripple 65B Preview takes text and returns text. The modality gap is not a performance difference you can close with a better prompt.

Muse Wonder (Max) scores 44 on Artificial Analysis's Intelligence Index — #26 of 66 models in its class, and above the 36 median for comparable models, though no longer the frontier-adjacent 52 that launch-week coverage reported. The index was rebuilt in late October and several models moved. Ripple 65B Preview does not appear on it at all.

What Apache 2.0 is worth

Ripple 65B Preview is 65 billion dense parameters under Apache 2.0, with the full weights on Hugging Face in BF16 plus NVFP4 and base-model variants. In BF16 that checkpoint is about 130 GB, which is DGX Spark territory or a quantised run on a smaller machine — not, despite what the launch coverage said, a MacBook, unless you are running the NVFP4 build. Ricursive claims 250 tokens per second on two B200s at batch size 8 before any custom kernels, and about 40% MFU through pretraining on plain sharding.

What that buys you is everything a hosted closed model cannot give: the ability to fine-tune on your own data, to run inference with no per-token bill and no data leaving your network, to pin a version forever, and to serve it at 3am without depending on someone else's status page. For a regulated workload, that list is often worth more than 34 DeepSWE points. For a startup shipping an agent this quarter, it usually is not.

There is also a licence asymmetry worth naming. Apache 2.0 is about as permissive as open weights get. Muse Wonder is closed outright — Meta's open-weight sibling in this family is Muse Spark Open, a different and much larger 816B model with 42B active parameters and 256 experts, not a smaller version of Wonder. If open weights are a requirement rather than a preference, this comparison ends here.

Running the two side by side

Neither model is on our catalogue today, and neither is going to be implied to be. Muse Wonder reaches developers through Meta's own API; Ripple through Ricursive's endpoint and third-party platforms, with weights on Hugging Face. What a router is good for in this situation is the thing both launches make obvious: you do not want a production path wired to a one-day-old Preview whose own card says its scores are hard to replicate. You want that model behind a fallback, taking a share of traffic you can dial up as evidence accumulates — automatic failover to a known-good model on error or timeout, rather than a rewrite when the experiment disappoints.

That pattern is also how you answer the pricing question empirically. Route 10% of your coding traffic to Ripple, keep 90% on Muse Wonder, and compare not the token bill but the completed-task cost — including the retries and the human time. One API key, one billing line, and a number you can defend in a planning meeting, which is more than any benchmark table will give you.

Who should pay the twenty times

Pay for Muse Wonder if your work is multimodal, long-horizon or customer-facing: agents that read screenshots, assistants that need to remember a user across sessions, anything where a 27% hallucination rate is already too high and you need the reliability that a frontier lab's post-training buys. The $6.95 per index task is a fair price for a model that finishes the task.

Run Ripple 65B Preview if the work is text-only, bounded and high-volume, and if you have the hardware or a cheap endpoint: batch classification, code review on a fixed rubric, a local assistant, a fine-tuning base. At $0.20 and $0.60 it is thirty-three times cheaper on output, and on a workload that plays to its strengths that ratio beats a 34.5-point deficit on one benchmark.

The mistake would be reading the DeepSWE gap as a verdict. It is one exam, taken once, reported by the lab that set it. The number that should decide this for you is not 78.8 versus 44.3 — it is what your own task set does when you run both, and that number does not exist until you generate it.