Test Muse Spark 1.3's long-context coding claim on your repo

You are staring at a model card that promises a huge context window and a better software-engineering score. The card is impressive, but the real question is whether your repository gets better, cheaper, and more reliable when the model sees more code.

Meta's Muse Spark 1.3 is the model in question. It became available on September 2, 2026, with a 1,048,576-token window and Standard-tier input pricing at $1.25 per million tokens. Output pricing is $4.25 per million tokens. The headline is not just size. Muse Spark 1.3's MRCR long-context score at 1 million tokens went from 66% to 98.5%. That number is the one people quote when they ask whether the model should become a default.

Benchmark numbers are the entry fee

On DeepSWE, a software-engineering benchmark, Muse Spark 1.3 posted 75.4%, the best score in the four-model comparison. It placed first on DeepSWE 1.1, ahead of the next two models at 74.0% and 73.0%. The gap is real, but it is thin. For the max setting, Muse Spark 1.3 scored 98.1% on MRCR 512K to 1M, against 73.8% for the comparable max setting of a competing model. Those numbers are useful, but they do not tell you how the model behaves in your codebase.

Long context is also where models get weird. In the NoLiMa long-context evaluation, a test for retrieval across large prompts, 10 models dropped under half of their short-context baselines at 32K tokens, and a top-performing model fell from 99.3% to 69.7%. A model can be excellent on a benchmark and still fail on the kind of noisy, multi-file context you actually send. The probe exists to catch that difference before it becomes your production default.

Your repo is the real benchmark

The model targets agent-style workflows and competitive coding. That matters because your default model edits files, runs tools, and recovers from mistakes. At launch, xhigh was the tier you could actually call; the stronger max reasoning tier remained in a limited partner preview while safety testing continued. If you are testing the model you can actually use, start there.

Its xhigh mode scored 61 on a third-party intelligence index, and the limited-preview max reasoning mode scored 62, tying a competing model. Those scores show where it sits among competitors. They do not settle whether the model will handle your dependency graph.

The probe decides the switch

Cost is the other half of the probe. Muse Spark 1.3 also has a low-cost endpoint: roughly $0.10 per million input tokens, $0.20 per million output tokens, in return for Meta training on the user data. If your code is confidential, that trade-off may end the test before it starts. If it is not, the cheap endpoint can make long-context runs affordable enough to repeat.

A third-party one-shot 3D figurine HTML test used 22,474 tokens and $0.10 on Muse Spark 1.3; Muse Spark 1.2 used 19,324 tokens and $0.08. It is not a coding benchmark, but it shows the kind of token drift you should expect when a model gets more verbose.

Before a default-model change, production teams should retest representative codebases, tool access, latency limits, and recovery behavior. The checklist below is the smallest version of that. Each item is a check you can run against a real task, not a full migration.

• Pick a real multi-file task from your repo, not a synthetic prompt.
• Run the same task at short context and long context with identical tools and timeout.
• Check whether the patch passes your existing tests.
• Note the failure mode: wrong file, invented API, timeout, or refusal.
• Log tokens and cost for each run.
• Compare latency against your current default.
• Switch only if long context improves correctness, cost, or failure behavior on your own task.

Choosing a real task keeps the probe honest. A synthetic prompt can overstate a long-context model's usefulness, while a real task includes the details that matter: stale docs, partial files, and dependencies that do not behave. Keeping the prompt, tools, and timeout identical isolates context length. If you change any of those, you have built a different experiment.

Passing existing tests is the only correctness check that should matter. A model can produce plausible code and still break the build. Noting the failure mode matters because long-context failures are often subtle: the model finds the right file but edits the wrong abstraction. Logging cost and latency turns the result into a number you can defend. The last step is the decision rule. If long context does not win on your own work, keep the default.