Muse Spark Open: Can You Run It, and Is Hosting Cheaper?

Quick answer (October 17, 2026): Meta released Muse Spark Open on October 15. It is an 816-billion-parameter open-weight mixture-of-experts model with roughly 42 billion active parameters per token and a 1-million-token context window. You can run it yourself, but the NVFP4 checkpoint occupies about 530 GB, so “42B active” does not mean it fits into the memory of a typical 42B model. As an immediately available alternative, Fireworks AI lists hosted inference at $1.25 per million input tokens, $0.15 per million cached-input tokens and $4.25 per million output tokens. Meta's release/deployment guide confirms both the model scale and supported runtimes.

The pricing decision is more interesting than the model's benchmark score: should you pay per token, reserve a dedicated inference endpoint, or buy/rent the machines to run it yourself? At low utilization the hosted API often wins, even though the weights are downloadable. At very high and predictable volume, the economics can reverse-but only if the hardware can actually sustain the required throughput and service level.

Will Muse Spark Open fit on your hardware?

Meta gives concrete deployment examples: a four-GPU Blackwell node using TensorRT-LLM, NVFP4 on eight H200s in another configuration, or two M5 Ultra Mac Studios with 512 GB unified memory each connected with Thunderbolt 5/RDMA. Meta also describes four 256 GB Mac Studios as a supported arrangement. These are vendor-tested paths, not a guarantee that every system with the same total memory runs at a commercially useful speed. Meta's deployment recipes.

For hobby experimentation, Meta cites Unsloth's aggressively quantized variant at about 300 GB of combined RAM/VRAM, with system-memory offload. It may be technically runnable on a workstation without being a sensible production endpoint. Quantization, available memory, context length and target latency all matter.

What do hosted providers actually charge? (October 2026)

Meta lists hosted inference partners including Baseten, Fireworks, Groq, Modal, Nebius, OpenRouter and Together AI. Availability and provider-specific capabilities vary. On October 17, OpenRouter's Muse Spark Open listing displayed $1.25 per million input tokens and $4.25 per million output tokens, with several listed providers offering $0.15 per million cache-read tokens. Fireworks publishes the same three price categories for its serverless offering. Those are dated public list prices, not a promise that every provider and endpoint will retain the same rates.

This example assumes 60 million uncached input tokens and 20 million output tokens in one month. If 30 million of the input tokens are actually billed as cache reads, the price would fall to $127: (30 × $1.25) + (30 × $0.15) + (20 × $4.25).

The cached rate applies only where the selected provider returns billable cache hits. Model context capacity is not a cache-hit rate. Don't model every repeated system prompt as cached without seeing usage evidence.

When does self-hosting beat the API? Calculate the crossover

Your answer depends on three numbers: monthly input/output tokens, the quote for your entire GPU configuration, and achievable throughput. A $/token comparison alone cannot tell you whether serving a 530 GB checkpoint is economical.

Here is the useful formula:

Hosted API cost = (uncached input tokens / 1M × input price) + (cached tokens / 1M × cache price) + (output tokens / 1M × output price).

Self-hosted cost = GPU or hardware rental hours × hourly cost + operations + networking + storage + engineering + idle-capacity overhead.

Do not compare $/token to the rental rate of one GPU if the model needs four or more. Compare to the whole deployable serving configuration, including redundant capacity if your service requires high availability.

For a neutral, illustrative example, assume:

• A leased GPU-serving configuration costs $40/hour total, not per GPU. This is a modeling assumption, not a verified market rental quote for Muse Spark Open.
• It stays allocated 24 hours a day for 30 days, or 720 hours.
• You exclude operations, storage, network, reliability reserves and capital costs, making this a favorable lower-bound comparison for self-hosting.
• Your traffic mix is 75% uncached input and 25% output, with no cache discounts on the hosted route. At the cited API prices, that mix costs 0.75 × $1.25 + 0.25 × $4.25 = $2.00 per million combined tokens.

The hardware lease is 720 × $40 = $28,800/month. At $2 per million combined tokens, API spending only reaches that amount after 14.4 billion tokens/month. That is 480 million tokens/day, or roughly 5,556 input-plus-output tokens every second on average, continuously for 30 days.

This is not a prediction that the hardware can serve 5,556 tokens/second. It is the critical sanity check: if a candidate self-hosted configuration cannot deliver the throughput at your required latency, it cannot reach this illustrative API-price crossover, even at 100% utilization. Your actual token mix, cache rates and rented-hardware quote will move the line.

A dedicated provider deployment is a third option: you reserve inference capacity without managing all of the drivers, kernels and serving infrastructure. Request a quote and test throughput; don't infer dedicated endpoint pricing from the public serverless token rate.

For a reusable tool, the UsageBox cost-per-task calculator handles measured task token counts, cache tokens and repeated calls. The more general self-hosting-versus-API analysis explains the utilization issue across models; the figures here are specific to Muse Spark Open's unusually large footprint.

Before you rent GPUs: what throughput must they sustain?

A startup rarely serves a perfect 75/25 token mix around the clock. A coding agent may send long repository snippets, read cached code context, run many short tool-selection turns, and generate long outputs only occasionally. Two models with identical token prices can have different cost per successful task if one needs more turns, retries or interventions.

Build a workload sample with several hundred representative tasks. For each deployment, capture:

1. Prefill latency for short prompts versus 100K+ token prompts. Big-context performance is easy to hide behind an average token-throughput figure.
2. Generated tokens per second at concurrency levels you actually need. Single-user demos do not validate multi-tenant serving.
3. Total memory footprint, including KV cache, spare capacity and quantization overhead-not merely the checkpoint file size.
4. Tool-calling reliability and completed-task success rate after failures or malformed calls. Cheap failed runs are expensive when a user must repeat the work.
5. Billable usage versus delivered work, including retries, cache reads, image/video input, idle time and standby capacity.
6. Availability and recovery time when a node restarts. Self-hosting may require warm spare capacity that doubles the reservation cost.

Don't publish throughput or latency claims borrowed from a launch demo as measurements of your own stack. Meta supplies sample recipes; production numbers need to be measured with your model, driver, quantization, prompt lengths and hardware.

Can you sell Muse Spark Open as a hosted API? The license catch

Open weights do not mean a restriction-free open-source license. Meta uses the Muse Model License, published with the model weights. Under its Section 3, an entity (together with affiliates) offering Model as a Service through an API or similar interface, with aggregate gross revenue exceeding $20 million in any consecutive 12-month period, must notify Meta and sign a separate agreement before offering Muse Spark Open or derivatives as part of that business. Section 3 explicitly excludes internal use and products where the model is only a component of a service that is not Model as a Service. The license also requires attribution and compliance with its usage policy. Read the actual license.

The threshold is about aggregate gross revenue, not just revenue generated by this specific model. It is also not a blanket ban on using Muse Spark Open in a commercial SaaS application. A paid support-agent product that uses the model internally is a different fact pattern from an inference company reselling generic model access. Review the full license and seek legal advice if you are deploying a model-hosting business; this summary isn't a legal opinion.

Metering the cost fairly when you change providers

Running the model through OpenRouter today, a dedicated inference provider next month, and your own GPUs later creates three different evidence sources:

Build your internal cost model separately from your customer invoice model. A $50/month customer subscription can cover variable inference, a fixed-capacity allocation or a hybrid-if you know which customer and feature is creating the load.

UsageBox can retain the numeric token usage or computed cost that your application sends, organize it by customer subscription and meter, and deduplicate delivery retries. It does not price Muse Spark Open, meter GPU utilization automatically, or issue invoices. Keep provider rates, utilization calculations and customer pricing downstream of the event ledger. That separation makes a move from API to self-hosting tractable without rewriting all customer-facing accounting.

What I'd choose today

For a new product with irregular load, start with a hosted API, tag each call with a task/customer identifier, and check cost per successfully completed task. It gives you a reliable price reference before you commit hardware. If data-location rules require self-hosting, compare a dedicated managed endpoint with building your own cluster. Only commit to owned or continuously leased machines after a benchmark proves your steady-state throughput, memory needs and unit cost.

Muse Spark Open removes the model acquisition barrier. It does not remove the cost of serving 530 GB of quantized weights to real users with acceptable latency.

FAQ

Can Muse Spark Open run on one GPU?

Not in its full Meta NVFP4 configuration on ordinary single-GPU hardware: the checkpoint is around 530 GB. Other very aggressive quantizations and CPU/RAM offloading exist, but they have different performance constraints.

How many GPUs does Muse Spark Open need?

Meta documents deployment on a four-GPU Blackwell node for an NVFP4 serving path, plus other multi-accelerator and multi-Mac options. Hardware requirements depend on the checkpoint, KV-cache budget, serving runtime and concurrency.

Is Muse Spark Open free?

The weights are available to download under the Muse Model License. Inference still costs hardware, electricity or API fees; the license also imposes conditions.

What does 816B total / 42B active mean for cost?

The sparse model activates fewer parameters for each token than its total count, which can reduce computation relative to a dense 816B model. But all experts' weights still have to be stored or accessible. Memory sizing does not fall to 42B just because that is the active compute path.

What does OpenRouter charge for Muse Spark Open?

As checked October 17, its model page lists $1.25/M input and $4.25/M output, with listed provider cache rates around $0.15/M. Rates and routes can change; use the current provider page for purchasing decisions.

---

Sources and verification (October 17, 2026):

• Meta - Build with Muse Spark Open: model specs, memory and serving configurations
• Meta - original October 15 release
• Fireworks AI - Muse Spark Open serverless rates
• OpenRouter - Muse Spark Open prices and provider list
• Muse Model License - full text

API rates are dated; hardware lease amounts in break-even examples are explicit assumptions, not observed market quotes or performance benchmarks.