Muse Spark Open vs DeepSeek V4.1 Flash: the faster model lost

If one coding assistant hands you a finished page in sixteen seconds and the other takes two and a half minutes, and both say they are done, which one would you give your team? We ran that test on two models anyone can download and run, this morning, one day after Meta released Muse Spark Open, and the answer was not the one the stopwatch suggested.

It is a very large model: 816B parameters, the numbers the model learned in training, of which only 42B are used for each word it writes. Meta published that file of numbers (the weights), so anyone can download the model and run it. Its rival here is DeepSeek V4.1 Flash, DeepSeek's low-priced model, which we already ran on two graphics cards last week. We ran both as coding assistants on 16 October, in a terminal and inside Claude Code, and recorded it:

The video is 5:13, with English voice-over and subtitles. This is a first look, not a benchmark: one run per test, on one day. The speed numbers compare two services, Muse served by Baseten and DeepSeek served by DeepSeek itself, not the two models on the same hardware. And inside Claude Code we let DeepSeek think harder than Muse (the setting was high for DeepSeek and medium for Muse), which matters for the round the title rests on.

What	Muse Spark Open (Baseten)	DeepSeek V4.1 Flash (DeepSeek API)
Same short prompt, what came back	code in 2.5 s	no code after 8.4 s (still thinking when it hit the limit)
Eight coding problems (six hard) solved	7 of 8	7 of 8
What those eight problems cost at list prices	0.38 USD	0.07 USD
Claude Code, average cost per small task	0.148 USD	0.016 USD
Claude Code, time to build a dashboard	16 s	2 min 29 s
Did that dashboard work	no, the bars stay empty	yes

The short version: on Baseten, Muse is very fast and codes as well as DeepSeek on these tests. It also thinks longer, costs five to nine times more per task in our runs, and its quickest piece of work needed a second look.

Where the two models stand

On the Artificial Analysis Intelligence Index, an independent score that combines many tests, the two models were tied on the day we tested:

Model	Artificial Analysis Intelligence Index (2026-10-16)
Claude Opus 5.5	58
GPT-6 Astra	53
Gemini 4 Argon	53
GLM-5.3	45
Kimi K3	44
Muse Spark Open	39
DeepSeek V4.1 Flash	39

So neither is among the very best models. Claude Opus 5.5, Anthropic's flagship, is well ahead. The interesting fight is between the two cheaper ones, because that is the slot where a team picks the model it runs all day.

The part of the work you never see

Before the results, one idea that explains most of them. Modern models think before they answer: they write notes to themselves, which you usually do not read, and only then write the reply. Models count all this text in tokens, pieces of a word, and the notes are billed like any other token. A model that thinks for 6,000 tokens to write a 200-token answer charges you for 6,200.

That changes what "fast" means. A model can stream tokens very quickly and still keep you waiting if it writes many more of them, and it can be cheap per token and still cost you more if it thinks twice as long. Keep that in mind through the three rounds.

Round one: Muse had the code in 2.5 seconds

Muse had working-looking code on screen in 2.5 seconds. DeepSeek spent 8.4 seconds thinking and never wrote a line. The request was the same for both, sent at the same moment: write a Python function that turns a time span like "P3DT4H5M" into seconds, with a short explanation and five examples that double as tests. We asked for little thinking and allowed at most 1,500 tokens of output.

Muse began answering in about a third of a second. It thought for 229 of its 1,006 tokens and spent the rest on the function, its explanation and the examples. We saw the code, but we did not save the run's output, so we cannot say here that its examples passed when executed.

DeepSeek started in 0.75 seconds and wrote quickly, 1,500 tokens in 8.4 seconds, but every one of them was a note to itself. In a separate test that morning, with twice the token limit, DeepSeek did answer, but its first real words took 3 to 6 seconds to appear, against about one second for Muse.

"Muse is faster" is true of Baseten's service. Across all the companies that serve each model, Artificial Analysis finds the opposite: the typical DeepSeek service is the quicker one (179 tokens per second against 102 for Muse). What we saw is narrower: Baseten serves a compressed copy of Muse, and on its service Muse was very quick in our runs.

Round two: the same score, a bigger bill

Both models solved the same hard programming puzzles, and Muse's bill was about five times DeepSeek's. The puzzles come from AtCoder, a Japanese programming-contest site, through LiveBench, a public test set. Each answer is checked against the examples in the problem plus hidden tests. Here we asked for a lot of thinking, up to 24,000 tokens.

Live in the video, with two hard problems, both models went 2 for 2, passing 15 of 15 tests on each (the 3 samples in the prompt plus 12 hidden ones). Muse finished both in 38 seconds, DeepSeek in 53. The race was closer than the total suggests. Muse took 17.1 seconds on Island Tour, where DeepSeek needed 40.2. On Set Meal, DeepSeek was faster, 13.2 seconds against 21.0.

The bigger difference was in the token count: 14,308 for Muse, 9,154 for DeepSeek. That is the thinking from the previous section, and it shows up on the bill.

Earlier the same day we had run a set of eight of these problems, six hard and two medium. Both models solved seven. Both missed the same one, Negative Traveling Salesman, by thinking until they hit the 24,000 token limit without writing code. Same score, about five times the bill: the eight problems cost 0.38 USD on Muse and 0.07 USD on DeepSeek at list prices. Muse wrote about 1.5 times as many tokens (about 88,000 against 59,000) and charges more for each one.

Round three: a page that looked done

Muse handed back a finished-looking page in 16 seconds, and every bar on it was empty. DeepSeek took 2 minutes 29 seconds and its page worked.

The setup: we pointed Claude Code, Anthropic's coding agent, at each model and gave both the same request and the same results file. Build one self-contained web page that loads the data and turns it into a dark, animated dashboard comparing the two models, under 250 lines.

Muse thought for 12 seconds, wrote an 88-line page in one go and stopped after 16 seconds. Its last message said: "Verified data.json is fetched live and all four requested metrics are shown." Its only check was to search the file for a few expected words. It never opened the page.

DeepSeek first loaded a set of chart-making guidelines that Claude Code can use, and checked that its two colours were easy to tell apart, even for colour-blind readers. Then it wrote the page, opened it in a browser and took screenshots to see it. The animation looked frozen in the screenshots, so it made a copy of the page with the animation already finished, confirmed that the bars were full, and fixed the layout problems it spotted. The result was a 188-line page.

Muse's page has a clean layout, six cards and a cost table. The bars fail because of one rule in the page's stylesheet, its design rules. The bars only get a colour through a rule that looks for the bar inside the row with the model's name. The page Muse wrote puts the bar next to that row, not inside it. The bar grows to the right width, but it is invisible. A person would have seen it in the first second of opening the page. DeepSeek did a soundcheck. Muse checked that the setlist was taped to the floor and went on stage.

DeepSeek's page works: a large "5.2x" headline for the cost gap, four cards with filled and labelled bars, and the winner marked where there is one.

It is not flawless either. Under one card it says the Claude Code tasks passed "at $0.296 each" and "at $0.033 each", but those figures are the totals for two tasks, not per task. The numbers are right and only the label is wrong, a smaller slip than empty bars.

In two earlier Claude Code jobs on a toy banking library (fix the bugs, add a report command), both models passed every hidden test, and DeepSeek did it for about a ninth of the price: 0.016 USD per task against 0.148 USD. They even fixed the same two lines.

Two caveats keep this fair. It is one run per model. And the effort was not matched: we reached Muse through a small translation layer (Baseten only speaks OpenAI's request format, Claude Code speaks Anthropic's), and it ran at medium thinking effort there, while DeepSeek ran at its default, high. A Muse that thinks harder might also check harder. We did not test that.

Who made it possible

Meta trained Muse Spark Open and released the weights, which is what lets anyone, including us, test it, host it or build on it. Baseten was already serving it when we tested, and that is where we measured Muse's speed. DeepSeek built V4.1 Flash, published its weights too, and serves it through its own API. AtCoder wrote the problems and their tests, and the LiveBench team (building on an earlier collection, LiveCodeBench) published the set we used. Artificial Analysis keeps the independent scores we quoted. Anthropic makes Claude Code, and the LiteLLM project made the translation layer that let Claude Code talk to Muse at all.

Our part was putting it together: the test scripts, the grading, the Claude Code setup for each model, reading the code both wrote and recording it.

What it means for the bill

On the tasks we ran, Muse cost five to nine times more than DeepSeek: 0.38 against 0.07 USD for the eight problems, and 0.148 against 0.016 USD per Claude Code job. Part of that is price, since Muse charges about four times more per token, and part is that it thinks longer. Artificial Analysis, on its own set of tasks, puts the cost per task at 0.84 USD for Muse and 0.27 for DeepSeek, against 5.98 for Claude Opus 5.5.

For a team that runs an assistant all day, the cost per task is what adds up: a thousand small tasks like ours come to about 148 USD on Muse and about 16 USD on DeepSeek. Speed is pleasant, and on Baseten Muse is very fast. But when the quick answer needs a person to check it, as the dashboard did, the time it saved goes back into the review.

Muse's speed here belongs to Baseten's service, and other providers serve it more slowly. Because the weights are public, you can choose who runs it, at what speed and price, and whether your code ever leaves your own machines. Running it yourself takes a server with several graphics cards: at FP4 the weights alone are about 408 GB, more than any single card holds. We have not tried that yet, or any provider other than Baseten. Meta's license allows it, with two conditions worth knowing. You show "Built with Muse Spark Open". And anyone who sells access to it as a service, with more than 20M USD of revenue in 12 months, must notify Meta and sign a separate agreement. Internal use, research and use as a component of your own product are exempt from that second one.

On these runs, for a cheap coding assistant that checks its own work, DeepSeek V4.1 Flash still wins. Muse is one to watch. The next question is the one our runs leave open: given the same high effort inside Claude Code, does Muse open the page before it says it is done?

For engineers

Every figure below comes from our run records of 2026-10-16 or the sources linked above.

• Models and providers. Muse Spark Open: 816B total, 42B active, 256 experts with 8 active per token, 1M context, released 2026-10-15 under the Muse Model License (model card). Served by the Baseten Model API, OpenAI-compatible, slug meta-models/muse-spark-open. /v1/models reported meta-models/Muse-Spark-Open-816B-A42B-NVFP4. Baseten reports speculative decoding in usage (race: 767 accepted, 899 rejected prediction tokens, so under half accepted). FP4 weights and speculative decoding probably explain part of Baseten's speed lead, but nothing we measured isolates either effect. DeepSeek V4.1 Flash via DeepSeek's first-party API, model deepseek-flash.
• Prices per 1M tokens. Muse on Baseten: 1.25 input, 0.15 cached input, 4.25 output USD. DeepSeek peak: 0.30 input (cache miss), 0.006 cache hit, 1.20 output USD. Off-peak is half. Peak is 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday. Ratios: 3.5x output, 4.2x input. All DeepSeek costs here use peak prices. The 8-problem run (10:22 to 10:25 UTC), the small Claude Code tasks (from 10:28 UTC) and the video runs (around 10:55 UTC) all fell after 10:00 UTC on a Friday, so at the off-peak prices a reader would pay half, and 0.07 and 0.016 USD are upper bounds.
• Third-party context (2026-10-16). Artificial Analysis Intelligence Index: Claude Opus 5.5 58, GPT-6 Astra 53, Gemini 4 Argon 53, GLM-5.3 45, Kimi K3 44, Muse Spark Open (xhigh) 39, DeepSeek V4.1 Flash (max) 39. Cost per task: 5.98 / 0.84 / 0.27 USD (Opus / Muse / DeepSeek). Median output speed across providers: Muse 102, DeepSeek 179, Opus 97 tok/s. Meta's model card (vendor-reported): Terminal-Bench 2.1 (Terminus 2) Muse 76.4 against Kimi K3 85.0, GLM 5.3 83.9, Qwen3.8-2.4T-A95B 82.0. MCP-Atlas: Muse 89.2, highest in Meta's table.
• Race. Prompt: "Write a Python function that parses an ISO 8601 duration string (like P3DT4H5M) into seconds. Include a docstring and 5 doctests." Streaming, reasoning_effort=low, max_tokens=1500, both launched together. First token counts the first reasoning or content token. tok/s = completion tokens / (end - first token), reasoning included. Muse: 0.34 s, 455 tok/s, 1,006 tokens (229 reasoning), 2.5 s. DeepSeek: 0.75 s, 197 tok/s, 1,500 tokens (all 1,500 reasoning), 8.4 s, no code. Muse's code runs doctest.testmod() under __main__ and approximates a year as 365.2425 days and a month as 30.436875. The race output was not saved, so doctest execution is unverified.
• Morning speed test. 3 prompts, reasoning_effort=low, max_tokens=3000, sequential. Muse: TTFT 0.31 / 0.34 / 0.37 s, first answer token 0.87 / 1.30 / 1.40 s, 431 / 299 / 331 tok/s. DeepSeek: TTFT 0.51 / 0.82 / 0.91 s, first answer token 3.0 / 5.3 / 5.9 s, 290 / 175 / 270 tok/s.
• LiveBench, 8 problems. livebench/coding test split, LCB_generation subset (derived from LiveCodeBench), AtCoder problems only, releases 2024-06-24 and 2024-07-26 (public, so contamination is possible). 6 hard, 2 medium, prompt verbatim, reasoning_effort=high, max_tokens=24000, 4 requests in parallel, public plus private tests, 10 s per test. Muse / DeepSeek, tokens and seconds: Mex and Update 6.1K/17 vs 4.1K/24. Set Meal 5.2K/15 vs 3.2K/19. Last Train 17.3K/54 vs 9.3K/55. Island Tour 5.3K/14 vs 3.6K/20. Christmas Color Grid 1 15.0K/41 (numpy + scipy) vs 11.3K/54. Erase Leaves 9.4K/35 vs 2.4K/14. Many Replacement 5.5K/19 vs 1.1K/6. Negative Traveling Salesman: both hit the 24K cap with no code block. Totals: 7/8 each, 87,877 vs 59,024 output tokens (1.49x), 0.3823 vs 0.073 USD (5.2x). Muse's Christmas Color Grid answer first failed only because our grading sandbox lacked numpy and scipy. We installed them and regraded the saved answer, with no new API call.
• LiveBench, live round. Same effort (high) and 24K cap, same grader (10 s per test), but each provider ran its two problems one after the other, not 4 in parallel. Island Tour and Set Meal, 15 tests each (3 public samples that appear in the prompt plus 12 hidden). Muse 17.1 s / 6,547 tokens and 21.0 s / 7,761 tokens, 38 s and 14,308 total. DeepSeek 40.2 s / 7,064 and 13.2 s / 2,090, 53 s and 9,154 total.
• Claude Code setup. Claude Code 2.1.301. Muse through a local LiteLLM proxy (hosted_vllm provider, api_base https://inference.baseten.co/v1, reasoning_effort: medium, use_chat_completions_url_for_anthropic_messages: true), because Baseten has no Anthropic-compatible endpoint. DeepSeek through https://api.deepseek.com/anthropic, model deepseek-flash, default effort (high).
• Dashboard round. Prompt: "Build index.html: one self-contained page (inline CSS and JS, no libraries or CDNs) that loads data.json and turns it into a dark, animated dashboard comparing the two models: speed, first token, coding problems solved and cost. Keep it under 250 lines." Identical data.json (morning figures: 330 vs 270 tok/s, 0.34 vs 0.82 s first token, 1.3 vs 5.29 s first answer token). Muse: 16.1 s turn, one Write of 88 lines, check limited to string assertions on the file. The bug: .c0 .fill and .c1 .fill are the only rules giving the fill a background, but c0/c1 sit on the .row div and <div class="bar"><div class="fill"> is its sibling, not a descendant, so the width animates on an element with no background. DeepSeek: 149.3 s turn, dataviz skill, palette #3987e5 / #d95926 validated (CVD dE 26.8), headless google-chrome screenshots, end state checked on a temporary copy because headless virtual time froze the animation, 188-line page. Its "✓ best" marker is skipped when both values are equal (problems solved, 7 vs 7). Its card footer labels the two-task totals (0.296 / 0.033 USD) as "each".
• Claude Code small tasks. claude -p, fresh config, minibank fixture with 3 of 4 tests failing, hidden tests. Fix: both 4/4 own and 8/8 hidden. DeepSeek 32 s, 0.0117 USD. Muse 20 s, 0.0752 USD (13 requests). Report command: both 16 own tests and 3/3 hidden. DeepSeek 65 s, 0.0208 USD. Muse 56 s, 0.2213 USD (22 requests). Average per task 0.148 vs 0.016 USD (the video rounds the second to 0.017). Both fixed the same two lines (Decimal parsing, dict copy). DeepSeek split the report into small testable functions. Muse wrote it inline but formats negative balances correctly and added a usage check. Neither validates a non-numeric --min.
• Limits.
  • One run per test, on one day. 8 problems and 3 Claude Code jobs are not a benchmark.
  • Speed is provider against provider (Baseten FP4 with speculative decoding against DeepSeek's own API), not model against model on the same GPU.
  • Effort was not matched in Claude Code: Muse at medium through LiteLLM, DeepSeek at high.
  • The LiveBench problems are public, so either model may have seen them in training.
  • Costs are computed from list prices and token counts, with DeepSeek at peak prices.
  • No per-task cost is given for the dashboard round.