DeepSeek V4 vs Qwen 3 235B: The 2026 Open-Source Reasoning Comparison

Open-source reasoning models closed the gap with frontier closed-source models faster than almost anyone predicted. In May 2026, both DeepSeek V4 and Qwen 3 235B score within 4 percentage points of Claude Opus 4.7 and GPT-5.4 on the benchmarks that matter most for engineering work. They are not yet on parity — but they are close enough, and cheap enough, that the decision is no longer 'open vs closed' but 'which open' and 'what serving stack.'

This guide compares the two leading open-source reasoning models head-to-head: benchmarks, license terms, serverless API pricing across the three biggest providers, self-hosting compute math, tool-use capabilities, and the specific workloads each one wins. All numbers below are from the official model cards plus our own evaluation on a 5,000-prompt internal eval set running through Together AI, Fireworks, and DeepInfra in late April 2026.

The Two Models in One Paragraph

DeepSeek V4 (released January 2026, 671 billion total parameters, 37 billion active per token via Mixture-of-Experts) is the third major iteration in DeepSeek's V3 line. It maintains the V3 family's coding focus but adds a stronger general-purpose reasoning core and native function-calling. Qwen 3 235B (released March 2026, 235 billion total / 22 billion active) is Alibaba's flagship in the Qwen 3 series, optimized for multilingual quality and built around a thinking-mode reasoning system that can be toggled per request.

Two architectural notes worth flagging. First, both models are MoE — only a small fraction of weights are active per token, which is what makes serving them at a 20–40B-active footprint feasible. Second, DeepSeek's MLA (Multi-head Latent Attention) reduces KV-cache memory by ~85% vs vanilla attention, which is the single biggest reason DeepSeek V4 can run inference at competitive latency despite its 671B total size.

Benchmarks Head-to-Head

We focused on six benchmarks that map to the workloads teams most often deploy open-source models for: general knowledge (MMLU-Pro), graduate-level science (GPQA Diamond), coding (LiveCodeBench, SWE-bench Verified, HumanEval-X), and tool use (BFCL — Berkeley Function-Calling Leaderboard). Numbers come from the official model cards, replicated against our own eval where possible.

DeepSeek V4 wins six of eight benchmarks; Qwen 3 235B wins two — but the two it wins are meaningful. BFCL (function-calling reliability) and MGSM (multilingual math) are exactly the capabilities you need for agentic and non-English production workloads. The two-percentage-point gap on MMLU-Pro is statistical noise; the four-point gap on LiveCodeBench is real and reflects DeepSeek's continued specialization in code.

How close are these to Claude Opus 4.7 and GPT-5.4?

Both open-source models are within 2–6 percentage points of the closed-source flagships on every benchmark. On LiveCodeBench, DeepSeek V4 (73.4%) actually exceeds both Claude Opus 4.7 (71.8%) and GPT-5.4 (69.4%) — the only contamination-free coding benchmark where open-source leads. On SWE-bench Verified, Claude Opus 4.7 still leads by 6.7 points, but DeepSeek V4 (67.8%) is within striking distance of GPT-5.4 (68.2%). For teams whose primary cost driver is the API bill, the quality-cost ratio of these open-source models is now compelling enough that they belong in production, not just in R&D.

Thinking mode and reasoning effort

Both models support a 'thinking mode' that adds 1–10 seconds of pre-response chain-of-thought, lifting scores on hard reasoning benchmarks. Qwen 3's thinking mode is opt-in per request via a flag; DeepSeek V4's reasoning style is more integrated into the base prompt. With thinking enabled:

Thinking mode adds 6–9 percentage points to HLE and 6 points to AIME for both models. For high-stakes reasoning tasks, the latency cost (3–8 seconds per request) is usually worth it. For chat workloads where the response should arrive in 2 seconds, leave it off.

Serverless API Pricing — Together, Fireworks, DeepInfra

The three biggest serverless hosts for open-source models — Together AI, Fireworks AI, DeepInfra — all serve both DeepSeek V4 and Qwen 3 235B. Pricing changes monthly. Below is the May 2026 snapshot.

DeepInfra is consistently cheapest, Fireworks is fastest. Together sits in the middle on both axes. For most production workloads, the right choice is provider-level rather than model-level: pick Fireworks if latency matters, DeepInfra if cost matters, Together if you want a single-vendor relationship that covers both models plus image generation and embeddings.

How much does this save vs closed-source?

Below is the same workload comparison we used in the Claude/GPT comparison, with DeepSeek V4 (Fireworks) and Qwen 3 235B (Fireworks) added.

DeepSeek V4 is 62× cheaper than Claude Opus 4.7 on the chat turn and 30× cheaper on long-doc QA. Qwen 3 235B is 89× cheaper than Claude on chat and 48× on long-doc. Even versus GPT-5.4 — the cost-competitive closed-source flagship — DeepSeek V4 is 27× cheaper on chat and Qwen 3 235B is 38× cheaper. The 5-point quality gap on most benchmarks is exchanged for a 30–90× cost reduction; for many production workloads that trade is a no-brainer.

Self-Hosting Compute Requirements

Once your monthly token volume crosses ~2–3 billion tokens, self-hosting starts to compete with serverless. Below is the practical hardware footprint for production-grade serving of each model with reasonable batch sizes.

Qwen 3 235B fits on 4 H100s at FP8 precision; DeepSeek V4 needs 8 H100s. At INT4 quantization (3–5% quality loss on most benchmarks), the footprint halves — Qwen 3 235B on 2 H100s, DeepSeek V4 on 4. INT4 is production-viable for both models per our internal eval, with the caveat that coding accuracy drops 1.5 points on DeepSeek V4 and 0.8 points on Qwen 3.

Throughput at scale

What hourly compute cost actually buys you, in tokens per second, with vLLM 0.7 or SGLang 0.4 as the serving stack:

Self-hosted, Qwen 3 235B at FP8 lands at roughly $1.39 per million output tokens — a hair more expensive than Fireworks list ($0.79) but completely under your control. The DeepSeek V4 self-hosted cost ($2.08) is more expensive than Fireworks list ($1.10) until you factor in the per-request margin Fireworks needs. The break-even where self-hosting beats serverless is typically around 50–80% sustained utilization.

Operational overhead — the silent cost of self-hosting

The list-price math always looks favorable for self-hosting, but the operational cost is non-trivial. Realistically you need: a dedicated ML platform engineer (≈$220k loaded cost), 24/7 on-call rotation (2-3 people minimum), monitoring (Grafana + Prometheus + Loki), automated failover, model-update pipeline, and a strategy for handling provider GPU shortages. We model this as ~$400k/year of fully-loaded overhead before any GPU bill. Self-hosting pays back only at scale (>10B tokens/month sustained) or when data residency / IP concerns force the issue.

Tool Use and Function Calling

Function-calling reliability is the make-or-break capability for agentic deployments. We tested both models on BFCL (Berkeley Function-Calling Leaderboard) and on a private 1,000-prompt suite of OpenAI-style tool definitions.

Qwen 3 235B wins every function-calling metric. The gap is small (1–4 points) but it appears consistently across tests. For agent-heavy products where the model issues 10+ tool calls per session, Qwen 3's higher reliability compounds into noticeably fewer failed agent runs. Qwen 3 also supports strict-schema mode (similar to OpenAI's `response_format: 'json_schema'`); DeepSeek V4 supports JSON mode but not strict schema enforcement as of this writing.

License Comparison — The Fine Print

Both models are 'open weights' in the practical sense — you can download them, fine-tune them, and serve them — but the licenses have meaningful differences.

For most commercial products, both licenses are workable. The two practical considerations: (1) if your product serves >100M monthly active users, you must request a commercial license from Alibaba — most enterprises will already have a relationship; (2) the 'national interests' clause in the Qwen license is vague and has not been tested in court, which has made some enterprise legal teams uneasy. DeepSeek's license is cleaner from a Western enterprise compliance standpoint.

Export control and geopolitical risk

Both DeepSeek and Alibaba are China-based companies, and there is ongoing regulatory uncertainty in the EU and US about training LLMs from Chinese-affiliated entities for certain government or critical-infrastructure use cases. For the majority of commercial applications this is not a blocker, but if you are building for US federal contracts or EU critical-infrastructure customers, run the question past your compliance team before committing.

Use-Case Recommendation Matrix

Migration and Integration

Both models are exposed through OpenAI-compatible APIs on every major serverless provider, so dropping them into existing OpenAI-SDK code is a one-line change. Below shows the standard pattern — note that DeepSeek's own API also speaks the OpenAI dialect, so you can hit it directly if you want to skip the serverless layer.

import OpenAI from "openai";

// Via Fireworks AI
const fw = new OpenAI({
  apiKey: process.env.FIREWORKS_API_KEY,
  baseURL: "https://api.fireworks.ai/inference/v1",
});

await fw.chat.completions.create({
  model: "accounts/fireworks/models/deepseek-v4",
  messages: [{ role: "user", content: "Refactor this Python function..." }],
});

await fw.chat.completions.create({
  model: "accounts/fireworks/models/qwen3-235b-a22b-instruct",
  messages: [{ role: "user", content: "Refactor this Python function..." }],
});

// Via DeepSeek directly
const ds = new OpenAI({
  apiKey: process.env.DEEPSEEK_API_KEY,
  baseURL: "https://api.deepseek.com",
});

await ds.chat.completions.create({
  model: "deepseek-v4",
  messages: [{ role: "user", content: "Refactor this Python function..." }],
});

// Or via Railwail (one key, both models, all providers)
const rw = new OpenAI({
  apiKey: process.env.RAILWAIL_API_KEY,
  baseURL: "https://railwail.com/v1",
});

await rw.chat.completions.create({
  model: "deepseek-v4", // or "qwen-3-235b"
  messages: [{ role: "user", content: "Refactor this Python function..." }],
});

Where the OpenAI compatibility breaks

Three differences will trip you up in production. First, both models ignore the `temperature` parameter above 1.5 — both clamp it. Second, DeepSeek V4's `tool_choice: 'required'` returns a tool call but does not enforce the strict-schema mode that OpenAI does — your JSON-validation code still needs to run. Third, Qwen 3's `thinking` mode is exposed via a non-standard `chat_template_kwargs` parameter that not all serverless providers expose; if you need it, pick a provider that supports it (Fireworks does).

Practical Production Notes

Fine-tuning

Both models support LoRA and QLoRA fine-tuning. DeepSeek V4 ships a base (non-instruct) checkpoint specifically so you can do your own instruction tuning; Qwen 3 235B ships both base and instruct. For a 10-million-token domain fine-tune, a single 4×H100 box trains for ~6 hours on Qwen 3 235B and ~12 hours on DeepSeek V4. Hugging Face's TRL and Axolotl both support both models out of the box.

Distillation into smaller models

Both providers ship distilled smaller models that inherit much of the quality: DeepSeek V4-Lite (16B active), Qwen 3 30B-A3B, Qwen 3 7B. For a production stack, distilled models give you 80% of the quality at 10–20× the cost reduction. The standard pattern is to use the flagship for hard cases and the distilled model for everything else.

Prompt-cache discounts on serverless

Fireworks and Together both support 70% cache-hit discounts on stable prefixes. DeepInfra is rolling this out in Q3 2026. For agentic workloads with stable system prompts, this brings effective input pricing into the $0.10/1M-token range — DeepSeek V4 effectively costs less than the cheapest closed-source small models.

What Will Change by End of 2026

• **DeepSeek R2 (reasoning-first)** — DeepSeek's roadmap signals a reasoning-first variant in Q3 2026 that should close the gap with closed-source on HLE and AIME.
• **Qwen 4** — Alibaba's pace suggests a Qwen 4 family in late 2026; rumors point to a stronger MoE design with ~30B active parameters and Apache 2.0 licensing.
• **Serverless pricing wars** — DeepInfra is signaling another 20% cut by Q3. Fireworks is expected to match. Self-hosting break-even will move further to the right.
• **Native multimodal in OSS** — Both models are currently text-only at the flagship size. Vision-capable open-source flagships are widely expected in H2 2026, which would shift this comparison meaningfully.

Bottom Line

DeepSeek V4 is the stronger open-source model for code-heavy English production. Qwen 3 235B is the stronger open-source model for multilingual products, agentic workloads, and cost-sensitive self-hosting. The gap between either and the closed-source flagships is now small enough that the right architectural pattern for most production workloads in 2026 is to route most traffic to an open model and reserve a closed-source flagship for the hardest cases. The price gap is too large to ignore — 30–90× — and the quality gap is small enough that for the right workload you will not notice it.

Try Both Open-Source Models Now

Railwail exposes DeepSeek V4 and Qwen 3 235B alongside Claude Opus 4.7, GPT-5.4, and 100+ other models behind a single OpenAI-compatible endpoint. Pay per token at provider list prices — no markup. Built-in routing lets you fall back to closed-source for hard cases or default everything to open-source for cost optimization. Start with free credits and run your own quality eval.