On OrcaRouter’s seven-day production window, the Muse Spark 1.2 API returns a first token at a p50 of 7.73 seconds and a p95 of 10.00 seconds — while the version it replaced, at the identical price on the same platform, sits at 1.93 seconds p50. Four times the wait, same rate card. We reviewed the older one separately in our Muse Spark 1.1 review.
Those numbers are hard to find anywhere else. Go to Artificial Analysis’ page for this model and look for output speed: N/A. Time to first token: also absent. The most widely-cited independent benchmark site has scored it on intelligence, cost, verbosity and hallucination — and published nothing at all about how long you wait for it.
Four times the wait. Same rate card. That’s the trade nobody put on a slide.
The measurements
Production telemetry, seven-day window:
- Muse Spark 1.2 — p50 time to first token 7.73 s, p95 10.00 s
- Muse Spark 1.1 — p50 1.93 s, p95 8.13 s
For scale, the same window puts several widely-used models well under four seconds at the median — Claude Opus 5 at 4.26 s, Claude Haiku 4.5 at 3.18 s, GPT-5.6 Luna at 3.31 s, and DeepSeek V4 Flash at 444 milliseconds.
Independent corroboration. Vals AI’s evaluation runs averaged roughly 610 seconds per test for Muse Spark 1.2 — a whole-task figure rather than a first-token one, but pointing unmistakably in the same direction.
Why it’s slow. Artificial Analysis measured the model consuming 95 million output tokens to complete its Intelligence Index, against a tier median near 70 million, for $639.27 and $0.40 per task — up from $0.29 per task for version 1.1 at identical pricing. Reasoning is mandatory on this model and cannot be disabled. It is not slow because of infrastructure; it is slow because it is doing what it was designed to do.
Why benchmark-site latency wouldn’t help you anyway
Even where a benchmark site does publish speed figures, they’re worth reading carefully. Those measurements are typically taken at each model’s *maximum* effort setting, on synthetic prompts, from a fixed location, without production concurrency.
Real traffic looks nothing like that. Your prompts are longer and more variable, your effort setting is probably not `xhigh`, and your requests contend with everyone else’s. That’s why the useful latency number is a percentile from real traffic — and why p95 matters more than p50 for anything a person waits on. The median tells you how it usually feels; the 95th percentile tells you how often it feels broken.
Muse Spark 1.2’s p95 of 10.00 seconds is the number to design around, not the 7.73.
What this rules in and out
Ruled out:
- Interactive chat. Seven seconds before the first character appears is not a conversation.
- Autocomplete and inline code suggestion. These need sub-second responses; the model is off by an order of magnitude.
- Synchronous API endpoints where a caller is holding a connection open.
- Anything with a tight SLA on response time.
Ruled in:
- Background agent runs. Meta’s own demonstration had the model working across more than 1,000 tool calls over 24 hours on GPU kernel optimisation. At that scale seven seconds per call is noise.
- Batch document processing. The domains where the model is independently strongest — it ranks #1 of 44 on Finance Agent (v2), #1 of 136 on TaxEval v2 and #1 of 31 on Harvey’s Legal Agent Benchmark on Vals AI’s common harness — are almost all batch-shaped anyway.
- Code review queues and CI integrations, where the work happens between a push and a human looking at the result.
- Overnight and scheduled jobs, where latency is genuinely free.
Measuring it yourself, properly
If you are going to make a deployment decision on latency, spend twenty minutes measuring it on your own traffic rather than trusting anyone’s published figure — including ours.
Three rules make the measurement worth having. Use your real prompts, not a short synthetic one: time to first token scales with how much input the model has to read, and a 200-token test prompt will flatter a model you intend to feed 50,000 tokens. Record percentiles, not averages — a handful of very slow requests barely move a mean but define what your users experience, which is why p95 is the number to design the timeout around. And measure at the effort setting you will actually deploy, because the published figures are all `xhigh` and your production default probably isn’t.
Then run it at your real concurrency. A model measured one request at a time behaves differently from the same model serving forty in parallel, and the gap between those two numbers is where most latency surprises live.
Practical mitigations
- Turn the effort dial down. The reasoning setting runs `minimal` → `low` → `medium` → `high` → `xhigh`, with `medium` as the default. Every published benchmark figure is `xhigh`. Lower settings cut both latency and token spend; measure the quality difference on your own tasks rather than assuming you need the top setting.
- Stream. It won’t reduce time to first token, but it does mean the user sees progress from second seven rather than second forty.
- Cache the stable part of the prompt. At $0.15 per million against $1.25, cached input is an 88% saving, and a smaller uncached prefix is less to process before generation starts.
- Set generous timeouts. A client configured for a three-second model will fail against this one. Check your framework’s defaults; many are well under ten seconds.
- Route by task shape. The cleanest fix is architectural: send latency-sensitive requests to a fast model and long-horizon work to this one. Behind a single OpenAI-compatible key that carries both at 0% markup, with automatic failover, that’s a routing rule rather than a second integration — and it’s how most teams end up using a model like this in practice.
The takeaway
Muse Spark 1.2 takes about seven and a half seconds to say its first word, and roughly ten at the 95th percentile — four times slower than the version it replaced, at the same price. No benchmark site publishes this, which means a lot of teams will find out after they’ve built something. It isn’t a defect; it’s the cost of a model that always reasons, and in the workloads where this model is genuinely excellent — long-horizon agents, document-heavy professional analysis — nobody is watching the clock. Just make sure that’s the workload you’re putting it in, and set your timeouts accordingly.
Sourcing note: p50 and p95 time-to-first-token figures are OrcaRouter’s own seven-day production telemetry across all traffic to each model, not a synthetic benchmark. Per-test latency is from Vals AI; token consumption, cost per task, and the absence of published speed figures are from Artificial Analysis’ live model page. Domain ranks are from Vals AI. Checked August 7, 2026; latency figures move with traffic and provider capacity.
Related: Grok 4.5: Benchmarks, Pricing & Is It Worth It? (2026)
| Disclaimer: This article was submitted by a guest contributor and reflects the author’s own analysis, testing, and opinions. AIInsightsNews has not independently verified every performance figure or benchmark cited. Model performance, latency, pricing, and availability can change over time, so readers should verify current figures with the relevant providers before making deployment or purchasing decisions. |
