Muse Spark Open: Benchmarks, License, How to Run (2026)

Meta's 816-billion-parameter open-weight model, checked against independent tests: what the Muse Model License really allows, what it costs per task, and exactly how to run it on two Mac Studios or a GPU server

On October 15, 2026, Meta released the weights of an 816-billion-parameter model that Apple measured at 25 tokens per second on two Mac Studios sitting on a desk. The model is Muse Spark Open, Meta calls it "the most capable US open-weight model to date", and it ships with a 1-million-token context window, native image, video and audio input, and only 42 billion parameters active per token - Meta AI Research. Apple published its own benchmark of the model the same day, showing 24.99 tokens per second with two M5 Ultra Mac Studios linked by Thunderbolt and 36.73 tokens per second with four - Apple Machine Learning Research. The launch thread on Hacker News passed 900 points within days - Hacker News.

The problem is that each of the three headlines is true and incomplete at the same time. "Most capable US open-weight model" is accurate, but on the independent Artificial Analysis Intelligence Index Muse Spark Open scores 39, which ranks it 11th of 121 comparable open-weight models, behind Xiaomi's MiMo-V2.6-Pro at 46, DeepSeek V4.1 Flash 1017 at 45 and Kimi K3 at 44 - Artificial Analysis. "Open weights" is accurate, but the Muse Model License is not an open-source license: it requires a "Built with Muse Spark Open" label on every product and makes large model-hosting businesses sign a separate deal with Meta. And "runs on your desktop" is accurate, but the desktop in question is two Mac Studios with 512GB of memory each, a configuration Apple says is "coming in late October" - Apple Newsroom.

This guide separates the claims from the evidence. It explains what Meta actually released and why it trails Meta's own hosted models, walks through Meta's benchmark table row by row and against independent results, reads the license clause by clause, works out what the model costs through an API, on rented GPUs and on your own Macs, and then gives step-by-step instructions for every realistic way to run it: two or four Mac Studios with MLX, a GPU server with vLLM or SGLang, and smaller quantized copies with llama.cpp. No technical background is assumed. Where a section gets technical, the plain-language version comes first.

Contents

1. Muse Spark Open on one page
2. Where it came from, and why Meta opened this model
3. Under the hood: what 816B total and 42B active mean
4. Meta's benchmark table, read row by row
5. What the independent numbers say
6. The Muse Model License, clause by clause
7. What it costs: API, rented GPUs, or your own Macs
8. How to run it on two or four Mac Studios
9. How to run it on GPU servers
10. Running it on less: quantized copies and llama.cpp
11. Using it in an agent: reasoning, tools and the harness
12. Safety: what Meta tested and what you still have to build
13. Where Muse Spark Open falls short
14. The outlook for open weights
15. The bottom line: who should use it, and for what

Muse Spark Open against the open-weight field: the scored comparison

Before the detail, here is where Muse Spark Open lands among the open-weight models a team would realistically weigh this month. The table scores nine downloadable models on five criteria chosen for one question: which model should a business run when it wants to own the weights rather than rent a closed API? Capability comes from the independent Artificial Analysis Intelligence Index v4.3, hosted prices come from OpenRouter's public model list so every row is priced from the same source - OpenRouter, and licenses and modalities come from each model's own card. Every cell shows the score and the fact behind it.

Two models Meta compared against are left out on purpose. Mistral Large 4 is not yet downloadable: Mistral says its "weights drop end of this month" - Mistral AI. Beam 1.0 from Reflection AI released its weights under Apache 2.0 on October 16 - Reflection AI, but it has no independent Intelligence Index score yet, and scoring a model without its most important number would flatter it. Both appear in the analysis later. One model Meta did not compare against is included, because it now tops the open field: Xiaomi's MiMo-V2.6-Pro, which arrived in September.

How the criteria work. Capability (30%) maps the Artificial Analysis Intelligence Index linearly from 20 (a score of 0) to 45 (a score of 10, the cap), because the index is the broadest independent measure and it already includes agentic work such as GDPval-AA and Terminal-Bench. Multimodal (15%) rewards the input types a model accepts and any computer-use evidence, because agents increasingly read screens, documents and recordings. License (20%) scores freedom to use, modify and resell: 10 for MIT, Apache 2.0 or OpenMDW, lower for each condition a business must track. Own hardware (15%) scores how small a machine can hold a 4-bit copy, using the published checkpoint where one exists and otherwise estimating 0.65 bytes per parameter, the ratio of Meta's own NVFP4 checkpoint (533GB for about 822 billion stored parameters - Hugging Face); Muse Spark Open gets a bonus point for the only vendor-supported, vendor-measured desktop path. Hosted price (20%) blends input and output at 3:1 and maps it on a log scale from $0.10 (10) to $10 (0), using the headline price OpenRouter lists, which can be a cheaper host than the model's maker. Final scores are weighted averages, rounded to one decimal.

Read the table as a buyer's default rather than a verdict on intelligence. It says three things about Meta's launch. First, Muse Spark Open is a genuine contender, finishing fourth of nine, and it shares the top of one column: only it and MiMo-V2.6-Pro accept text, images, video and audio together, and Muse's 80.4 on the OSWorld-Verified computer-use test is Meta's own run but a strong one. Second, it loses on the two things open-weight buyers usually care about most, price and license: at $1.25 and $4.25 per million tokens it costs roughly four to five times more than MiMo, DeepSeek or GLM through the same marketplace, and its license carries more conditions than any other model in the table. Third, the three models that beat it are all Chinese, which matters for some buyers more than any score. If you need a US-origin model with full multimodal input that you can run on your own hardware, Muse Spark Open is the only option; if you need the most intelligence per dollar, or full multimodal input regardless of origin, it is not. Section 15 turns this into a decision guide by job.

1. Muse Spark Open on one page

Muse Spark Open is a large reasoning model from Meta Superintelligence Labs, released with downloadable weights on Thursday, October 15, 2026. Meta describes it as "a natively multimodal model with 816B total parameters (42B active) and a 1M-token context window", built "for coding and agentic work" and long-horizon tasks - Meta AI Research. It is the open-weight member of the Muse family, the line of models Meta has shipped since April, and the PyTorch team's launch post confirms it "shares the same base model as Muse Spark 1.3", Meta's current hosted mid-tier model - PyTorch.

The release is unusually broad. On day one the model was available through seven API hosts (Baseten, Fireworks AI, Groq, Modal, Nebius, OpenRouter and Together AI), as downloadable weights on four clouds and Hugging Face (Amazon SageMaker AI, Google Cloud Model Garden, Hugging Face and Microsoft Foundry), and in seven inference engines (SGLang, vLLM, TensorRT-LLM, Hugging Face Transformers, Apple MLX, llama.cpp and Unsloth). That breadth is itself a strategy, which section 2 unpacks. The spec sheet below collects the facts a buyer needs, all drawn from Meta's model card - Hugging Face.

Sources: the model card for the specification, Meta's hardware page for the hardware, Meta's prompting guide for reasoning levels and the cutoff, OpenRouter for price, and Artificial Analysis for the index.

Three facts from that sheet shape everything that follows. First, the gap between total and active parameters is the whole reason a model this large can run on two desktop computers: every token touches only about a twentieth of the network, so memory capacity matters far more than raw compute. Second, the open model is not Meta's best model. Meta's own hosted Muse Spark 1.3 scores 48.1 on the same index at its maximum setting - Artificial Analysis, and Muse Wonder, released three days earlier, scores 52, as we covered in our Muse Wonder benchmark guide; the open release sits roughly where Muse Spark 1.2 did in August. Third, the price is set, not discovered: every host lists the same $1.25 and $4.25, which is unusual for an open model and has consequences covered in sections 7 and 13.

1.1 What Meta says the model is for

Meta pitches Muse Spark Open at three jobs: long-horizon agent work, complex software engineering and multi-step reasoning. The model card adds a longer list of intended uses, including tool use "across extended multi-turn workflows, diagnosing error and retrying with tool call failures", multimodal reasoning over "screenshots, charts, documents, images, audio and video recordings", synthetic data generation, and serving as an LLM-as-a-judge evaluator for other models. That last pair is easy to overlook and commercially important: a downloadable model that can judge and generate training data is a tool for building other models, which is precisely what the license's definition of "Derivatives" is written to cover.

The launch post backs the agent pitch with two demos run entirely on Mac hardware. Meta says it used Muse Code, its terminal coding agent, powered by Muse Spark Open, to ship "real iOS changes to Ice Cubes (an open-source Mastodon client)", including bug fixes, new features and a full build, and to drive DaVinci Resolve end to end, "with the model reviewing footage frame by frame to find the strongest moments and crop them vertically" - Meta AI Research. Meta published no reproducible script or task log for either demo, so treat them as statements of intent rather than benchmarks. They do show where Meta wants the model to be judged: not on chat, but on agents that run for a long time on private machines.

That framing also explains why Meta tied the launch so closely to Apple. A model that runs on a pair of Macs reaches a buyer who would never rent eight datacenter GPUs, and it gives Meta a story the Chinese open-weight leaders cannot easily tell: an American model, optimized with an American hardware maker, running entirely offline. For readers who want the family background first, our guide to the original Muse Spark covers the April launch, and our Muse Wonder guide covers Meta's frontier tier.

2. Where it came from, and why Meta opened this model

The Muse family is six months old, and its history explains both the strengths and the gaps of the open release. Meta Superintelligence Labs launched the original Muse Spark on April 8, 2026 as a closed model, the first time in Meta's AI history that its flagship was not released as open weights, as we documented in our original Muse Spark guide. Over the summer Meta shipped versions 1.1 and 1.2, launched Muse Code and Muse Spark 1.2 together on August 5 - Meta AI Research, and on August 10 released Muse Glimmer, a 30-billion-parameter model under the permissive Apache 2.0 license - Meta AI Research.

The open release of a large Muse model was promised for months before it arrived. When Glimmer launched, Mark Zuckerberg wrote: "Soon we'll also release the weights for Muse Spark 1.2, our latest foundation model. Meta is a strong supporter of open source" - OfficeChai. On September 2, Meta's Muse Spark 1.3 announcement again pointed to "the Muse Spark open weights release" as coming - Meta AI Research, and The Register reported the weights would land "soon" - The Register. Hugging Face's metadata shows both Muse Spark Open repositories were created on September 15, a month before the public launch - Hugging Face.

The diagram makes the sequencing visible: Meta opened its models from the bottom up and kept the top closed. Glimmer, the small model, got the most permissive license Meta has ever used; the mid-tier open model got a custom license with conditions; the frontier models, Muse Wonder and Wonder Full, have no downloadable weights at all. That is a coherent strategy, and reading it correctly tells you what to expect from future Meta releases.

2.1 What the open model actually is

The most important fact about Muse Spark Open's lineage is buried in the PyTorch post: the model is "building on our August release of Muse Spark", meaning Muse Spark 1.2, which launched on August 5, and it "shares the same base model as Muse Spark 1.3" - PyTorch. The Muse Spark Open model card adds that "this open weights version has additional safety post-training to make it more robust against misuse as a standalone model without system guardrails" - Hugging Face. In plain terms: Meta took a base model it also uses for its hosted product, gave it a post-training recipe closer to 1.2's than 1.3's, and then added an extra layer of safety training because a downloaded model cannot rely on Meta's servers to filter what it does.

The independent numbers line up with that reading. On Artificial Analysis, Muse Spark 1.2 at its xhigh setting scores 39.6, Muse Spark Open at xhigh scores 38.9, and Muse Spark 1.3 scores 45.1 at xhigh and 48.1 at max - Artificial Analysis. The open model is therefore a 1.2-class model on a 1.3-class base, and that six-point gap to the hosted 1.3 is the price of the safety post-training and whatever Meta chose not to give away. Bloomberg noted on launch day that, according to Meta, the model "is less advanced than Muse Wonder", and that releasing it "fulfills a prior Meta commitment" - Bloomberg. Hacker News readers noticed immediately. One wrote that Zuckerberg had promised the weights of Muse Spark 1.2, "and now we only get that one" - Hacker News; another said bluntly that it "performs worse than Muse Spark 1.3 and 1.2" - Hacker News.

2.2 Why Meta releases weights of a weaker model

Start from the structural question rather than the press release: why would a company give away a model that competes with its own paid API? The answer is that Meta does not primarily sell model access. It does now sell some, through its hosted Muse Spark 1.3 and Muse Wonder, and section 6 shows how the license protects that business, but its main products are apps used by billions of people, and its main costs are compute and talent. A strong open model lowers the price of the layer Meta buys from (inference and tooling) and raises the cost of competing with Meta at the layer where it earns money (consumer reach). Every developer who builds on Muse weights, every inference engine that optimizes for the Muse architecture, and every cloud that lists it reduces Meta's dependence on anyone else's stack. That is why the day-one list of partners is so long: seven API hosts, four clouds and seven inference engines, plus Apple.

The second force is geopolitical. Chinese labs have dominated open-weight leaderboards for most of 2026, and MiMo-V2.6-Pro, DeepSeek V4.1 Flash, GLM 5.3, Kimi K3 and Qwen 3.8 all outscore Muse Spark Open today. Meta's AI chief Alexandr Wang chose his superlative carefully, writing on X that the model is "the most capable US open-weight model to date" - Khaleej Times. For American enterprises and government buyers who will not run a Chinese model on sensitive data, that qualifier is the entire value proposition. One Hacker News commenter read the same framing as "an implicit acknowledgment of how good Chinese companies have become" - Hacker News, and both readings are correct. If sovereignty is your concern, our guide to sovereign AI and nationally owned models covers the wider trend.

The third force is the Apple partnership. Meta and Apple are not natural allies, and MacRumors noted it was "something of a surprise to see the two companies partnering", quoting Wang's line to Axios: "We're excited for mommy and daddy to be playing nice again" - MacRumors. Apple's John Ternus called it "amazing to run a model of Muse Spark Open's caliber and scale this efficiently, right from your desk" - CNBC. Each side gets something concrete. Apple gets a flagship demonstration that its 512GB Mac Studio and its new RDMA-over-Thunderbolt clustering can run a model of this size, timed weeks before the 512GB machine ships. Meta gets a desktop story no Chinese lab can match with an American hardware partner, and a new audience of developers who buy Macs rather than GPUs.

How should a buyer apply this? Expect Meta to keep its best model closed and its open model one step behind, with license conditions aimed at large competitors rather than ordinary developers. Plan around the open model you can download today, not the hosted model it resembles, and benchmark it on your own task before assuming it matches anything Meta sells through its API.

3. Under the hood: what 816B total and 42B active mean

Most coverage of the launch repeated the two parameter counts without explaining why they matter, and the gap between them decides almost every practical question about running the model. A parameter is one of the numbers a model learned during training; together they are the model's knowledge and skill. In a traditional dense model, every parameter is used to produce every word. In a Mixture of Experts (MoE) model like Muse Spark Open, the network is split into many specialist blocks called experts, and a small routing network picks only a few of them for each token. Muse Spark Open has 256 experts per layer and activates 8 for each token, which is how 816 billion parameters in total become about 42 billion in use at any moment - Hugging Face.

The consequence is a split between two hardware limits. Memory capacity has to hold all 816 billion parameters, because the router might pick any expert for the next token. Memory bandwidth only has to move the 42 billion active ones for each token, which is what decides generation speed. That is why Meta's pitch for the Mac Studio is phrased the way it is: the M5 Ultra's unified memory "lets the M5 Ultra's integrated GPU use up to 512 GB per Mac Studio, so two machines can hold an entire model", and its 1.2 TB/s of bandwidth "is fast enough to read the small slice each token needs" - Meta AI Research.

The architecture details in the model card are worth knowing because several of them show up as practical settings later. The language model has 62 layers, a hidden dimension of 8,192, grouped-query attention with 128 query heads sharing 16 key-value heads, and a vocabulary of 202,048 tokens. A separate 1.8-billion-parameter perception encoder turns images and video frames into tokens the language model can read. The weights ship in two precisions: BF16, the full 16-bit format at about 1.64TB, and NVFP4, NVIDIA's 4-bit floating-point format at about 533GB, which is the version almost everyone will actually run - vLLM recipes.

Hugging Face's launch post includes a diagram of the whole system, and it is the clearest single picture of how the pieces fit: separate paths that turn text, images and video, and audio into tokens, feeding one 62-layer language model whose layers each route every token to 8 of 256 experts.

Read the diagram from the inputs inward. Each kind of media has its own encoder, which is why community copies that drop the audio encoder still handle text and images. Everything then becomes the same kind of token, so the expensive part of the model, the experts, is shared across all media types. That shared design is what lets one set of weights read a screenshot, a recording and a code file in the same conversation.

3.1 The 1M-token context, and a number many people got wrong

A context window is how much text, code or media the model can consider at once, and the cost of a long window is the KV cache, the working memory a model keeps for every token it has read. Hugging Face's launch blog calculated that each token adds 126,976 values to the cache, "about 250 KB per token and about 266 GB for a full 1M-token context" - Hugging Face, and a widely read Hacker News comment repeated that the model would "need over 200GB just for the KV cache" at 1M tokens - Hacker News. That calculation assumes every layer remembers every token.

Meta's own documentation says otherwise. "Of its 62 decoder layers, 46 use sliding-window attention over the most recent 2,048 tokens and 16 use full attention. Only the full-attention layers keep a KV cache for the whole context" - Meta developer docs. The vLLM team spells out the consequence: "At 1M tokens, this brings the cache to just over ¼ of what all-full attention would need" - vLLM. Working it through, 16 of 62 layers is about 26%, so a full 1M-token context needs roughly 69GB of cache in 16-bit precision rather than 266GB, and about half that with an 8-bit (FP8) cache, which LMSYS's benchmark configuration uses. That difference is why two Macs holding a 493GB model still have room for long contexts.

3.2 Reasoning effort, tools and the knowledge cutoff

Muse Spark Open is a reasoning model: it writes a private chain of thought before answering, and you control how long that chain can run with a reasoning effort setting. There are exactly four levels, and Meta's prompting guide maps each to a "reasoning strength" the model sees in its system prompt: low is 8, medium is 32, high is 256 and xhigh, the default, is 512. "Reasoning can't be turned off. Any value other than these four, such as none or max, is rejected" - Meta developer docs. Meta's settings page maps each level to a kind of job, which section 11 walks through, and recommends sampling at temperature 1.0 and top_p 1.0 - Meta settings.

Two more details from the chat template matter in practice. The template tells the model its knowledge cutoff is 2026-01-04, so anything after early January has to come from search or documents you provide. And tool calls use Meta's own ATEM format, an XML-like syntax wrapped in <atem:function_calls> blocks, which every inference engine had to add a parser for at launch. Meta's hosted API also offers deferred tool loading through a tool_search feature, so an agent with hundreds of tools can show the model only their names until it needs one, but that feature belongs to Meta's servers and is not part of the open weights. Section 11 covers how to use these settings in a real agent, and section 13 covers the parser inconsistencies they caused on day one.

For a visual walk-through of these trade-offs, the RepoChad channel published a launch-day breakdown of the architecture, the hardware it needs and the problems of running it locally. It is among the most watched English-language videos dedicated to the model so far, and it covers in nine minutes what the next sections cover in detail.

What this means for you: budget memory for all 816 billion parameters, budget speed for 42 billion, and do not believe a KV-cache figure that ignores the sliding-window layers. Those three facts decide which of the hardware options in sections 8 to 10 will work for you.

4. Meta's benchmark table, read row by row

Meta published one large benchmark table with the launch, comparing Muse Spark Open with seven other open-weight models across agentic work, knowledge and reasoning, coding, multimodal understanding and safety. It is better documented than most vendor tables: an eight-page methodology report explains where every number came from, which runs Meta did itself, and which figures it copied from a rival's own announcement - Meta evaluation methodology. That report is the key to reading the table honestly, because a mixed table of independent results, Meta's own runs and competitors' self-reported claims can make any model look better or worse depending on which rows you emphasize.

The table below reproduces Meta's figures for Muse Spark Open and the four rivals most buyers will compare it with. All models were run at the highest reasoning setting available to them (xhigh for Muse and Inkling, max for GLM 5.3 and Kimi K3), which is fair to everyone but also means none of these numbers reflects the cheaper, faster settings most production systems use. A dash means Meta reported no figure, usually because the model does not accept that kind of input or no comparable result existed.

Source: Meta's model card - Hugging Face. The best score in each row is bolded.

Counted plainly, Muse Spark Open takes the top spot in 7 of 20 rows, Kimi K3 in 10 (with one tie), and GLM 5.3 in 3. The pattern in which rows each model wins matters more than the count, and it is consistent: Muse leads where the test rewards knowing what it does not know and using tools carefully, and trails where the test rewards sustained coding and broad knowledge-work output.

4.1 Where Muse Spark Open genuinely leads

The strongest result is MCP-Atlas, Scale AI's benchmark of 1,000 human-written tasks across 36 real Model Context Protocol servers and 220 tools, where Muse scores 89.2 against 84.5 for the next model. Meta's methodology notes that these results were "produced by Scale AI for the remaining models following the official leaderboard's agent harness and scoring pipeline", with only Beam's figure self-reported - Meta evaluation methodology. That makes it one of the cleaner rows in the table. If your agent's job is to pick the right tool among many and call it correctly, this is the most relevant number Meta published.

The second group of wins is about reliability. On HLE-Diamond, a closed-book subset of Humanity's Last Exam sourced from Scale's leaderboard, Muse scores 26.1 against 22.2 for Kimi K3. On AA-Omniscience, Artificial Analysis's test that subtracts wrong answers from right ones so that a confident hallucination costs more than an honest "I don't know", it scores 25, the best of the open field. Artificial Analysis measures its hallucination rate at 24.1% - Artificial Analysis. For agents that write reports, answer customers or fill in forms, a model that abstains instead of inventing is often worth more than one with a slightly higher raw score.

The third group is multimodal, where most rivals cannot compete at all because they do not accept images or video. Muse beats Kimi K3 on ZeroBench, SimpleVQA and IntPhys 2, and trails it on BabyVision, WorldVQA and Video-MME v2. JobBench, 65 professional tasks across 35 white-collar occupations sourced from its official leaderboard, is a narrow win at 61.8 against GLM's 61.4.

4.2 Where it trails, and by how much

The coding rows are the clearest weakness. On Terminal-Bench 2.1, run by Artificial Analysis with the Terminus 2 agent in an E2B sandbox, Muse scores 76.4 against 85.0 for Kimi K3, 83.9 for GLM 5.3 and 82.0 for Qwen. On DeepSWE 1.1, a long-horizon software benchmark of 113 tasks across 91 repositories, it scores 60 against 68 and 67. On SWE-Atlas-QnA, which tests understanding of large production codebases, it scores 58 against 66. These are not rounding errors; they are the gap between a model that finishes most long coding jobs and one that finishes noticeably fewer.

The knowledge-work row is the other notable loss. GDPval-AA v2, OpenAI's benchmark of 220 economically valuable tasks run by Artificial Analysis in its own agent harness, puts Muse at an Elo of 1401, more than 200 points behind GLM 5.3 at 1653 and behind Qwen, Kimi and even Mistral Large 4's 1424. Elo gaps of that size mean the stronger model's deliverables are preferred most of the time in head-to-head judging. The chart below puts the agentic and coding rows side by side for the three strongest open models.

The chart shows the shape of the trade. Muse wins the two tool-use rows on the left, roughly ties on Toolathlon, and falls behind on the three coding rows on the right. If you want a downloadable model mainly to write and fix code, Kimi K3 or GLM 5.3 is the better default today, and our Kimi K3 guide and guide to Z.ai's GLM models cover them in depth.

4.3 The fine print in Meta's methodology

Meta's methodology report deserves credit for disclosing its sources, and it also contains the caveats a careful reader needs. Most vendors publish a table and a footnote; Meta published eight pages that say, row by row, who ran each test, with which harness, and which numbers were copied from a rival's announcement. That transparency is what makes it possible to discount the table correctly rather than accept or dismiss it wholesale.

The practical value is that each caveat points in a known direction. Some inflate every model equally and change nothing about the ranking; others favor one side of a comparison, and those are the ones to watch. Five stand out, and each changes how much weight a row can carry:

• Mixed sources. Some rows are official leaderboards, some are Meta's own runs, and some are a rival's self-reported number.
• Self-reported rivals. Beam and Mistral Large 4 figures were taken from their launch posts.
• Harness differences. DeepSWE used Muse Code for Muse, Claude Code for Qwen and Kimi Code for Kimi K3.
• Best of five. ZeroBench counts a question as solved if any of five sampled answers is correct.
• Untuned rivals. Meta says its setup was "not specifically tuned for third-party models".

Each of those points cuts in a specific direction. Harness differences are the biggest, because an agent benchmark measures the model and its scaffolding together; Kimi K3 scoring 68 on DeepSWE with its own coding agent and Muse scoring 60 with Muse Code is a comparison of two products, not two models. The best-of-five rule on ZeroBench inflates every model's score equally, so it does not distort the ranking, but it makes the absolute number look higher than a single attempt would. Kimi K3's OSWorld figure of 84.8 is self-reported while Muse's 80.4 is Meta's own run over four attempts, so that row compares two different setups. And the note that Meta's evaluation setup "may not reflect their best provider-optimized performance" is a polite way of saying rivals might score higher in their own hands - Meta evaluation methodology.

The practical lesson is to read the rows sourced from neutral parties first (MCP-Atlas from Scale, Terminal-Bench, SciCode, GPQA and GDPval from Artificial Analysis, HLE-Diamond from Scale) and treat the rest as Meta's case for its model. Our piece on why AI coding benchmarks mislead explains the harness problem in more detail, and the next section looks at what neutral evaluators found on their own.

5. What the independent numbers say

Vendor tables tell you what a lab wants you to see; independent evaluators run the same tests on every model with the same harness. Four days after launch, four independent sources had published results for Muse Spark Open: Artificial Analysis, Vals AI, Arena and OpenRouter's usage data. Together they confirm Meta's strengths, sharpen its weaknesses, and add one finding Meta's table did not show at all.

Artificial Analysis is the most complete. It gives Muse Spark Open, at the xhigh setting, a score of 39 on Intelligence Index v4.3, "well above average among comparable models (median: 19)", and ranks it 11th of 121 comparable open-weight models - Artificial Analysis. Its summary is blunt: the model "is amongst the leading models in intelligence, but particularly expensive when comparing to other open weight models of similar size. It's also notably fast and fairly concise". The measured numbers behind that summary are a speed of about 143 tokens per second through the API against a peer median of 78, 110 million tokens generated to complete the index (against a median of 140 million), and an average cost of $0.84 per index task.

The chart makes the positioning concrete. The closed frontier sits 14 to 19 points above Muse Spark Open, Meta's own hosted Muse Spark 1.3 sits about 9 points above it at its maximum setting, and the four strongest open models, all Chinese, sit 5 to 7 points above it. DeepSeek's V4.1 Flash 1017 update, published two days after Meta's launch, jumped from 39.5 to 45.1 on its own and pushed Muse down a place in the open ranking. In a field moving that fast, a launch-day rank is a snapshot, and small differences in price, license and hardware fit often decide more than the score does, which is why the scored table at the top weights those factors heavily.

Artificial Analysis's launch analysis adds the most useful single observation of the week. Among the nine highest-scoring open-weight models at the time, Muse Spark Open "ranks last on the four agentic evaluations in the index but fourth on the other six combined", and it "leads all open-weights models on AA-Omniscience (25)" - Artificial Analysis on X. The same post notes that GLM 5.3 "owes all of its 6-point lead to the agentic evaluations", and that Muse uses about 40,000 output tokens per index task, the fewest of that group. In one sentence: Muse knows a lot, guesses rarely and talks briefly, but it is weaker than its Chinese peers at the long, multi-step work that agents do.

5.1 The Terminal-Bench 4.0 problem

The finding Meta's table did not show is on Terminal-Bench 4.0, the newest and hardest version of the terminal-task benchmark, which is one of the four agentic tests in the Intelligence Index. Meta's table reports Terminal-Bench 2.1, where Muse scores 76.4. On version 4.0, Artificial Analysis's own data shows Muse Spark Open solving about 8.1% of tasks - Artificial Analysis. Vals AI found almost the same: 6.57%, ranking 41st of 50 models on that test - Vals AI. For comparison, Meta's hosted Muse Spark 1.3 scored 33.3% on Terminal-Bench 4.0 in Artificial Analysis's testing, and the closed frontier models scored between about 52% and 60%, as we reported in our Muse Wonder guide.

Two readings of that gap are possible, and both matter. The charitable one is that Terminal-Bench 2.1 has become easy enough that strong models cluster in the high 70s and 80s, while 4.0 still spreads them from single digits to about 60%, so a vendor quoting 2.1 is following common practice rather than hiding something. The less charitable one is that the extra safety post-training and the older post-training recipe cost the open model precisely the kind of persistent, multi-step terminal work that 4.0 rewards, which would also explain its last place on the agentic part of the index. Either way, if your agent's job is long autonomous sessions in a shell, test it yourself before committing, and do not read the 76.4 as a promise.

5.2 Vals, Arena and real-world usage

Vals AI places Muse Spark Open "#39 of 50 models on the Vals Index with 46.61%", while noting that its best result is third of 80 models on Finance Agent (v2), at 61.34% - Vals AI. The finance result fits the reliability pattern from section 4: a model that abstains rather than inventing numbers does well on tasks where a wrong figure is worse than no figure. Vals ran it through Together AI at xhigh effort and measured a cost of about $4.08 per test and an average latency of over an hour per test, a reminder that reasoning models at maximum effort are slow and token-hungry even when the per-token price looks moderate.

On Arena, where human voters compare anonymous answers, Muse Spark Open had not yet appeared on the main text leaderboard in the data Arena published on October 15, while Muse Wonder, Muse Spark 1.3 and Muse Glimmer were all listed. On the WebDev board, where voters judge generated web apps, Crypto Briefing reported a launch score of 1511, "making it the highest-ranked US open model on that board" - Crypto Briefing. Arena's published leaderboard data for October 18 shows it at about 1524 after 1,337 votes, 50th overall, with every open model above it from a Chinese lab - Arena leaderboard data. On OpenRouter, early usage is dominated by coding agents: the open-source agent pi accounts for more than 35 billion tokens, with Claude Code also among the top apps - OpenRouter. Developers are clearly trying it as a drop-in engine for existing agent harnesses.

5.3 What developers said

The Hacker News discussion, 917 points and 477 comments by October 19, captured the reaction better than any review. The top comment by replies compared it unfavorably with smaller Chinese releases, saying it was "underperforming Qwen3.8 Flash Next and GLM 5.3 Flash" and that "Meta has a bit of catching up to do in the open-weight space" - Hacker News. Another developer reported testing it locally against GLM 5.3 Flash and finding it "slower in TTFT, tok/s and concurrency" - Hacker News. On the positive side, one tester called it "one of the best open models I've seen for conversion" of images into HTML - Hacker News, which fits the multimodal strengths in Meta's table.

The separate thread on Apple's benchmark post, at 365 points, added a methodological objection worth knowing about. Apple's comparison ran Muse at 4-bit while Qwen 3.8 27B ran at full 16-bit precision and Mistral Medium 3.5 at 8-bit, and a commenter put it sharply: "they're sandbagging Qwen pretty heavily by benchmarking Meta's model at 4-bit, against Qwen only at native BF16" - Hacker News. Apple states the formats openly in its own post, so nothing is hidden, but it is a reminder that speed comparisons between models in different formats compare formats as much as models.

How to apply all of this: the independent evidence says Muse Spark Open is a knowledgeable, careful, multimodal mid-tier open model that is weaker at long agentic and coding sessions and more expensive than its Chinese peers. Run your own evaluation on a sample of your real tasks at the reasoning setting you would use in production, because the gap between xhigh results and medium-effort behavior can be large. Our October ranking of LLMs for AI agents places it in the wider market.

6. The Muse Model License, clause by clause

"Open weights" and "open source" are not the same thing, and the Muse Model License is where the difference lives. The license text is short, about 600 words plus a usage policy, and it is shown in full on the gated Hugging Face page, where every downloader must accept it - Hugging Face. Meta's own description is that it carries "limited commercial terms, which allow many developers to use the model for free" - Meta AI Research. Both halves of that sentence are accurate, and which half applies to you depends on what you build.

The structure is borrowed from the MIT license, one of the most permissive licenses in software, and then constrained. The opening grant gives anyone the right "to use, copy, modify (including fine-tune), create derivative works, distill, merge, publish, distribute, sublicense, and/or sell copies" of the model. That is genuinely broad: fine-tuning, distillation and resale are all explicitly allowed. Then come the conditions that MIT does not have, and they are what a business has to plan around.

6.1 The four conditions in plain language

Condition 1: the license travels. Anyone who distributes the model or a derivative must include the license and Meta's usage policy, and must follow that policy, which is "incorporated into this license". This is what turns the usage policy (section 6.2) from guidance into a contractual obligation.

Condition 2: the label. The license requires that the licensee "shall prominently display 'Built with Muse Spark Open' in the user interface of each product or service that uses the Software or any Derivatives, or in the accompanying documentation, website, or settings menu". There is no size threshold. A hobby app, an internal tool and a product used by millions all owe the label. The definition of Derivatives is wide: "any AI model created, trained, modified (including fine-tuned), distilled, or otherwise improved using the Software or any outputs or results thereof". The phrase "or any outputs" matters: a model trained on text Muse Spark Open generated is a derivative too, so a startup that uses Muse to create synthetic training data for its own model takes on the attribution duty for that model.

Condition 3: the hosting deal. If the licensee or its affiliates offer AI models to third parties through an API ("Model as a Service") and their combined gross revenue "exceeds twenty (20) million US dollars" in any 12 months, they "must notify Meta and enter into a separate written agreement with Meta" before offering Muse in that business. The clause explicitly does not apply to "internal use, research, or any commercial activity that is not Model as a Service", or to using the model "as a component to power features of the Licensee's own product or service". In practice it targets inference clouds and API resellers, not companies building their own apps.

Condition 4: outputs are yours. Meta claims no ownership of what the model writes for you. The remaining text is a standard warranty disclaimer, plus two notable lines, written in capitals in the original: Meta "shall have no liability with respect to any Derivatives", and the licensee "is solely responsible for the safety, deployment, and use of its Derivatives". For licensees in the European region, the contracting party is Meta Platforms Ireland Limited.

The diagram shows why most developers will never feel the hosting clause, and why everyone feels the attribution clause. For a typical company building an internal agent or a product feature, the only real obligations are the label and the usage policy. For an inference provider or a large reseller, the separate agreement is the gate, and Meta decides its terms.

6.2 The usage policy, and why it matters more than it looks

The usage policy attached as Exhibit A is the part most likely to surprise a commercial user, because the license makes compliance a condition of the grant. Most of it bans what every model policy bans: illegal content, harassment, malware, fraud and impersonation.

The difference from an ordinary terms-of-service page is enforcement. A hosted API provider enforces its policy by watching traffic and closing accounts; a downloaded model has no one watching, so Meta's only lever is the license itself, which makes following the policy a condition of using the weights at all. That turns a few unusual clauses into real business risks for companies that would never think of themselves as policy violators. Five provisions go further than usual and deserve attention before you deploy:

• No users under 18. The policy states the model "is not intended for individuals under the age of 18".
• No military or nuclear uses. It bans "Military, warfare, nuclear industries or applications, espionage" and ITAR-controlled work.
• No critical infrastructure. It bans "Operation of critical infrastructure, transportation technologies, or heavy machinery".
• No unlicensed professional practice. Financial, legal and medical advice without a license is prohibited.
• No passing off outputs as human. It bans "Representing that the use of Muse Spark Open or outputs are human generated".

The last two are where ordinary businesses need care. An AI customer-support agent that answers billing questions is fine; one that gives individualized financial or legal advice may cross the "unlicensed practice" line depending on jurisdiction. A marketing workflow that publishes AI-drafted copy under a human byline arguably "represents" outputs as human-generated. And the critical-infrastructure ban is broad enough that utilities, transport operators and industrial automation vendors should get legal advice before building on the model at all. None of these restrictions exist in an Apache 2.0 or MIT license, which is the practical meaning of the difference between open weights and open source. The Open Source Initiative's definition of open-source AI requires the freedom to "use the system for any purpose and without having to ask for permission" - Open Source Initiative, which the usage policy plainly does not grant.

There is also a gate before the license. Downloading the weights from Hugging Face requires a form with your first and last name, date of birth, country, affiliation and job title, under a heading that asks for your full legal name and full organization name, and approval is manual; one Hacker News user reported "the approval was received in about 10 minutes or so" - Hacker News. Artificial Analysis gives the model an Openness Index of 27.8 out of 100 and labels it "Open Weights (Commercial Use Restricted)" - Artificial Analysis.

6.3 How it compares with other open-weight licenses

The Muse license is best understood by comparison, because it sits in a cluster of custom licenses that Chinese and American labs have converged on during 2026. The New Stack observed that "this looks a lot like the license that Moonshot uses for Kimi K3" - The New Stack, and Trending Topics concluded that for large cloud providers that want to resell the model, "Meta remains the gatekeeper" - Trending Topics. The table compares the conditions a business actually has to track.

Sources: Kimi K3 license, Qwen model card, GLM 5.3 model card, Llama 3.1 license.

Two comparisons stand out. Against Meta's own history, the Muse license is looser than Llama's in one way and stricter in another: it drops the old rule that derivative models must put "Llama" at the start of their name and the 700-million-user cap, but its hosting trigger at $20 million in revenue catches far more companies than Llama's user cap ever did. Against Kimi K3, the hosting clause is identical, but Muse's attribution duty applies to every product while Kimi's only applies to very large ones, so Muse is the stricter of the two for small companies. A Hacker News commenter predicted the market effect: "The usual effect of separate licensing is decreased price competition from public providers (like we saw with Kimi K3)" - Hacker News. Sections 7 and 13 show that prediction holding so far.

What to do with this: if you build your own product or run the model internally, the license costs you a label and a policy review. If you are, or plan to become, a model-hosting business with more than $20 million in revenue, budget for a negotiation with Meta. If you need freedom from use restrictions, for example in defense or infrastructure, choose an Apache 2.0, MIT or OpenMDW model instead. This is a summary for orientation, not legal advice; read the license and talk to counsel before shipping.

7. What it costs: API, rented GPUs, or your own Macs

There are three ways to pay for Muse Spark Open, and they have completely different cost structures. Through an API, you pay per token and own nothing. On rented GPUs, you pay per hour for hardware whether or not it is busy. On your own Macs, you pay once for hardware and then only for electricity, at the cost of speed. The right choice depends less on the headline price than on how many tokens you will push through the model and how much of that traffic repeats.

The API price is the same everywhere, which is the first unusual fact. OpenRouter lists $1.25 per million input tokens, $0.15 per million cached input tokens and $4.25 per million output tokens at every host serving the model: Fireworks, Together, Baseten, Modal and Nebius - OpenRouter. Fireworks shows the same rates on its own page and notes a limited preview "through October 29, 2026, on US-only capacity, with the usual 50% US-only premium waived" - Fireworks AI. Groq offers the model in limited preview at "~350+ tps", with a shorter 131,072-token context and no public price - Groq. Those rates also match exactly what Meta's hosted Muse Spark 1.3 costs on OpenRouter, which suggests the hosts are following a reference price rather than competing on cost.

7.1 Price per token versus cost per task

Artificial Analysis calls those prices "expensive" for an open model, against a median of $0.43 input and $1.68 output among comparable models - Artificial Analysis. But the price per token is only half the story; what matters is the cost to finish a task, which also depends on how many tokens the model spends thinking. Because Muse is concise, its cost per Intelligence Index task is $0.84: less than half of GLM 5.3's $2.01 and Kimi K3's $2.00, whose low input prices are offset by longer reasoning (GLM uses about 71,000 output tokens per task against Muse's 40,000) and, for Kimi, expensive output. The chart compares it with both open and closed models.

The chart says Muse Spark Open is a cheap way to buy mid-tier intelligence compared with the closed frontier and with Kimi K3, but not compared with OpenAI's mid-tier or the two cheapest open leaders. GPT-6.1 Sol finishes an index task for less money while scoring about 13 points higher, and MiMo-V2.6-Pro and DeepSeek V4.1 Flash 1017 each score 6 to 7 points higher at a third or less of Muse's cost per task. The closed models not shown sit higher still: Muse Wonder at $4.52 per task, and Gemini 4 Argon at $1.99, a figure based on introductory pricing of $2 and $10 per million tokens through November 30 that rises to $4 and $20 on December 1 - Google AI for Developers, as our Gemini 4 Argon guide explains.

7.2 Worked example: one agent turn

Per-task averages hide the structure of agent workloads, so it helps to price a single turn. The LMSYS team benchmarked Muse Spark Open on a realistic coding-agent workload: each conversation starts with a prompt of about 74,000 tokens, each turn sends about 80,000 tokens in total and gets back about 220, and because successive turns repeat most of the prompt, about 92% of input tokens hit the cache - LMSYS. At API prices, one such turn costs about two cents: roughly $0.011 for the 73,600 cached tokens at $0.15 per million, $0.008 for the 6,400 fresh tokens at $1.25, and under $0.001 for the 220 output tokens at $4.25. Input, not output, is about 95% of the bill.

That single fact reshapes the self-hosting question. A naive comparison looks only at output speed: two Macs generating 25 tokens per second around the clock produce about 2.2 million tokens a day, worth only about $9 at the API's output price, which would never repay the hardware. But an agent mostly reads. Using Apple's measured time-to-first-token of 8.2 seconds for an 8,192-token prompt on two Macs in tensor-parallel mode, which works out to roughly 1,000 tokens per second of prompt processing, a turn with 6,400 fresh tokens and 220 output tokens takes about 15 seconds. That is roughly 230 turns an hour, or about $4.60 of API-equivalent work per hour.

The arithmetic now depends on use. Run that agent eight hours a day on 250 working days and it replaces roughly $9,200 of API spend a year; run it around the clock and the figure is about $40,000. MacRumors notes the 256GB Mac Studio "is already priced over $10,000" - MacRumors, and Apple has not yet priced the 512GB model, so a two-Mac setup will cost at least $20,000 and likely more. That implies a payback period of roughly two years for a single working-hours agent, or about six months for one that never stops. There is one large assumption: that the server reuses the shared prompt between turns. If it does not, every turn re-reads all 80,000 tokens at about 1,000 tokens per second, each turn takes well over a minute, and the economics collapse.

7.3 Renting GPUs instead

Rented GPUs flip the trade-off: they are far faster than Macs but cost money every hour. Meta's documented minimum for the NVFP4 model is four B300 GPUs - Meta developer docs, and RunPod lists B300s at $8.99 per GPU-hour on its secure cloud and $6.94 on its community cloud - RunPod. Four of them at the secure rate cost about $36 an hour, or about $863 a day. To beat the API at two cents a turn, that server must sustain about 1,800 agent turns an hour, one every two seconds, around the clock.

LMSYS's benchmark shows how plausible that is. On eight B300s running 128 conversations at once, total throughput reached 80.3K tokens per second per GPU. Each turn in that workload processes roughly 80,000 tokens, so the eight-GPU server completes about eight turns per second, close to 29,000 an hour, at an hourly cost of about $72: roughly a quarter of a cent per turn, about one-eighth of the API price. Even with a single conversation running, the 14.8K tokens per second per GPU works out to about 1.5 turns per second for the whole server, or about 1.4 cents a turn. Two caveats keep these figures honest: the benchmark fixed the speculative-decoding acceptance length at 4.5 instead of measuring it, and it replays turns back to back without the seconds a real agent spends running tools, so a real deployment needs many concurrent agents to keep the hardware that busy.

How to apply this: for a few agents or occasional use, the API is cheapest and simplest. For many concurrent agents with steady traffic, rented GPUs win once utilization is high. Macs win only for always-on agents with heavily repeated context, or when privacy, offline operation or data sovereignty is worth paying for on its own. Our analysis of the true cost of LLM inference and our guide to AI model routing cover how to mix these options, sending routine turns to a cheap model and hard ones to a stronger model.

8. How to run it on two or four Mac Studios

The Mac path made the headlines, and it also has the strictest requirements. Meta's hardware page lists exactly two Apple configurations: "Two Mac Studio computers with M5 Ultra and 512 GB of unified memory each, or four with 256 GB each" - Meta developer docs. Both add up to about a terabyte of memory, and that number is not arbitrary. Apple's engineering post explains that the full model "would require more than 1.6TB of RAM in its native precision (BF16)", while the 4-bit NVFP4 version brings the footprint down "to about 493GB" - Apple Machine Learning Research. Half a terabyte of weights plus room for long contexts is more than any single Mac holds, so the model has to be split across machines.

What makes the split practical is a change most Mac owners never noticed. macOS 26.2 added a low-latency RDMA driver over Thunderbolt 5, and MLX 0.30.1 added a matching communication backend called jaccl. RDMA (remote direct memory access) lets one Mac read another Mac's memory without going through the normal networking stack, which cuts the delay of every exchange between machines. There are two ways to use it. In pipeline mode, each Mac holds a block of layers and a token passes through Mac A, then Mac B. In tensor mode, every layer is split across all the Macs and they work on each token together, which is faster but needs the fast link. Apple tested both, and the difference matters for what you can expect.

The machine in the photo looks like any other desktop, which is the point of the partnership. Inside it, the M5 Ultra has up to 512GB of unified memory and 1.2TB/s of memory bandwidth, "50 percent higher than before" - Apple Newsroom. Unified memory means the GPU can use almost all of it, unlike a PC where the graphics card has its own small pool. That single design choice is why a pair of Macs can do a job that otherwise needs a rack of datacenter GPUs.

8.1 What you need before you start

The shopping list is short but expensive, and one part of it is not on sale yet. Apple's newsroom post states that the "Mac Studio with 512GB of unified memory is coming in late October", while the M5 Ultra model "starts at $5,499" in a 96GB configuration. Engadget estimated that the four-Mac route, using 256GB machines, "will cost roughly $38,000" - Engadget, and the two-Mac route depends on a 512GB price Apple has not yet published.

Meta's run-inference page lists the software and wiring requirements, and they are strict: every Mac needs a direct Thunderbolt 5 link to every other Mac, not a hub or a network switch - Meta developer docs. Apple's tests went one step further and doubled every link, "connected with two Thunderbolt cables (to double the link bandwidth)". In summary, you need:

• Two or four Mac Studios with M5 Ultra, 512GB or 256GB each
• Thunderbolt 5 cables, one direct link per pair of Macs, ideally doubled
• macOS 26.2 or later on every machine, for the RDMA driver
• MLX 0.30.1 or later and passwordless SSH between the Macs
• Approved Hugging Face access to the gated Meta repository

The cabling line is the one people underestimate. Two Macs need one link (two cables if doubled). Four Macs in a full mesh need six links, which means every Mac connects directly to the other three, and doubling them uses six Thunderbolt connections per machine. Power is modest by datacenter standards: Apple puts the M5 Ultra's peak at about 300W, so even a four-Mac cluster peaks around 1.2kW, a small fraction of an eight-GPU datacenter server. And the Hugging Face approval is manual, so request access a day before you plan to download 533GB of weights.

8.2 Step by step

The setup takes an afternoon if nothing goes wrong, and most of it is one-time configuration. The commands below come from three official sources: the MLX distributed documentation for enabling RDMA and writing the cluster file - MLX docs, Apple's Muse post for the launch commands, and Meta's own deploy page for the requirements. Run the first steps on every Mac.

Step 1: switch on RDMA. RDMA has to be enabled from macOS Recovery, which is a deliberate security choice by Apple. Restart each Mac into Recovery, open Terminal from the Utilities menu, run the command, then restart normally. Afterwards, ibv_devices should list the Thunderbolt RDMA interfaces.

# In macOS Recovery > Utilities > Terminal, on every Mac
rdma_ctl enable

# After a normal restart, confirm the RDMA devices exist
ibv_devices

Step 2: install and download. Install the MLX packages and log in to Hugging Face with the account whose access Meta approved. Each Mac reads the weights from its own local copy, so download the NVFP4 checkpoint on every machine before the first launch rather than letting four Macs pull 533GB at the same moment.

pip install -U mlx "mlx-lm>=0.32.2"
hf auth login
hf download meta-models/Muse-Spark-Open-816B-A42B-NVFP4

Step 3: describe the cluster. MLX needs a hostfile that tells it which Mac is which and which Thunderbolt interfaces connect them. The mlx.distributed_config tool discovers this automatically over Thunderbolt and writes the file for you. Replace the host names with your own Macs' SSH names; for a two-Mac cluster, list two.

mlx.distributed_config --verbose \
  --hosts mac-studio-1,mac-studio-2,mac-studio-3,mac-studio-4 \
  --over thunderbolt --backend jaccl \
  --auto-setup --output hostfile.json

Step 4: benchmark, then serve. Apple's post uses mlx.launch to start the same command on every Mac at once. The first command measures speed with an 8,192-token prompt; the second starts an OpenAI-compatible server on port 8080, which any agent, chat app or coding tool that speaks the OpenAI API can use - Apple Machine Learning Research.

mlx.launch --hostfile hostfile.json --backend jaccl --env MLX_METAL_FAST_SYNCH=1 -- \
  mlx_lm.benchmark --model meta-models/Muse-Spark-Open-816B-A42B-NVFP4 -p 8192 -g 128 -b 1

mlx.launch --hostfile hostfile.json --backend jaccl --env MLX_METAL_FAST_SYNCH=1 -- \
  mlx_lm.server --model meta-models/Muse-Spark-Open-816B-A42B-NVFP4 --port 8080

One flag deserves a warning. Both Apple and Meta set MLX_METAL_FAST_SYNCH=1, but the MLX documentation says the setting "is however not reliable" and can "lead to deadlock and leave the GPU wedged", which is why it is off by default. If a run hangs and the GPU stops responding, drop the flag and accept slightly lower speed. Apple's post also includes a ready configuration for the OpenCode coding agent pointing at http://127.0.0.1:8080/v1, which is the quickest way to test the model on real coding work once the server is up.

8.3 What speed to expect

Apple published two tables, one for the delay before the first word appears (time to first token, which depends on how fast the cluster reads your prompt) and one for generation speed once it starts. Both were measured with the NVFP4 model at two context lengths, and they show a trade-off that the headline number hides.

Source: Apple Machine Learning Research, tables 2 and 3 - Apple.

The generation numbers are good news. About 25 tokens per second on two Macs is faster than most people read, and the speed barely drops as the context grows, because the sliding-window layers described in section 3 keep most of the cache small. The first-token numbers are the catch. On two Macs in tensor mode, a 65,000-token prompt takes 70 seconds before anything comes back, slower than pipeline mode's 47.6 seconds, because splitting every layer across two machines adds communication to the prompt-reading step. Four Macs fix both problems at once, which is why Meta's deploy page notes that "four Macs serve fastest".

For agent work, that first-token delay is the number to plan around. An agent rereads a long context on every turn, so a setup that needs a minute to read 65,000 fresh tokens is only usable if the server keeps the shared part of the prompt cached between turns, the same condition that decided the economics in section 7. Apple also measured the generation gap to the previous Mac: time to first token is "up to 4.6× faster" than on an M3 Ultra and generation is "1.6× faster", so the older 512GB M3 Ultra Mac Studios that already exist can run the model too, just more slowly. Finally, remember the objection from section 5: Apple's comparison tables ran Muse at 4-bit while Qwen 3.8 27B ran in BF16 and Mistral Medium 3.5 in FP8, so they compare formats as much as models.

9. How to run it on GPU servers

For a team serving many users or many agents at once, GPUs are the serious option, and the setup is simpler than the Mac path because the inference engines did the work before launch. Meta's hardware matrix lists four routes: NVIDIA B300 or GB300 GPUs, four for the NVFP4 model and eight for BF16; AMD MI355X or MI350X, eight GPUs in BF16, MXFP4 or FP8 on vLLM; and even Intel Xeon 6 server processors running an INT4 copy on SGLang - Meta developer docs. The NVFP4 format is the one most people will use, and it is "specifically for NVIDIA Blackwell GPUs" - Hugging Face, so older Hopper cards (H100, H200) need a different checkpoint.

The choice of format decides the bill. The NVFP4 checkpoint is 533GB, and vLLM's recipe notes that it "fits one 8-GPU node" of current Blackwell hardware with room for long contexts, while the BF16 checkpoint needs a minimum of about 1,959GB of GPU memory in the same recipe - vLLM recipes. In practice that means a single Blackwell server for NVFP4 and two eight-GPU Hopper servers for BF16. AMD users have their own 4-bit option, a Quark MXFP4 checkpoint of about 509GB.

Sources: Meta's hardware page, NVIDIA's NIM guide and vLLM's recipe; the H200 row is derived from vLLM's 1,959GB BF16 minimum.

9.1 vLLM

vLLM is the most widely used open-source inference server, and its team shipped day-zero support with a dedicated Docker image, vllm/vllm-openai:muse-spark-open (and a ROCm twin for AMD). Two caveats apply this week. The vLLM recipe says "no pip wheel is available now", and the vLLM blog says a regular release will follow "after the code (PR #61879) is reviewed and merged, which usually takes about a week" - vLLM. Until then, use the Docker image or a nightly build.

Meta's deploy page gives the minimal command for four B300 GPUs. The two parser flags are the important part: they translate the model's private reasoning and its ATEM-format tool calls into the standard OpenAI response shape, and without them an agent framework sees raw markup instead of tool calls.

vllm serve meta-models/Muse-Spark-Open-816B-A42B-NVFP4 \
  --tensor-parallel-size 4 \
  --enable-expert-parallel \
  --max-model-len 1048576 \
  --reasoning-parser muse \
  --tool-call-parser muse \
  --enable-auto-tool-choice

vLLM's own recipe uses eight GPUs and adds speculative decoding with a small draft model, Inferact/Muse-Spark-Open-DSpark, that guesses several tokens ahead so the large model can verify them in one pass. It is worth enabling once the basic server works, because generation speed is where large MoE models feel slowest. On Google's TPUs, vLLM reports "over 650 tokens/sec on 4 TPU v7 chips" with the draft model against 270 without it, which shows how much the trick can be worth.

9.2 SGLang

SGLang, maintained by the LMSYS team, is the other major server, and it published the most useful real-world benchmark of the launch. Rather than a synthetic prompt, LMSYS replayed a coding-agent workload: each conversation starts with a prompt of about 74,000 tokens and runs 13 turns, with a cache hit rate of about 92% - LMSYS. On eight B300 GPUs with the NVFP4 model, it measured "14.8K total tokens/sec per GPU at 543 tokens/sec per user" with one conversation running, and "80.3K total tokens/sec per GPU at 61 tokens/sec per user" with 128 running at once.

The chart shows the basic trade-off of serving any model: as more conversations share the server, total throughput rises and each user's speed falls. At one conversation, a user gets over 500 tokens per second, more than twenty times what two Macs deliver. At 128, each user still gets 61 tokens per second, more than double the Macs, while the server does about five times more total work. One honest caveat sits in LMSYS's appendix: the speculative-decoding acceptance length was "fixed at 4.5 through SGLANG_SIMULATE_ACC_LEN", a benchmark setting that assumes the draft model guesses well. Real acceptance varies by task, so treat these numbers as a ceiling.

Meta's deploy page lists the Docker image lmsysorg/sglang:dev-muse-spark-open and a launch on four GPUs; the command below is its core, and the page lists further flags for each GPU type. The LMSYS benchmark used a much longer command with more than twenty flags for caching, CUDA graphs and the DFlash2 draft model (RadixArk/Muse-Spark-Open-DFlash2); get the core command running first and add those afterwards.

sglang serve --model-path meta-models/Muse-Spark-Open-816B-A42B-NVFP4 \
  --tp-size 4 --ep-size 4 \
  --quantization modelopt_fp4 \
  --reasoning-parser muse --tool-call-parser muse

9.3 NVIDIA NIM and the cloud catalogs

Teams that want a packaged container rather than an open-source server can use NVIDIA's NIM, which wraps SGLang with NVIDIA's support and update process. Its guide is explicit about limits: "This model has been verified on the NVIDIA-B200 GPU only", the first run "downloads about 500 GB of weights", and on eight B200s the server is ready about 6 to 10 minutes after the download - NVIDIA NIM docs. It needs CUDA 12.9 or later and driver 580 or later.

The managed clouds are the easiest route of all. Meta lists the weights in Amazon SageMaker AI, Google Cloud Model Garden and Microsoft Foundry, where deployment runs through the cloud's own console at its normal GPU-hour rates. For hourly hardware prices, RunPod lists B300s at $8.99 per GPU-hour on its secure cloud and $6.94 on its community cloud, B200s at $7.99 and H200s at $5.29 - RunPod, while Nebius charges $9.50 for an HGX B300 GPU-hour - Nebius. Section 7.3 worked through what those rates mean per agent turn.

The practical sequence for a GPU team is short. Start with the vLLM or SGLang Docker image on four B300s or eight B200s, confirm tool calls come back parsed, then add speculative decoding and prefix caching, and only then tune the long list of performance flags. If your hardware is Hopper-generation, budget for the BF16 checkpoint on two nodes, or rent Blackwell capacity for the NVFP4 model instead.

10. Running it on less: quantized copies and llama.cpp

Not everyone has a terabyte of memory, and the open-source community moved within hours to shrink the model further. Quantization stores each parameter in fewer bits, which cuts memory and speeds up generation at some cost in quality. Meta's NVFP4 release is already a 4-bit format; community projects went down to 3, 2 and even 1 bit. The question is how far you can push it before the model stops being worth running.

Unsloth, which publishes the most popular compressed copies, gives a clear answer: "quants below UD-IQ2_S do degrade for general tasks", and it recommends UD-IQ2_S as the minimum for agentic work - Unsloth docs. Its guide also gives the memory needed for each level, counting system memory and GPU memory together: about 180 to 212GB at 1 bit, 250 to 316GB at 2 bits, 346 to 410GB at 3 bits, 512GB at 4 bits and 870 to 950GB at 8 bits. The chart shows the actual file sizes of the main published copies.

The chart makes the practical threshold visible. Everything at 3 bits and above needs more than 256GB, so the realistic single-machine target is a Mac Studio or workstation with 512GB, and the minimum copy Unsloth trusts for agents, UD-IQ2_S at 275.5GB, still needs more than a 256GB machine once you add room for the context. Below that, the 1-bit and smallest 2-bit copies fit in 256GB but give up enough quality that the case for running Muse at all weakens.

10.1 One 512GB Mac

The most interesting result for individuals is that a single 512GB Mac can run a 3-bit copy at usable speed. Hugging Face tested the MLX community's oQ3e quantization on an M3 Ultra with 512GB, where "the model takes about 344 GB" and runs at "about 225 tok/s prefill and 21 tok/s generation" with a short prompt - Hugging Face. The same blog measured an importance-calibrated 2-bit copy in llama.cpp at 18 tokens per second using 304GB. Those are M3 Ultra numbers, from machines people already own; the M5 Ultra should be faster.

pip install -U "mlx-lm>=0.32.2"
mlx_lm.generate --model mlx-community/Muse-Spark-Open-816B-A42B-oQ3e \
  --prompt "Summarize the attached contract in five bullet points" \
  --max-tokens 5000

Two limits apply to the single-Mac route. The community MLX copy has no audio encoder, so it handles text and images but not recordings. And the 4-bit model barely fits: its 493GB footprint plus about 69GB of cache for a full million-token context comes to roughly 560GB, more than one 512GB machine holds, so a single Mac running the 4-bit model must use much shorter contexts. The 3-bit copy leaves room for long contexts, which is why most single-Mac users pick it.

The screenshot shows what local use looks like day to day: a normal chat window, the model's reasoning visible above its answer, and no data leaving the machine. That last point is the real argument for the single-Mac route. It will never match a GPU server's speed, but for a lawyer, a doctor's office or an engineer working on unreleased code, a model that runs entirely offline on hardware they own changes what they are allowed to use it for.

10.2 llama.cpp and Unsloth on any hardware

llama.cpp runs on almost anything: Macs, Windows and Linux PCs, with or without a GPU, splitting the model between graphics memory and system memory. Hugging Face's blog gives the shortest path with the new llama installer, which downloads a ready-made 2-bit copy from the ggml-org repository and starts a local server - Hugging Face.

curl -LsSf https://llama.app/install.sh | sh
llama serve -hf ggml-org/Muse-Spark-Open-816B-A42B-GGUF:Q2_K

Unsloth's copies come with one launch-week warning: its guide says llama.cpp pull request #30616 "needs to be merged for building from main to work", and until then you should use Unsloth's own prebuilt binaries. Its recommended settings are temperature 1.0 and top-p 1.0, matching Meta's. On a PC, the speed of a split model depends on how much of it sits in system memory, and ordinary desktop memory has a small fraction of the Mac Studio's 1.2TB/s of bandwidth, so expect a 256GB workstation running the smallest copies to be noticeably slower than the Mac figures above.

hf download unsloth/Muse-Spark-Open-816B-A42B-GGUF \
  --local-dir unsloth/Muse-Spark-Open-816B-A42B-GGUF \
  --include "*UD-IQ2_S*"

xCreate, a creator who tests local models on Apple hardware, ran a 4-bit MLX copy on a 512GB M3 Ultra Mac Studio for a full day, building small 3D scenes, games and other creative projects with it. The video is a realistic picture of daily use on hardware people already own, at the speeds this section describes.

10.3 The Ollama and LM Studio trap

Many people's first instinct is to type ollama run or search LM Studio, and both apps do list the model, but neither offers a local download. Ollama's page lists only a muse-spark-open:cloud tag, priced at $1.25 per million input tokens and $4.25 per million output tokens - Ollama. LM Studio states plainly that its page "lists the Cloud model only; it does not include local downloads" - LM Studio. In both apps, choosing Muse Spark Open sends your data to a remote server at API prices, which defeats the purpose if privacy was the reason you wanted a local model.

10.4 When a smaller model is the better answer

The honest conclusion of this section is that most people who want a private model on one machine should not run Muse Spark Open at all. A 2-bit copy of an 816B model is a compromise on every axis: quality, speed and context length. Meta's own Muse Glimmer 30B runs on a single 24GB graphics card under the permissive Apache 2.0 license, as we showed in our Muse Glimmer guide, and NVIDIA released Nemotron 3.5 Bolt 74B-A9B, a model sized for 24GB, on the same day as Muse Spark Open - NVIDIA.

The rule of thumb that falls out of the numbers: run Muse Spark Open locally only if you have at least 512GB of fast unified memory, or a terabyte across several Macs, and a task that needs its specific strengths (multimodal input, tool reliability, an American origin). Below that, a smaller model at full quality usually beats a large model squeezed into too little memory, and our survey of open-source LLMs lists the alternatives.

11. Using it in an agent: reasoning, tools and the harness

Meta built Muse Spark Open for agents, and agent work exposes settings that a chat window hides. A chatbot answers once; an agent loops through dozens of turns, calls tools, reads their output and decides what to do next, so a small inefficiency per turn multiplies into a large bill or a slow product. Three choices decide most of the outcome: how hard the model thinks on each turn, how its tool calls reach your code, and whether the server can reuse the parts of the conversation that repeat.

The good news is that Meta documented all three more carefully than most labs do. Its settings page, prompting guide and deploy page together answer most of the questions a builder hits in the first week - Meta developer docs. The less good news is that the defaults are tuned for benchmark scores rather than for cost, so a team that never changes them pays for the deepest possible reasoning on every trivial step.

11.1 Choosing the reasoning effort

The default effort is xhigh, the deepest of the four levels, and it is what Meta used for every benchmark in the model card. That makes sense for a launch table, where the goal is the highest possible score, but it is the wrong default for most production traffic. Reasoning tokens are billed as output tokens, at $4.25 per million through the API - OpenRouter docs, and on a Mac cluster every reasoning token costs about 40 milliseconds of waiting, so a model that thinks deeply on every step is both slower and more expensive than it needs to be, often with no gain in quality.

Meta's own settings page maps the levels to jobs, and following that mapping is the single cheapest optimization available:

• low for classification, extraction, straightforward questions and short tool loops
• medium for "general agentic work"
• high for multi-step reasoning, hard debugging and long tool loops
• xhigh for "problems where depth matters more than latency"

The interesting line is medium, which Meta itself names as the setting for general agent work. Most agent turns are routine: read a file, pick the next tool, summarize a result. Running them at xhigh spends hundreds of reasoning tokens where a few dozen would do, and because reasoning cannot be turned off, the only control you have is the level. A sensible pattern is to run the loop at medium, switch to high or xhigh for planning and for steps that failed once, and use low for pure extraction. Meta's prompting guide adds two details worth knowing: a "Reasoning strength" line in the system prompt "takes precedence over reasoning_effort", and the model "pays more attention to the beginning of the system prompt", so put the instructions that matter first - Meta prompting guide.

Through OpenRouter, the effort is set with the standard reasoning object, which accepts the same level names - OpenRouter docs. On a self-hosted server, the level is passed into the chat template; in Hugging Face Transformers it is the reasoning_effort argument of apply_chat_template, and each serving engine documents its own way of forwarding it.

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta/muse-spark-open",
    "reasoning": {"effort": "medium"},
    "messages": [{"role": "user", "content": "List the failing tests in this log and the likely cause of each."}]
  }'

11.2 Tools, parsers and stop tokens

Muse Spark Open writes tool calls in Meta's own ATEM format, an XML-like syntax inside <atem:function_calls> blocks, and the chat template wraps each tool result in <tool_output> tags. Your agent framework never needs to see this if the server translates it: that is the job of the --tool-call-parser muse and --reasoning-parser muse flags in vLLM and SGLang, which turn ATEM markup into the standard OpenAI tool_calls field. Meta's guide also says "You don't need to describe your tools in the system prompt", since the chat template already passes the tool definitions to the model; describing them twice only wastes context.

Two traps catch people who build their own serving layer. The first is stop tokens: Meta's docs warn "never stop on <|eom|>", because the model emits that token at the end of each tool call and then keeps going, while the true end of a reply is <|eot|>. A server configured to stop at <|eom|> silently cuts off every multi-step answer. The second is tool search. Meta's documentation describes deferred tool loading, where the model sees only tool names until it needs one, but that feature runs on Meta's hosted Responses and Messages APIs, "not available on Chat Completions", and it is not part of the open-weight release - Meta docs. An agent with hundreds of tools on self-hosted Muse has to filter the tool list itself, for example by retrieving the most relevant tools per step.

11.3 Keeping the cache warm

Section 7 showed that input, not output, is about 95% of the cost of a typical agent turn, and section 8 showed that reading a long prompt is the slowest step on a Mac. Both problems have the same fix: make the beginning of every request identical, so the server's prefix cache can skip re-reading it. In LMSYS's coding-agent benchmark, that reuse reached a 92% cache hit rate, and its second test hit 96.9% to 98.0% - LMSYS.

In practice this means keeping the system prompt, the tool definitions and any reference documents at the start of the context and never editing them mid-session, appending new turns only at the end, and avoiding timestamps or random IDs in the system prompt, which change the prefix and break the cache. Meta also advises setting the server's maximum context length "to what your workload needs rather than the full window", which frees memory for more concurrent conversations. A million-token window is a ceiling, not a target.

11.4 Which harness to run it in

The model is only half of an agent; the other half is the harness, the program that runs the loop, executes tools and manages context. Meta demonstrated Muse Spark Open inside Muse Code, its own terminal coding agent, which we priced in our Muse Code guide. Apple's post ships a configuration for the open-source OpenCode agent pointed at a local Mac server, and OpenRouter's usage data shows developers already running the model through the open-source pi agent and Claude Code - OpenRouter. Because all of these speak the OpenAI-compatible API, switching between hosted and self-hosted Muse is a change of one URL.

Harness choice matters more than it looks. Meta's own methodology ran each model in a different harness on the coding benchmarks, so the gap between Kimi K3 and Muse on DeepSWE partly reflects Kimi Code against Muse Code. If your agent underperforms, test a second harness before blaming the model. And if you would rather not operate inference or harnesses at all, managed platforms take the whole layer off your hands, from hosted coding agents to company-level platforms such as O-mega, which run a business's AI agents for it; the trade-off is that you give up control over weights, hardware and data location, which is the main reason to choose an open model in the first place. Our guide to open-source personal AI covers the self-built end of that spectrum.

12. Safety: what Meta tested and what you still have to build

A downloadable model changes the safety picture in one fundamental way: whoever holds the weights controls the model. Meta's own framework post states the problem plainly: "Someone holding the weights can resample to get around a refusal, prefill outputs, or fine-tune refusal behavior away" - Meta AI Research. A hosted model can be patched, monitored and filtered on the server. An open model cannot, which is why Meta gave this release "additional safety post-training" and why the license makes each licensee "solely responsible for the safety, deployment, and use of its Derivatives".

Meta says it evaluated the model under its Meta Superintelligence Scaling Framework, "covering the most severe risks", and that "it met the thresholds our framework requires for release", with "a full evaluation report available soon" - Meta AI Research. Until that report appears, the evidence is the summary in the model card, which is detailed enough to read but not yet detailed enough to reproduce.

12.1 The numbers Meta published

The model card reports results in four areas: content safety, agentic risk, privacy, and what Meta calls preparedness (chemical, biological, cyber and loss-of-control risks). In cybersecurity, Meta says the model "refused 99.2% of jailbreaks on our internal benchmark and 94.8% when aggregating across PolyGuard (cyber subset), RedCode, and CyberBench 2024", against 75.5% and 70.2% for Kimi K3 in the same setup - Hugging Face. For chemical and biological risk, it reports refusal rates above 98% on SecureBio's BioTIER and above 97% in multi-turn agentic tests. On loss of control, it reports a 98.1% honesty rate on the MASK benchmark and a 0% misbehavior rate on the Agentic Misalignment benchmark.

The comparative rows are the most informative, because they measure every model the same way. On StrongREJECT v2, Meta's internal set of 202 disallowed behaviors attacked under five conditions, the score is an attack success rate, so lower is safer: Muse Spark Open scores 0.5 against 62.9 to 86.4 for the rival open models. Because Meta built and ran that test itself, the more neutral evidence is FORTRESS, a set of more than 1,010 expert-written adversarial prompts from Scale AI, with results taken from Scale's own leaderboard - Meta evaluation methodology. It reports two numbers per model: an average risk score, the share of harm criteria a response meets on adversarial prompts, and an over-refusal score, the percentage of harmless prompts the model refuses. Lower is better on both, and the chart shows why both matter.

The chart shows the trade Meta made. Muse Spark Open has by far the lowest risk score, about a quarter of the next model's, and the highest over-refusal score, more than six times Kimi K3's. In plain terms, it is the hardest open model to talk into doing something harmful and the most likely to refuse something harmless. For a consumer chatbot that is a sensible default. For an internal agent doing security research, medical documentation or legal analysis, over-refusal is a real cost, and it is the kind of behavior teams often fine-tune away, which brings back the problem in the framework quote above.

12.2 What Meta does not ship, and what you have to build

Meta's release contains no separate guard model, the kind of classifier that screens inputs and outputs before they reach the user; it relies on the safety training inside the model plus advice. The model card states: "We strongly recommend deploying Muse Spark Open as part of an AI system with guardrails tailored to your intended use cases", including "human-in-the-loop confirmation for irreversible actions", and it advises builders to "avoid exposing raw chain-of-thought" to end users. It also warns that "Downstream modifications could degrade safety", which covers every fine-tune.

For an agent builder, that advice turns into four practical layers. Sandbox the tools: an agent that runs code or shell commands should do so in an isolated environment, and Perplexity open-sourced its own agent sandbox, SPACE, under Apache 2.0 the same day Muse Spark Open launched - Perplexity. Gate irreversible actions such as payments, deletions and outbound email behind human approval, as Meta recommends. Filter inputs and outputs with your own classifier or policy layer, since none ships with the model. And log everything, because a self-hosted model has no provider watching for abuse; our guide to AI agent observability tools compares the options.

The license adds one more duty that is easy to miss. The usage policy says the model "is not intended for individuals under the age of 18", so a consumer product built on it needs an age policy, and products in regulated advice (financial, legal, medical) need to stay on the right side of the policy's ban on unlicensed practice. Treat the safety numbers as evidence that the base model is a careful starting point, not as a certificate for whatever you build on it.

13. Where Muse Spark Open falls short

Every launch has a list of weaknesses, and this one is clearer than most because the evidence arrived within four days. Taken together, the independent results, the license text and the launch-week tooling point to five concrete shortfalls. None of them is fatal for every buyer, but each one rules the model out for a specific group of users, and it is better to know which group you are in before you buy hardware.

The first two shortfalls are about the model itself, the next two about the ecosystem around it, and the last about behavior that only shows up in daily use. They are ordered roughly by how many buyers each one affects.

13.1 Long coding sessions

The clearest weakness is sustained software work. Meta's own table puts Muse Spark Open 8 points behind Kimi K3 on DeepSWE and 8.6 points behind on Terminal-Bench 2.1, and the independent Terminal-Bench 4.0 results are far worse: about 8% on Artificial Analysis and 6.57% on Vals AI, against 33.3% for Meta's own hosted Muse Spark 1.3. If your main use case is an autonomous coding agent working through long tasks in a terminal, the open Chinese models and Meta's own hosted model are both stronger today.

13.2 Price without competition

Open weights usually mean many hosts competing on price. Four days after launch, Muse Spark Open has five hosts on OpenRouter (Modal, Together, Nebius, Fireworks and Baseten), and every one charges exactly $1.25 per million input tokens and $4.25 per million output tokens - OpenRouter, the same rate Meta charges for its hosted Muse Spark 1.3. GLM 5.3, by comparison, is served by dozens of endpoints with input prices from a few cents to $2.80 per million tokens. The likely mechanism is the license: any host earning more than $20 million a year from model hosting must sign a separate agreement with Meta first, so the launch partners are hosts that already have one. Kimi K3, under an identical clause, shows where this probably leads: most large hosts charge Moonshot's own $3 and $15, while a handful of smaller hosts undercut it - OpenRouter. Whether the same happens for Muse is the most important open question for anyone budgeting API use.

13.3 License conditions

For most companies the license costs only a label and a policy review, as section 6 showed. For three groups it is a real barrier: companies in the sectors the usage policy bans (defense, critical infrastructure, transportation), large model-hosting businesses that would need Meta's agreement, and anyone using Muse outputs to train their own model, which turns that model into a "Derivative" that owes the attribution label. Teams in those positions should pick a model under Apache 2.0, MIT or OpenMDW.

13.4 Hardware and launch-week tooling

The desktop story depends on a 512GB Mac Studio that Apple says is "coming in late October", and the GPU story depends on Blackwell hardware for the NVFP4 format. The software is equally fresh. vLLM support ships as a Docker image while its code waits for review, llama.cpp support needed an unmerged pull request at launch, the mlx-lm support landed in a second pull request after the first was closed, and the engines do not even agree on names: vLLM and SGLang call the parser muse, TensorRT-LLM calls it musespark, and Hugging Face's blog used a plugin with musespark1x parsers. Hugging Face's launch post also contained a broken link to the GGUF files and code snippets that do not run as printed. None of this is unusual for a launch week, but it means the first person on your team to deploy it should budget a few days, not an afternoon.

13.5 Behavior in daily use

Three behaviors show up only after the model is running. Reasoning cannot be turned off, so even trivial requests pay for some thinking time; low effort reduces it but never removes it. Over-refusal is the highest of the open field on FORTRESS, which matters for security, medical and legal work. And the template's knowledge cutoff of January 4, 2026 means the model knows nothing about the nine months before its release, including most of the models it is compared with, so any agent that needs current facts must give it search or documents. Add the lack of a full safety report and the model's absence from Arena's main text leaderboard so far, and the picture is of a capable model whose real-world behavior is still being mapped.

14. The outlook for open weights

Muse Spark Open arrived in one of the busiest weeks for open weights this year, and its place in that crowd says more about where the market is going than any single benchmark. Three forces are visible, and reasoning from them gives a better forecast than reading launch announcements one at a time.

The first force is a split in licensing. One camp releases under permissive licenses: NVIDIA's Nemotron family under OpenMDW-1.1, Reflection AI's Beam 1.0 under Apache 2.0, DeepSeek and Xiaomi's MiMo under MIT, and Thinking Machines' Inkling under Apache 2.0. The other camp uses custom licenses with a revenue line: Kimi K3 and Muse at $20 million for model hosting, Qwen at $50 million, and GLM's security review at $10 billion. The pattern behind the split is about what each license protects. A lab whose main income comes from somewhere else, such as chips (NVIDIA) or phones and cars (Xiaomi), or that needs adoption before anything else (Reflection AI, Thinking Machines), wants maximum use and gives the weights away. A lab whose income depends on selling access to its own models (Moonshot, Alibaba's cloud) draws a line above which large competitors must negotiate, so they cannot resell the model more cheaply than its maker. DeepSeek is the instructive exception: it sells its own API too, but competes by being the cheapest host of its own model rather than by restricting others. Meta's licenses follow the same logic. Glimmer is too small to compete with anything Meta sells, so it got Apache 2.0. Muse Spark Open overlaps directly with the hosted Muse Spark 1.3, at the identical per-token price, so it got a license that keeps Meta in control of who resells it.

The second force is hardware. Memory capacity, not compute, is the binding constraint for large MoE models, and the machines with the most memory per dollar are no longer only datacenter GPUs. Unified-memory desktops like the 512GB Mac Studio, and clusters of them linked by RDMA, now run models that needed a GPU server a year ago. Expect more labs to publish an official "runs on two desktops" path, because it reaches developers no cloud pricing can, and expect model sizes for open releases to cluster around what a terabyte of fast memory can hold.

The third force is Meta's own strategy, which is now legible: release the small model permissively, release the mid-tier model under conditions, keep the frontier model closed, and keep the open model a step behind the hosted one. Nothing Meta has said since October 15 suggests weights for Muse Wonder. Plan on the assumption that the next Meta open release will again trail its best hosted model, and that its license will again protect Meta's API business.

It is worth testing that forecast against the strongest counter-argument. Meta has reversed course before: it moved from releasing its Llama flagships as open weights to a closed first Muse model in April, then back to open weights with Glimmer in August and this release in October, so its strategy has followed competitive pressure more than principle. If Chinese open models keep pulling ahead and American buyers keep asking for a domestic alternative, the pressure on Meta to open a stronger model rises, because being the default American open model is a position worth defending. The structural reading above predicts the default; the competitive reading explains when Meta might break from it. A buyer should plan for the default and treat anything better as upside.

14.1 What is coming next

The releases due in the next weeks will test these forces. Mistral Large 4, "a 1 trillion-parameter natively multimodal model with 52 billion active parameters", is in public preview at $1.36 per million input tokens and $4.18 per million output tokens, and Mistral says "We will release the weights by the end of the month" - Mistral AI. Its license has not been announced, and which camp it joins will matter to European buyers. NVIDIA's Nemotron 3.5 Super VL, a 120-billion-parameter multimodal model, and Nemotron 3.5 Bolt 74B-A9B, sized for a 24GB card, launched on October 15 with a smaller 4GB Bolt model "coming Oct. 23" - NVIDIA. Beam 1.0, Reflection AI's 501-billion-parameter model with 23 billion active, released its weights under Apache 2.0 on October 16 - Reflection AI.

Read together, these releases sharpen Muse Spark Open's position rather than threaten it. Among American open models its lead is wide: Artificial Analysis rated NVIDIA's new Nemotron 3.5 Super VL at 26 on its index, calling it "the next highest-scoring US open-weights model" after Muse's 39 - Artificial Analysis on X. Among open models from anywhere, it is mid-pack and likely to slip further as Chinese labs ship updates every few weeks, as DeepSeek did two days after Meta's launch. The one release that could change the American picture is Beam 1.0, whose independent scores are not yet in; the one that could change the European picture is Mistral Large 4, depending on the license it ships with.

14.2 What to watch

Five developments will decide whether Muse Spark Open becomes a standard choice or a footnote. None of them requires predicting what Meta will do next; each is a fact that will either appear or not in the coming weeks, and each changes a specific part of the buying decision described in this guide.

The value of watching specific facts rather than headlines is that launch-week coverage moves on quickly while the model's practical position keeps changing. A price cut from a new host or a final engine release will not make the news, but it changes the economics more than the next benchmark will, and it is easy to miss without a list. These are the five to check before committing:

• Meta's full safety report, promised as "available soon"
• New hosts below the $1.25 and $4.25 reference price
• Final engine releases in vLLM, llama.cpp and mlx-lm
• Apple's 512GB price, which sets the cost of the two-Mac path
• Independent coding results at medium effort, not only xhigh

The second and fourth items matter most for cost: they decide whether the API route gets cheaper and what the self-hosted route really costs, and together they will settle whether the two-Mac setup is a practical purchase or a demonstration. The third decides how much engineering time a deployment takes. The last item matters most for quality, because nearly every published number used the most expensive reasoning setting, and the behavior that production systems will actually see at medium effort is still largely unmeasured. Our monthly LLM ranking for AI agents will track how the open field moves.

15. The bottom line: who should use it, and for what

Muse Spark Open is a good model with a narrow best-fit zone. It is not the smartest open model, not the cheapest, and not the most freely licensed. What it is, uniquely, is an American-made model that reads text, images, video and audio, uses tools with unusual care, refuses harmful requests more reliably than any rival in Meta's own safety tests, and comes with an official, measured path to running entirely on hardware you own. For some buyers that combination is worth more than five points on an index; for most, it is not.

The table below turns the analysis into defaults by situation. Treat each row as a starting point for your own test, run on a sample of your real tasks at the reasoning setting you would use in production.

Three conclusions follow from the table. First, if privacy, offline operation or American origin is a hard requirement, Muse Spark Open is the strongest choice available and the two-Mac setup is a real, documented option rather than a demo; budget for the hardware, set the reasoning effort deliberately, and build the guardrails Meta leaves to you. Second, if cost is the requirement, the API price of $1.25 and $4.25 per million tokens is high for an open model, and MiMo-V2.6-Pro, DeepSeek V4.1 Flash 1017 and OpenAI's GPT-6.1 Sol all buy more capability per dollar; our cheapest LLM API price table has the full comparison. Third, if coding is the job, test Kimi K3 or GLM 5.3 first, and treat Muse as the tool-use and multimodal specialist it is.

The broader lesson of the launch is that "open" now comes in grades. Weights you can download, a license you can live with, hardware you can afford, and tooling that works on day one are four separate questions, and Muse Spark Open answers yes to the first, a qualified yes to the second, an expensive yes to the third, and "give it a week" to the fourth. That is a respectable result for Meta's first large open release since it moved its frontier work behind an API, and a clear signal that the company intends to compete in open weights again, on its own terms.

This guide reflects Muse Spark Open, its license and the open-weight market as of October 19, 2026, four days after launch. Benchmarks, host prices, hardware availability and inference-engine support are changing quickly, so verify current details before you buy hardware or sign a contract. Nothing here is legal advice; read the Muse Model License and consult counsel before shipping a product built on it.