Muse Spark Open: Meta's 816B Open-Weight Model for Agents

What Is Muse Spark Open?

Muse Spark Open is the open-weights version of Muse Spark, built by Meta for coding and agentic work. The PyTorch team's release post says it shares the same base model as Muse Spark 1.3, with additional safety post-training so it resists misuse when it runs as a standalone model without system guardrails.

Alexandr Wang announced the release on X:

The model card lists the architecture and the recommended inference settings:

The PyTorch post describes what the model was trained to do as an agent:

• Long-horizon tasks - It maps out steps, acts, observes and self-corrects over long horizons instead of making single-shot tool calls.
• Subagents and computer use - Through an agentic harness, it can spawn and coordinate subagents and use computer-use capabilities across desktop, mobile and browser.
• Stated intent - It writes separate commentary that states its intent before it acts, so you can see what it is about to do and why.
• Codebase work - It was trained on multi-file refactors, debugging sessions and long-running tasks, and the 1M context lets it hold a large project with its dependencies.

Muse Spark Open is the full-size open model in Meta's lineup, and Muse Glimmer, released earlier, is the small dense one. Meta's frontier tier is the closed Muse Wonder family, which runs through the Meta Model API and Muse Code instead of downloadable weights.

US open-weight releases are something TestMu AI has taken a public position on, in the open weights letter we signed.

How Does Muse Spark Open Score on Agentic and Coding Benchmarks?

Meta's model card compares Muse Spark Open at xhigh reasoning effort with seven open-weight models of similar size and architecture, including Kimi K3, GLM 5.3, Qwen3.8-2.4T-A95B and Mistral Large 4. The rows below are the ones that bear on an agent, with the highest score any other model in the table posts on each.

Read the rows by what your agent spends its time doing:

• Tool selection - MCP-Atlas and JobBench are the two agentic rows where it leads, so agents whose main job is choosing and sequencing tool calls are its strongest fit. If those tools sit behind MCP servers, MCP testing covers the server side.
• Terminal and repository work - It trails the best open model by 8.6 points on Terminal-Bench 2.1 and by 8 points on both DeepSWE 1.1 and SWE-Atlas-QnA, so run your own repository tasks before moving a coding agent onto it.
• Self-reported harnesses - The DeepSWE 1.1 and SWE-Atlas-QnA rows use each vendor's preferred harness, so they compare a model plus its harness rather than the model by itself.
• Composite rank - On the Artificial Analysis Intelligence Index row it scores 39, behind GLM 5.3, Kimi K3 and Qwen3.8, so Meta's "most capable" claim is a ranking among US open-weight models.
• Jailbreak resistance - It scores 0.5 on StrongREJECT v2 with adaptive attacks, where lower is better and no other model in the table scores below 62.9.

What Hardware Does Muse Spark Open Need?

Meta's developer guide lists each checkpoint, who produced it and the hardware it fits:

Size a GPU deployment from the model card's figures, which ask for at least 700GB of VRAM for NVFP4 and 2TB for BF16, both above the raw checkpoint sizes. The card also warns that quantized inference may show minor quality differences from full precision in edge cases, which is why the test plan below runs both builds.

The developer guide also lists where the model runs on launch day:

• Inference runtimes - SGLang, vLLM, TensorRT-LLM, Hugging Face Transformers, MLX, llama.cpp and Unsloth, verified on NVIDIA, AMD, Intel and Apple silicon.
• Hosted APIs - Baseten, Fireworks AI, Groq (a limited preview on GroqCloud), Modal, Nebius, OpenRouter and Together AI.
• Model catalogs - Amazon SageMaker AI, Google Cloud Model Garden and Microsoft Foundry Models, for teams that need the weights in a private instance.
• Speculative decoding - Two draft models ship with it, DFlash V2 for SGLang and DSpark for vLLM, and Meta reports 3.7x single-request throughput for DFlash V2 on AMD MI355X with accuracy unchanged.
• Post-training - TorchTitan, SGLang Miles, NVIDIA NeMo AutoModel and Hugging Face TRL support fine-tuning at launch, and Fireworks AI and Together AI offer managed training APIs.

What Does the Muse Model License Allow?

The Muse Model License grants the right to use, copy, modify, fine-tune, distill, merge, publish, distribute, sublicense and sell copies of the model and its weights. It is a custom license with conditions attached:

• Usage Policy - Copies and derivatives must include the license and Meta's Usage Policy, and every use must comply with that policy.
• Attribution - Each product or service that uses the model or a derivative must prominently display "Built with Muse Spark Open" in its user interface, documentation, website or settings menu.
• Derivatives - Any model created, fine-tuned, distilled or otherwise improved using Muse Spark Open or its outputs counts as a derivative, so a model trained on its synthetic data carries the same attribution duty.
• Model as a Service - A company that sells API access to models, with group revenue above 20 million US dollars in any 12 consecutive months, must notify Meta and sign a separate agreement before offering Muse Spark Open in that service.
• Exemptions - The revenue clause does not cover internal use, research, other commercial activity, or using the model to power features of your own product.
• Outputs - Meta claims no ownership of what the model generates.

Add the attribution label to your release checklist next to the license file. A fine-tuned support agent that reaches customers needs "Built with Muse Spark Open" in its UI, docs or settings, even when the base model is several training runs back.

What Should You Test Before Shipping an Agent on Muse Spark Open?

Meta's prompting guide documents how Muse Spark Open handles reasoning strength, parallel tool calls and stop tokens, including the settings that can override one another.

Those details and the limitations in the model card show where your deployment can behave differently from the checkpoint Meta evaluated. Each check below traces to a specific line in one of the two documents and sits on top of standard LLM testing of answer quality:

The irreversible-action row is a scope test, and AI agent permission testing covers how to check that an agent stays inside the actions it was granted.

Comparing Your Current Model With Muse Spark Open

Moving an existing agent onto Muse Spark Open keeps its prompts, tools and policies, so the question is which behaviours changed. TestMu AI's Agent Assurance tests how agents actually behave across workflows, tools and actions, and one agent can carry several profiles, such as one for your current model and one for a Muse Spark Open endpoint, with the same scenario suite running against each.

• Scenarios from your code - It reads the agent's code to find its prompts, tools and MCP servers, then generates functional and adversarial scenarios, including prompt injection, jailbreak and data exfiltration, with no hand-written cases.
• Grading against effects - Each acceptance criterion is checked against what the run changed: files under the paths the profile declares, artifacts produced, and tool calls checked against the tools the agent declares.
• Run-over-run comparison - Saved runs show which scenarios are newly failing, fixed or flaky, which is the diff a model swap or a new quantized build needs.
• Unable to Verify - Criteria it could not check are reported apart and kept out of the pass rate, so a passing run reflects observed behaviour.

Agent Assurance is pre-alpha and runs from the terminal as rook, installed with npm install -g @testmuai/rook. Point it at staging, because the agent's writes during a run are real and are not rolled back.

How Do You Run Muse Spark Open Behind a Coding Agent?

Meta's launch post says it tested on-device agentic workflows with Muse Code running on Muse Spark Open, including bug fixes and new features shipped to Ice Cubes, an open-source Mastodon client for iOS. For your own coding agent, the shortest path is an OpenAI-compatible server: SGLang or vLLM started with the muse reasoning and tool-call parsers returns tool calls as standard tool_calls, per the prompting guide.

This is the vLLM command from Meta's developer guide without the DSpark draft model. It serves the NVFP4 checkpoint across four GPUs with the full 1M-token context:

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

Unsloth is the smaller route: Unsloth Desktop runs the GGUF builds on macOS, Windows and Linux and serves them through OpenAI- and Anthropic-compatible endpoints that coding agents can call, according to the developer guide.

A coding agent on any model checks its work with tests, type checks and builds, and none of those render the page it changed. Kane CLI runs a plain-English objective in a real Chrome browser and returns an evidence-backed pass or fail, so the agent can confirm a UI change before it reports the task done.

npm install -g @testmuai/kane-cli
npx @testmuai/kane-cli-skill
kane-cli run "Open http://localhost:3000/settings, change the display name to QA Bot, save, and verify the header shows QA Bot" --agent --headless

The skill installer covers Claude Code, Codex CLI and Gemini CLI, and other agents can take the same instructions appended to an AGENTS.md file. In agent mode, Kane CLI streams NDJSON events and ends with a run_end event carrying the status and summary, which the agent reads to decide whether to fix the change or hand it back.

How to Get Started With Muse Spark Open

Start on a hosted endpoint before buying hardware: run your agent's existing scenarios against Muse Spark Open on one of the launch providers, at the reasoning effort you plan to ship, and compare the results with your current model. If the tool-use lead holds on your tasks and the coding gap does not hurt them, repeat the run on the quantized checkpoint you will self-host. The Agent Assurance quickstart takes you from installing rook to a first graded run.