Apple’s machine learning team clocked Meta’s newest open model at 36.73 tokens a second. That figure took four M5 Ultra Mac Studios wired together over Thunderbolt 5, with the model squeezed to 4-bit precision and one user at a time, according to Apple’s own benchmark post. It is the most useful number in the whole Muse Spark Open launch, because it tells you what “runs on your desktop” actually means before you order anything.
Meta released Muse Spark Open on October 15 and called it “the most capable US open-weight model to date”. Most of the coverage stopped at the Apple partnership and the 816 billion parameters. This guide covers the questions that come after the headline: what hardware it really takes, what the setup involves, when renting beats owning, what the license lets you do, and where the model is weaker than the launch post suggests.
What Meta actually put on Hugging Face
The basics, from Meta’s launch post and the Hugging Face model card:
- Architecture: mixture of experts, 816B total parameters with 42B active per token. The model card lists the effort settings as low, medium, high and xhigh, and xhigh is the default.
- Context: up to 1M tokens. It takes text, image, audio and video as input and produces text.
- Checkpoints: BF16 and NVFP4 (4-bit).
- Where to get it: gated weights on Hugging Face, plus Amazon SageMaker AI, Google Cloud Model Garden and Microsoft Foundry Models. Meta lists Baseten, Fireworks AI, Groq, Modal, Nebius, OpenRouter and Together AI as hosted API partners.
- Engines: SGLang, vLLM, TensorRT-LLM, Transformers, Apple MLX, llama.cpp and Unsloth.
This matters for a reason specific to Meta’s lineup. Three days earlier, Meta launched Muse Wonder, and its best variant has no public API and no downloadable weights. Spark Open is the opposite deal: a smaller, weaker model that you can actually hold, inspect and run inside your own boundary. If you are choosing between Meta models, that is the first fork, not the benchmark table.
The memory math: 493GB of weights, a 700GB floor
The 42B active figure invites a misreading: that this runs like a 42B model. It does not. Every expert has to sit in memory even though only a few fire per token. VentureBeat made the same point when it read the model card’s requirements.
The numbers that decide your hardware:
- Apple measured the NVFP4 weights at about 493GB, and the BF16 weights at over 1.6TB (Apple ML Research).
- The model card asks for at least 700GB of accelerator memory for NVFP4 and at least 2TB for BF16. The gap between 493GB and 700GB is the working memory for the KV cache and activations, and it grows with the context you feed the model.
So a single Mac Studio cannot run it, even at the 512GB ceiling. Meta’s reference build is two M5 Ultra Mac Studios with 512GB each, which Meta describes as two machines that “behave like one supercomputer with a terabyte of unified memory”.
Here is the catch for anyone trying to buy this month. The 512GB M5 Ultra configuration was slated for October, and VentureBeat reports it ships late in the month with no announced price. The configuration you can buy today tops out at 256GB, so the available route to a terabyte is four machines. VentureBeat priced a 256GB M5 Ultra with a 1TB SSD at $10,799, which puts four of them at $43,196 before tax, cables and a desk strong enough to hold them.
On the data center side, NVFP4 is a format built for NVIDIA’s FP4-capable Blackwell parts, and the 700GB floor means a multi-GPU node, not a single card. Meta’s own developer material points at GB300 NVL72 racks for production-scale agentic workloads, according to Tech Insider’s breakdown.
What Apple’s benchmark says about speed
Apple ran Muse Spark Open on M5 Ultra clusters at NVFP4, batch size 1. The relevant rows from its post:
| Configuration | Decode speed | Time to first token |
|---|---|---|
| 2 × M5 Ultra, pipeline parallel | 15.74 tokens/s | 8.4 s |
| 2 × M5 Ultra, tensor parallel | 24.99 tokens/s | 8.2 s |
| 4 × M5 Ultra, tensor parallel | 36.73 tokens/s | 4.8 s |
Three things in that post change how you should plan.
Long prompts are slow. Apple reports that on four M5 Ultras at a 65,536-token context, time to first token was about 40.6 seconds with two Thunderbolt cables per link (50.5 seconds with one). The 1M-token context window is a property of the model; feeding it a million tokens on a desk is a different matter. An agent that rereads a large codebase on every turn will spend most of its life in prefill.
Batch size 1 means one user. Every number above is a single stream. Thirty-seven tokens a second is pleasant for one developer and inadequate for a team sharing one endpoint.
It is the 4-bit model. Apple evaluated NVFP4, not native BF16, and the model card itself notes “minor quality loss when quantized.” Meta’s benchmark table does not say which precision produced its scores. Assume the local model is a little worse than the hosted one until your own tests say otherwise.
Setting it up on Macs
Apple’s post describes the stack, and it is short:
- macOS 26.2 or later. That release added a low-latency RDMA driver over Thunderbolt 5, which is what lets several Macs exchange data fast enough to act as one machine.
- MLX v0.30.1 or later, which adds the
jacclcommunication backend on top of that driver. - Cabling: Apple used two Thunderbolt 5 cables per link to double bandwidth. Four machines run as a mesh.
- Launching: Apple’s runs used
mlx.launchwith--backend jaccl, drivingmlx_lm.serverfor serving ormlx_lm.benchmarkfor measurement. Copy the exact flags from Apple’s post rather than from a forum thread, since this tooling is weeks old and changing. - Pick the parallelism deliberately. Pipeline parallel splits the model by depth; it needs little communication but decodes at roughly single-machine speed. Tensor parallel splits by width; it needs the fast link but decodes much faster. On two machines, Apple found tensor parallel slower at long-context prefill for this model because of extra traffic normalizing expert outputs, while four machines pulled ahead. For interactive coding, take tensor parallel. For overnight batch jobs on long documents with two machines, test pipeline too.
Apple also flags MLX_METAL_FAST_SYNCH=1 as an experimental speedup. Experimental is the operative word. Leave it off until the base setup is stable.
The Hugging Face listing also surfaces quantized builds for llama.cpp, Ollama and LM Studio. Treat those as community conversions, not Meta releases, and check who produced each one before you point anything sensitive at it.
Rent or own: the arithmetic
The hosted price is the benchmark you are buying hardware against. Together AI lists Muse Spark Open at $1.25 per million input tokens, $0.15 per million cached input tokens and $4.25 per million output tokens, per VentureBeat’s pricing survey, which also notes that other launch partners have not all published rates.
Now the arithmetic. This is this site’s own calculation, using Apple’s published speed and Together’s published price, not a figure from Meta or Apple:
- Four Mac Studios decoding nonstop at 36.73 tokens per second produce about 3.17 million output tokens a day.
- At $4.25 per million, buying those tokens from Together costs about $13.50 a day.
- At that rate the $43,196 cluster takes roughly 3,200 days, close to nine years, to pay for itself on output tokens alone.
- Give the local cluster credit for input tokens too, at a generous three input tokens per output token billed at full price, and the payback is still close to five years. That assumes the machines run flat out every hour of every day, with no electricity cost (Apple puts M5 Ultra peak draw at about 300W per machine) and no time spent on upkeep.
Hardware like this is usually written off over three or four years. On pure token economics, owning loses, and it is not close.
That does not make the Mac cluster pointless. It changes what you are buying. You are not buying cheaper tokens; you are buying a model that never sends a prompt across your network boundary, works without an internet connection, and cannot be repriced, rate-limited or deprecated by a provider. For a legal team with privileged documents, a health researcher under strict data-residency rules, or an infrastructure group that needs an air-gapped assistant, that is the product. The broader self-hosting tradeoffs apply here as well: you also own the patching, the monitoring and the 2 a.m. failures.
One more hosted detail worth checking before you pick a provider: context limits vary. VentureBeat reports Fireworks offering the full 1,048,576-token window, while Groq caps it at 131,072 tokens and requires organization approval. “Muse Spark Open on provider X” is not one product.
The license terms that matter
Meta calls this open weights, and it is careful not to call it open source. The Muse Model License, as summarized on the model card and by OrcaRouter’s license read, comes down to four clauses that will reach most readers:
- The $20 million trigger applies to resellers, not users. If you and your affiliates offer the model to third parties as a service and gross more than $20 million in any 12-month period, you must notify Meta and sign a separate agreement first. Internal use, research and building it into your own product are exempt.
- Attribution is mandatory. Any product using the model or a derivative must show “Built with Muse Spark Open” in its interface, documentation, website or settings.
- “Derivative” is broad. VentureBeat reports that the definition includes models improved using Spark Open’s outputs. If you plan to distill it into a smaller in-house model, the attribution clause follows the student model.
- The download gate asks for more than an email. Hugging Face’s form wants your full legal name, date of birth and full organization name, and it cannot be edited after you submit. Get the organization name right the first time, and route the request through whoever owns vendor agreements.
Meta also claims no ownership of outputs, and fine-tuning, merging and redistribution are allowed. For most internal deployments, the license is workable. For anyone building an inference business, read the full text with counsel before the first customer.
Strong at tools, weaker at code, and quick to refuse
Meta pitches Spark Open for coding and agentic work. Its own benchmark table supports half of that. All figures below are Meta-reported, from the model card, and the coding numbers were run in each model’s preferred agent harness, so the harness is part of what is being compared.
Where it leads: tool use and long-horizon office work. Per the model card, it posts 89.2 on MCP-Atlas, ahead of every open model in Meta’s table (Qwen3.8 at 84.5, GLM 5.3 at 84.2, Kimi K3 at 82.3), and 61.8 on JobBench.
Where it trails: terminal and software engineering tasks. On Terminal-Bench 2.1 it scores 76.4 against Kimi K3’s 85.0 and GLM 5.3’s 83.9. On DeepSWE 1.1 it scores 60 against GLM 5.3’s 67 and Kimi K3’s 68. Meta’s table lists an Artificial Analysis Intelligence Index of 39, below GLM 5.3’s 45; VentureBeat could not find an independent Artificial Analysis listing to confirm it. If the deciding workload is autonomous coding, Meta’s own numbers point you to Kimi K3 or GLM 5.3. Spark Open’s real pitch is that it is the strongest option with a US developer, which matters if your procurement rules screen on model origin.
The refusal tradeoff. The safety rows are the most practical part of the table. On StrongREJECT v2, an adaptive jailbreak test where lower is better, Spark Open scores 0.5; the other open models range from 62.9 to 86.4. That is a large gap in resistance to attacks. The flip side shows up in the FORTRESS benchmark, where its over-refusal score is 17.4, the highest in the table (Kimi K3 is 2.7). In plain terms: it is hard to talk into something harmful, and more likely to decline something harmless. For an agent pipeline, an unexpected refusal halfway through a job is a failure mode, so put borderline but legitimate requests from your own domain (security tooling, medical text, legal disputes) into your test set.
Turn the dial down. Because xhigh is the default effort, a hosted deployment will bill maximum reasoning on every call unless you set it lower. The model card recommends high or xhigh for complex tasks; for classification, extraction and routine tool calls, start at low or medium and step up only where your own evals show a loss. The same rule we laid out for effort settings across the frontier models applies here, and it matters more on an open model that providers bill per token.
Matching the route to the job
- Most teams: start on a hosted API. At $1.25/$4.25 per million tokens it sits well under Sonnet-class pricing, and you can test the model on your real workload for the price of a lunch. Set effort explicitly and check the provider’s context limit.
- Data that cannot leave the building: the Mac cluster earns its place. Plan on four 256GB machines now or two 512GB machines once Apple ships and prices them. Size it for a handful of concurrent users, keep prompts well under 64K tokens if you need interactive speed, and test the 4-bit build against the hosted model on identical tasks.
- Production concurrency: data center GPUs. If dozens of people or agents will share the endpoint, desktop clusters at batch size 1 are the wrong tool. Price a GPU node that clears the 700GB NVFP4 floor or a dedicated deployment on SageMaker, Model Garden or Foundry.
- Coding-agent accuracy above everything: look elsewhere first. On Meta’s own scores, other open models lead the terminal and software engineering benchmarks.
Whichever route you pick, run your own tasks before trusting the launch table. Reflection’s Beam arrived twelve days ago with the same “America’s open frontier model” positioning and launched as a waitlisted API, with weights promised later. Meta shipped the weights. That makes Spark Open the first model in this category that you can actually test inside your own walls, and the testing is now your job.