AI Arena Week 30: DeepSeek V4 Pro Thinks for 76 Seconds — a €0 Local Model Answers in 78 ms

The rig and the tests

Every Saturday at 05:00 CET, our AI Arena rig automatically runs a fresh benchmark suite. The setup: an NVIDIA RTX 5060 Ti 16 GB running Ollama for local models, plus direct API calls to cloud providers. This week we ran 20 fresh benchmark runs across 18 unique model×test combinations, covering four standard tests: PHP Drupal module generation, HTML/JS canvas animation, a Python galaxy simulation, and English article writing.

The local lineup this week: Gemma 4 at 4B and 12B quantized sizes, DeepSeek Coder V2 16B, Qwen 3 32B, and Qwen 3 Coder 30B. On the cloud side, we tested DeepSeek V4 Pro — currently the most cost-efficient reasoning model on the market. All numbers are our own measurements from the rig. If you want to see the full history, head over to our AI Arena dashboard.

Speed rankings per test

English article writing

The cloud reasoning model generates at 614 tok/s — nearly 7× faster than the local 4B model — but only after 76 seconds of thinking. In practice, the local 4B model finished its full article (3,546 tokens) in 120 seconds total, while the cloud model wrapped up in 83 seconds total. The cloud wins on total wall time despite the long TTFT because its generation phase is so fast.

PHP Drupal module

Here the cloud model "only" thinks for 20 seconds — a much more practical wait. Combined with 176 tok/s generation, it completes the coding task in 35 seconds total. The local 4B model takes 242 seconds: fast per-token but it generates more tokens (1,650 vs 2,523 — the reasoning model codes more concisely).

HTML/JS animation

* Measurement artifact: DeepSeek V4 Pro hit the 4,096-token output cap on this test, causing the tok/s counter to spike and TTFT to register as zero. The actual wall time was 67 seconds. Real throughput was likely in the same 60–200 tok/s range as other tests.

Python galaxy simulation

* Same output-cap artifact as the HTML/JS test. Wall time: 81 seconds.

Local vs cloud: where does €0 beat the API?

Here's what jumps out from the numbers when you think like an EU developer picking infrastructure:

TTFT — local models win decisively. Gemma 4 (both sizes) starts generating in 75–240 ms. That's near-instant. Even the older deepseek-coder-v2:16b manages ~1 second. Contrast with DeepSeek V4 Pro: the reasoning phase takes 20 to 76 seconds depending on task complexity. The English article test — where it "thinks" longest — took 76.5 seconds before the first token appeared. If you're building an interactive chat app, that's unusable. If you're running a batch coding pipeline overnight, it's fine.

Generation speed — cloud dominates. Once DeepSeek V4 Pro finishes reasoning, it outputs tokens 2× to 7× faster than local models on our RTX 5060 Ti. For the article task it hits 614 tok/s versus 84 tok/s for gemma4:4b. For coding (PHP test) it's 176 tok/s versus 85 tok/s. The cloud GPUs are simply faster silicon.

VRAM efficiency — Gemma 4 is the star. The 4B quantized model uses just 4,646 MB of VRAM at peak on our 16 GB card, consistently hitting ~84 tok/s across all four tests. The 12B version doubles the memory (7,642 MB) and roughly halves the speed — a textbook compute-bound tradeoff. Qwen 3 at 32B (14,684 MB) drops to 3.56 tok/s — barely functional. You can stack three gemma4:4b instances on one consumer GPU and still have VRAM to spare.

The €0 argument. gemma4:4b runs locally with zero API costs, zero rate limits, zero data leaving your machine. A €500 GPU gets you unlimited inference. Compare that to DeepSeek V4 Pro's $0.87 per million output tokens (€0.78 at current rates). If you generate 10 million output tokens per month — a modest volume for a production chatbot — you're paying €7.80/month. At 100 million tokens, you're at €78. The break-even against a GPU happens within a year for many use cases.

For reference, Gemini 3.6 Flash costs $7.50/1M output tokens (€6.70), Claude Sonnet 5 runs $10/1M output (€8.93), and DeepSeek V4 Flash — the non-reasoning sibling — comes in at just $0.28/1M output (€0.25). DeepSeek remains the pricing outlier: their top reasoning model costs less than Gemini's budget Flash model.

What TTFT means in practice — and why reasoning models are different

Time-to-first-token measures how long you wait before anything appears on screen. For a standard LLM like Gemma, it's the time to process your prompt and start generating — usually under a second on decent hardware. For a reasoning model like DeepSeek V4 Pro, the model runs an internal chain-of-thought before deciding what to output. You don't see those internal tokens; you just wait.

This week's data quantifies that wait: 20 seconds for a coding task, 76 seconds for an open-ended writing task. The spread depends on how "hard" the model judges the prompt to be. A Drupal module has a clear spec — the model reasons faster. An article prompt ("write an English article about AI") is open-ended — the model explores more branches internally.

Is that wait worth it? For the English article test, the reasoning model produced better-structured output in fewer tokens (4,096 vs 3,546 from gemma4:4b), and the total wall time was 83 seconds versus 120 seconds. The cloud model was both faster overall and likely produced higher-quality prose — but you stared at a blank screen for the first 76 seconds. That's a UX problem for interactive use but a non-issue for batch generation.

For comparison, our compare tool lets you stack any two models from the arena side by side — useful if you're trying to decide between instant local answers and the deeper reasoning you get from the cloud.

Bottom line for European builders

If you're running a chatbot or IDE plugin where users expect instant feedback, run a small local model. Gemma 4 at 4B on any modern GPU gives you 84 tok/s with sub-250ms latency for €0/month. Keep a cloud reasoning model as a fallback for hard problems — at DeepSeek's prices, that fallback costs almost nothing.

If you're running batch jobs — code generation, document processing, translation — the cloud reasoning models win on both speed and quality. The TTFT penalty is irrelevant when nobody is waiting at a screen, and the per-token throughput is 2–7× higher than what a consumer GPU can deliver.

And if you're on a tight budget in the EU: a used RTX 3060 12 GB (~€200 on European second-hand markets) plus gemma4:12b at 42 tok/s gives you a perfectly usable local dev assistant. The cloud API cost savings pay for the card in months.