Technical Research Brief • Dataset verified 2026-10-17
Output Speed Is a Product Feature, Not a Benchmark Trophy
Artificial Analysis publishes two different speed numbers: a model-level median and per-provider endpoint measurements. The gap is the product decision. DeepSeek V4.1 Flash (Max) ranges from 66.8 t/s on DigitalOcean to 1,504.3 t/s on LithosAI (ULTRA CHAT) — a 22.5x spread for identical weights — while its first-party endpoint measures 176.0 t/s. Speed without capability is not a product; endpoint choice without measurement is a guess. This brief separates the two numbers and shows where endpoint speed changes the economics of an agent.
Fastest endpoint
1,504 t/s
DeepSeek V4.1 Flash on LithosAI (ULTRA CHAT)
Same weights, 22.5x spread
67 – 1,504 t/s
DeepSeek V4.1 Flash across AA providers
Fastest model median
388 t/s
Nemotron 3.5 Super VL
Capable but slow
38 – 79 t/s
Qwen3.8 Max and DeepSeek V4 Pro at max
Model-level medians
Artificial Analysis model pages, 2026-10-17
Model
AA Intelligence
Output speed
Cost / AA task
Cheapest token price
Nemotron 3.5 Super VL NVIDIA
26
388 t/s
$0.19
$0.10 / $0.40 per M
Claude Haiku 5.5 Anthropic
43
235 t/s
$0.21
$0.10 / $0.50 per M
Beam 1.0 Reflection
30
228 t/s
$0.57
$1.00 / $3.00 per M
Ling 3.1 Flash InclusionAI
41
214 t/s
$1.00
$0.075 / $0.23 per M
DeepSeek V4.1 Flash DeepSeek
39
176 t/s
$0.27
$0.15 / $0.60 per M
Claude Sonnet 5.5 Anthropic
56
141 t/s
$5.46
$2.00 / $10.00 per M
Qwen3.8 Max Alibaba
45
38 t/s
$5.41
$2.00 / $6.00 per M
DeepSeek V4 Pro DeepSeek
36
79 t/s
$0.67
$0.66 / $1.98 per M
AA reports the first-party API where one exists, otherwise the median across providers. These are model-level numbers, not the endpoint you necessarily call.
Same weights, different endpoints
AA API provider benchmarks, 2026-10-17
Model
Endpoint
Output speed
AA cost / task
DeepSeek V4.1 Flash (Max)
LithosAI (ULTRA CHAT)
1,504.3 t/s
$0.38
DeepSeek V4.1 Flash (Max)
Baseten (FAST)
697.0 t/s
$2.10
DeepSeek V4.1 Flash (Max)
DeepSeek
176.0 t/s
$0.27
DeepSeek V4.1 Flash (Max)
DigitalOcean
66.8 t/s
$1.75
Source: Artificial Analysis provider benchmarks for
DeepSeek V4.1 Flash (Max),
checked 2026-10-17. Speeds are measured output tokens per second on AA's 10k-input-token workload. Cost per task is AA's weighted Intelligence Index cost, not your workload cost. Endpoint performance varies with load, quantization and rate limits.
What the endpoint data says
Provider choice can beat model choice. DeepSeek V4.1 Flash's first-party endpoint measures 176.0 t/s; LithosAI (ULTRA CHAT) serves the same weights at 1,504.3 t/s — 8.5x the first-party median — while DigitalOcean measures 66.8 t/s. The model name is not the performance number.
Fastest is not cheapest. Baseten (FAST) serves DeepSeek V4.1 Flash at 697.0 t/s for $2.10 per AA task; DeepSeek's own endpoint measures 176.0 t/s at $0.27. That is roughly 4x the speed for 7.8x the cost per task. Price the successful task, not the token.
Decode speed is not response time. Claude Haiku 5.5 decodes at 235.4 t/s, but AA measures 336.4 seconds to the first answer token in its Max reasoning configuration. Output speed only helps after thinking ends; a fast decoder cannot rescue a slow reasoning phase.
Model-level medians are a starting point. Use provider benchmarks for the endpoint you will actually call, keep a fallback, and measure your own prompts, cache hit rate and rate-limit behaviour.
When speed actually pays
Interactive completion and edit-prediction loops. Once the first token arrives, decode speed controls how fast the answer fills in. Below roughly 100 t/s the stream can feel like the bottleneck; above it, time to first answer token and reasoning time often dominate. Measure both.
Parallel agent fan-out. When a batch waits for all branches, wall-clock time is set by the slowest branch. Faster endpoints let you keep more speculative branches inside a fixed time budget.
CI and pre-merge review. A review agent that returns in 20 seconds gets used; one that takes four minutes gets disabled. Treat 20 seconds as a design target, not a benchmark result.
Not for final reasoning. For ambiguous architecture work, the cost of a wrong answer dwarfs the cost of waiting. Pay for the slow, careful model where the blast radius is high.
The routing pattern that works
Use a fast model for the inner loop — reading files, drafting edits, running tests, summarising failures — and hand the final patch to a stronger model.
In many agent loops most turns are tool calls rather than deep reasoning, so this can cut wall-clock time without reducing final quality.
It also cuts cost: route the bulk of inner-loop tokens to a fast cached model, and let the expensive model see a small, well-prepared context. The exact split depends on your trace, not a fixed 80/20 rule.
Pick the endpoint with measured speed, not just the model name. Keep a fallback endpoint and verify both with your own prompts; AA's provider medians are a starting point, not a guarantee. Faster endpoints can also charge more per task, so compare speed and cost per successful task together.