Muse Spark Open Developer Guide: API, Pricing, Local Setup

Meta released Muse Spark Open on 15 October 2026, and since then I keep seeing the same questions from people who build with LLMs: what is it, how do I call it, what does it cost, can I plug it into a coding agent, and can I really run it at home? This guide answers those for Muse Spark Open from Meta's own docs, the Hugging Face model card and each provider's pricing page. It covers a working API call, an OpenCode setup, honest hardware numbers for self-hosting, the license terms that matter, and where Muse Spark 1.1, 1.2 and 1.3 fit in.

What Muse Spark Open is

Muse Spark Open is the open-weight release of Meta's Muse Spark model. The key facts from the model card:

• Mixture of experts: 816B total parameters, 42B active per token. There are 256 experts and each token is routed to 8 of them.
• Context: 1M tokens (1,048,576) at inference.
• Modalities: text, image, video and audio in; text out.
• Always reasons: you pick reasoning_effort as low, medium, high or xhigh. The model's default is xhigh, and you can't turn reasoning off.
• Recommended sampling: temperature 1.0, top_p 1.0, top_k disabled.
• Two checkpoints: BF16 (about 1.65 TB of weights) and NVFP4 (about 537 GB), according to Get the model.

Meta's model card also says this version got extra safety post-training so it holds up as a standalone model without system guardrails. Meta still recommends adding your own guardrails, such as human confirmation before irreversible agent actions.

Muse Spark 1.1, 1.2 and 1.3 vs Muse Spark Open

"muse spark 1.3" is one of the most searched related terms, and the naming is confusing, so here is how it fits together.

Muse Spark 1.1, 1.2 and 1.3 are Meta's hosted models. You call them on Meta Model API at https://api.meta.ai/v1 with model IDs muse-spark-1.3, muse-spark-1.2 and muse-spark-1.1. Meta's models page calls 1.3 the latest version, with better coding than 1.2 and an extra max reasoning level. 1.3 and 1.2 also have cheaper "Contributor" variants (muse-spark-1.3-contributor), where Meta may use your prompts and outputs to train future models.

Muse Spark Open is the downloadable version. Meta's docs describe it as "the open-weight release of Muse Spark", and it is not served on Meta Model API. You run it yourself or through a third-party host. Meta doesn't say which hosted version number the open weights match, so I won't guess. Treat it as its own model with its own model card and benchmarks.

Muse Spark API: calling Muse Spark Open

Every launch provider exposes an OpenAI-compatible endpoint, so the OpenAI SDK works with a different base URL and model string. The model IDs below come from Meta's Run inference page and OpenRouter's model list:

Here is a streaming Python call through OpenRouter. I tested the request shape against a local mock server with openai 3.37 (I didn't have a paid key for this run). Change the three environment variables and the same script works against any row in the table, or against your own server.

import os
from openai import OpenAI

# Works with OpenRouter, any OpenAI-compatible host, or a local server.
client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://openrouter.ai/api/v1"),
    api_key=os.environ["LLM_API_KEY"],
)
MODEL = os.environ.get("LLM_MODEL", "meta/muse-spark-open")

stream = client.chat.completions.create(
    model=MODEL,
    messages=[
        {"role": "system", "content": "You are a senior Python reviewer. Be brief."},
        {"role": "user", "content": "Review this function:\n\ndef avg(xs): return sum(xs)/len(xs)"},
    ],
    reasoning_effort="high",   # low | medium | high | xhigh
    max_tokens=16000,          # reasoning tokens count toward this
    temperature=1.0,
    top_p=1.0,
    stream=True,
    # OpenRouter only: prefer these hosts, fall back to others if they are down
    extra_body={"provider": {"order": ["together", "fireworks"], "allow_fallbacks": True}},
)

for chunk in stream:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="", flush=True)
print()

Tool calling uses the normal OpenAI tools format. Fireworks' section of Meta's docs shows reasoning coming back in a separate reasoning_content field, apart from content.

Muse Spark pricing by provider

These are list prices per 1 million tokens, read from each provider's own page on 24 October 2026:

The hosted closed model, Muse Spark 1.3 on Meta Model API, costs the same in Standard mode ($1.25 input, $0.15 cached, $4.25 output). Contributor mode drops that to $0.10, $0.002 and $0.20, in exchange for letting Meta train on your content.

At these rates, a coding-agent turn with 40,000 input tokens (half of them cached) and 6,000 output tokens costs about 20,000 × $1.25 + 20,000 × $0.15 + 6,000 × $4.25, divided by a million, which is roughly $0.054. To turn token prices into cost per finished job, use the method in my LLM API pricing comparison.

Is Muse Spark free?

The weights cost nothing to download, and the license is free of charge. Hosted use isn't free on any provider page I checked. The cheapest Meta-hosted option is Muse Spark 1.3 Contributor mode, which is a different model and comes with a training-data trade-off.

Muse Spark OpenCode setup

OpenCode already has OpenRouter built in. Run /connect, pick OpenRouter, paste your key, then choose the model with /models. To make it the default and pin the upstream hosts, add this to opencode.json (I checked both configs against OpenCode's published JSON schema):

{
  "$schema": "https://opencode.ai/config.json",
  "model": "openrouter/meta/muse-spark-open",
  "provider": {
    "openrouter": {
      "models": {
        "meta/muse-spark-open": {
          "options": {
            "provider": {
              "order": ["together", "fireworks"],
              "allow_fallbacks": true
            }
          }
        }
      }
    }
  }
}

If you run the model yourself (next section), point OpenCode at your local OpenAI-compatible server instead. Set the context limit to what the server was started with, not 1M, or the agent will plan for room it doesn't have:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "local": {
      "name": "Muse Spark Open (local)",
      "npm": "@ai-sdk/openai-compatible",
      "options": { "baseURL": "http://127.0.0.1:8080/v1" },
      "models": {
        "muse-spark-open": {
          "name": "Muse Spark Open",
          "reasoning": true,
          "limit": { "context": 32768, "output": 8192 }
        }
      }
    }
  }
}

Can you run Muse Spark Open yourself?

Yes, if you have a lot of memory. The MoE design means each token only computes through about 42B parameters, but Meta's docs are clear that serving still loads all 816B weights into memory.

The setups that Meta and the runtime maintainers document:

• NVIDIA: the NVFP4 checkpoint on one 4-GPU Blackwell node (4 × B300, TP4/EP4), or BF16 on 8 × B300. Budget roughly 2 TB of VRAM for BF16 (hardware platforms).
• AMD: 8 × MI355X or MI350X with vLLM, using BF16 or AMD's MXFP4 and FP8 builds.
• Apple: two Mac Studios with M5 Ultra and 512 GB of unified memory each, or four with 256 GB each, running the NVFP4 checkpoint in MLX. You need macOS 26.2 or later and a direct Thunderbolt 5 link between every pair of Macs.
• llama.cpp GGUF: the ggml-org repo has Q2_K at 304 GB, Q4_K_S at 470 GB and Q8_0 at 872 GB. Unsloth's dynamic GGUFs need roughly 300 to 315 GB of combined RAM and VRAM at 2-bit, and 470 to 500 GB at 4-bit.

Once you have the hardware, starting a local server is one line, from Meta's Run inference page:

# llama.cpp: downloads and serves the 2-bit GGUF with an OpenAI-compatible API on :8080
llama serve -hf ggml-org/Muse-Spark-Open-816B-A42B-GGUF:Q2_K

# vLLM on a 4-GPU Blackwell node with the NVFP4 checkpoint
vllm serve meta-models/Muse-Spark-Open-816B-A42B-NVFP4 \
  --tensor-parallel-size 4 --enable-expert-parallel \
  --reasoning-parser muse --tool-call-parser muse --enable-auto-tool-choice

My honest take, working from Sri Lanka on freelance budgets: a 4 × B300 node or two 512 GB Mac Studios only makes sense if you have strict data-residency needs or steady, heavy traffic. For prototypes and most client work, the hosted API at $1.25/$4.25 is cheaper and much simpler.

Muse Spark Open license: what you can and can't do

The Muse Model License is permissive in style, with conditions:

• You may use, modify, fine-tune, distill, redistribute and sell, free of charge.
• You must show "Built with Muse Spark Open" in the product UI, docs, website or settings. This applies to derivatives too, including models trained on its outputs.
• If you offer AI models to others as a service (Model as a Service) and you and your affiliates make over US$20 million in gross revenue in any 12 months, you must notify Meta and sign a separate agreement. Internal use and using the model to power your own product's features are excluded.
• The Usage Policy applies, and the model isn't intended for users under 18.

Muse Spark benchmark results

Meta's model card compares Muse Spark Open with other large open-weight models. These scores are Meta's own, measured at xhigh reasoning:

What I take from this: Muse Spark Open is strong at tool use (MCP-Atlas), which matters if you're wiring it to MCP servers. On terminal and long-horizon coding, the biggest open models score higher. Its safety refusal scores are much stronger than the comparison models' in the same table. Treat all of these as vendor numbers and test on your own tasks.

When to pick Muse Spark Open vs a closed API

• Pick it when you need the option to self-host later (compliance, client data that can't leave a region), when you want to fine-tune, or when you want several hosts at the same price so you aren't locked in.
• Pick it for agent workflows heavy on tool calls, where its MCP-Atlas score is a good sign. Pair it with a fixed workflow for anything irreversible, as I described in n8n agents vs workflows.
• Pick a closed frontier model when you need the best coding results today and self-hosting doesn't matter. Meta's own hosted Muse Spark 1.3 costs the same per token.
• Skip self-hosting unless you can keep the hardware busy. Idle B300s and Mac Studios cost money whether or not you send them requests.

Quick checklist before you ship:

• Pin the model string and, on OpenRouter, the provider order.
• Set reasoning_effort explicitly and stream responses.
• Add "Built with Muse Spark Open" to your docs or settings screen.
• Keep a human confirmation step for destructive tool calls.