Qwen 3.8 Max vs DeepSeek V4 Flash 2026: 3 Points, 345x Bill

The short version, in fields you can copy:

AA Intelligence Index v4.1:  Qwen 3.8 Max 53 · DeepSeek V4 Flash 0731 50
Arena text Elo:              1496 ±10 vs 1436 ±4 (+60 Qwen)
Parameters:                  2.4T / 95B active vs 284B / 13B active (8.5x)
ofox price per 1M:           $2.00 / $6.00 vs $0.14 / $0.28 (14.3x, 21.4x)
Measured on 3 tasks:         $0.052328 vs $0.000151 (345x), 181s vs 30s (6x)
Only one that sees:          Qwen 3.8 Max (vision + video + web search)
Bigger max output:           DeepSeek V4 Flash, 384K vs 131K
ofox model IDs:              bailian/qwen3.8-max · deepseek/deepseek-v4-flash
Snapshot:                    2026-08-04

r/DeepSeek spent yesterday arguing about a chart showing these two models three points apart on the Artificial Analysis Intelligence Index, with one of them carrying 8.5x the parameters. The thread title called it “similar performance.” The top comments disagreed, and they were right to: three index points is not noise. What nobody in that thread priced is the other side of the trade. We ran both models on the same three tasks through one gateway, and the three points cost 345 times more.

TL;DR: Which One Should You Pick?

Quick Specs Comparison

Prices are ofox catalog rates read on 2026-08-04. Parameter counts come from each vendor’s own release material.

Two lines carry most of the decision. Qwen is the only one that can look at a picture, and DeepSeek writes 2.9x more tokens in a single response. Everything else is a question of what three index points are worth to you.

Which Model Scores Higher on Third-Party Benchmarks?

Qwen 3.8 Max, on every source that has both. The margins are consistent and small.

Read the sourcing before you use these numbers.

• The AA 53 is the weakest-sourced figure here, and we are flagging it rather than hiding it. Artificial Analysis has no model page for Qwen 3.8 Max: the score exists only inside the Intelligence Index chart widget, so the usual per-model figures (cost to run the index, verbosity, output speed) are not published for it. For context on the same index, Kimi K3 scores 57, GLM-5.2 51, Gemini 3.6 Flash 50, DeepSeek V4 Pro 44, and Qwen 3.7 Max 46.
• The Arena numbers we read directly off the boards. Elo there is rolling and updates daily, so treat the ordering as the durable part and the exact numbers as a snapshot. A 60-point gap with ±10 and ±4 intervals is a real lead, unlike the 8-point gap we found between Qwen 3.6 Plus and V4 Flash on the same board.
• LiveBench has not scored Qwen 3.8 Max at all. It does score DeepSeek V4 Flash 0731 at 74.2, up from 65.5 for the April release, which is the single clearest measure of what the July retrain bought.

The efficiency argument that started the Reddit thread is legitimate arithmetic: 284B total parameters reaching within three points of a 2.4T model, with 13B active per token against 95B. Whether that matters to you depends on whether you are buying weights or buying tokens. If you are buying tokens, the parameter count is the vendor’s problem and the price is yours.

How Do They Compare on Three Real Tasks?

Both models were correct on the work; the invoices were not close. We sent three prompts through api.ofox.ai/v1/chat/completions on 2026-08-04 with default parameters and no system prompt, and took the token counts from the API usage object.

Three observations worth more than the totals.

• Neither model got the reasoning wrong. Identical JSON on the receipt, both with correct line arithmetic. Both returned a working even-length median, which we executed against four cases before calling it correct. The three index points did not show up as a right-or-wrong difference on work this size, which is what you would expect: benchmark gaps live in the hard tail, not in routine tasks.
• The strict-format task went to Qwen, decisively. Asked for 40 rows covering status codes 400 through 439, Qwen produced exactly 40, filling unassigned codes with placeholders. DeepSeek produced 29, silently skipping every unassigned code and then wandering outside the range to include 451. If a parser downstream expects a fixed shape, that is a correctness failure and not a style preference.
• Latency compounds with verbosity, and the 6x is not a throughput claim. Our number is end-to-end wall clock across three calls, and it is driven by token count rather than speed: Qwen emitted 19.7x more output. The per-second figures are a different measurement, and only one side of this matchup has one. Artificial Analysis lists DeepSeek V4 Flash 0731 at 122.7 output tokens per second (rank 8 of 101 in that view, read 2026-08-04) and publishes no throughput figure for Qwen 3.8 Max, since it has no model page. So treat 6x as “this workload finished six times sooner,” not as “this model is six times faster per token.” For a batch job that is a cost line. For anything interactive it is a product decision.

Three prompts is a sample, not a study. The direction held on all three, and the cheapest way to check whether it holds on your work is the loop at the end of this article.

Which One Is Better for Coding?

Qwen 3.8 Max on the board that measures it, DeepSeek V4 Flash on the bill. The Arena WebDev leaderboard, where humans compare generated front-end code side by side, puts qwen3.8-max at 1668 (+18/-18) against deepseek-v4-flash-high at 1577. That 91-point gap is wider than the 60 points separating them on the general text board, so whatever Qwen’s extra parameters are buying, front-end generation is part of it.

Context for that 1668: on the same board kimi-k3-max sits at 1676 and claude-opus-5-high at 1669, all three inside overlapping intervals. Qwen 3.8 Max is genuinely in the top group for this task, which is not something a $2 input price usually buys.

Our own coding task did not reproduce the gap, and that is informative rather than contradictory. Both models fixed the even-length median bug correctly on the first attempt, and the fix is six lines. Routine repairs do not separate a 53 from a 50. What separates them is the long tail: an unfamiliar framework, an ambiguous spec, a refactor that has to hold across files. If your coding work is mostly the routine kind, you are paying 21x for a difference that will not show up. If it is mostly the hard kind, the WebDev board says the money is doing something.

What Did the 0731 Retrain Actually Change?

It moved DeepSeek V4 Flash from clearly behind to three points back. The model ID did not change, the architecture did not change, and the price did not change. The weights did.

LiveBench scores the two releases separately, which makes the delta legible:

An 8.7-point jump on the same evaluation, and it carried the cheap tier past DeepSeek’s own flagship. On the Artificial Analysis index the same inversion shows up: V4 Flash 0731 at 50 against V4 Pro at 44.

Two practical consequences:

• The ofox entry already resolves to 0731. The catalog page for deepseek/deepseek-v4-flash lists a 2026-07-31 release date, so you get the retrained weights without pinning a date suffix. Anything you read about V4 Flash written before August is describing a materially weaker model.
• Comparisons written in June are stale, not wrong. A June piece that put Qwen ahead by a wide margin was accurate then. The gap that survives today is three index points, and that is the number this article is about.

Do Both Models Work on the Anthropic Protocol?

Yes, both answer on POST https://api.ofox.ai/anthropic/v1/messages. We sent each one the same one-word instruction on 2026-08-04:

curl https://api.ofox.ai/anthropic/v1/messages \
  -H "x-api-key: $OFOX_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"bailian/qwen3.8-max","max_tokens":64,
       "messages":[{"role":"user","content":"Reply with exactly: ok"}]}'

Both replied ok. The usage objects did not match: Qwen 3.8 Max reported 98 input and 27 output tokens, DeepSeek V4 Flash reported 15 input and 2 output. Same two-letter answer, 13x the output tokens and 6.5x the input tokens, before the 21.4x rate difference is applied.

This matters if your team runs Anthropic-shaped tooling and wants to point it at a cheaper model. The request shape is unchanged, cache_creation_input_tokens and cache_read_input_tokens come back in the response, and only the model string moves.

How Much Does Each One Cost Per Month?

Between 15x and 82x, depending on whether you price the rate card or the tokens you actually get back. Both scenarios below use ofox list rates at 30 days per month. These are arithmetic on published prices, not invoices.

Workload A, priced on the rate card. 5M input and 0.5M output tokens per day, no caching.

Workload B, the same job priced with the token ratio we measured. Qwen returns 19.7x the output, so its 0.5M becomes 9.85M per day while DeepSeek stays at 0.5M.

The rate card understates the gap by a factor of five once you count what each model actually returns.

One caveat on that cache line, because ofox lists three providers for DeepSeek V4 Flash and they do not price caching the same way:

The 89x cache advantage over Qwen’s $0.25 holds on the DeepSeek row, which is also the one Artificial Analysis reflects at $0.003 per million on its cache-hit ranking. Land on the BaiLian row and the same comparison is 8.9x, still a large gap but an order of magnitude smaller. Check which provider your traffic resolves to before you build a budget on the bottom number.

What Can Qwen 3.8 Max Do That DeepSeek V4 Flash Can’t?

See. The ofox catalog lists Vision, Video Input and Web Search on bailian/qwen3.8-max, and Function Calling plus Prompt Caching on deepseek/deepseek-v4-flash. That is the capability line, and no amount of price advantage crosses it.

Work that hits the wall:

• Screenshot triage, UI review, or any agent that inspects its own rendered output
• Scanned documents, receipts, forms, anything that arrives as a photo
• Video keyframe tagging, which needs the video input path specifically
• Charts and diagrams where the numbers exist only in the picture
• Slide decks, dashboards, and document layout work, which is where Alibaba pointed its launch demos

One commenter in that Reddit thread made the sharpest version of this point: a model with image input can write a UI, screenshot it, and inspect its own work. The text-only model cannot enter that loop at any price.

The reverse gap is narrower but real. DeepSeek’s 384K max output against Qwen’s 131K is 2.9x, and it decides whether a long translation, a full test suite, or a large structured extraction comes back in one response or forces you to write chunking logic.

What Did r/DeepSeek Actually Argue About This?

The thread rejected its own headline, and the rejection was the useful part. The post framed 53 against 50 as “similar performance” with 8.5x the parameters. The two highest-voted replies were “that’s not similar performance” and “3 points is a big difference,” and both are right on the numbers.

Three arguments from that thread are worth carrying into a decision, because they cover ground no leaderboard does.

• The office-document gap. One commenter pointed out that the April DeepSeek V4 Flash scored poorly on the AA briefcase evaluation, which measures work on spreadsheets, documents, slides and PDFs, and that the July retrain has not been scored on it. Alibaba’s launch demos for 3.8 Max leaned heavily on slides, dashboards and analytical layout. If your workload is office-shaped, a general index score is the wrong instrument and neither model has a published number that settles it.
• The self-inspection loop. A model with image input can generate a UI, screenshot it, and check its own output. DeepSeek V4 Flash cannot enter that loop at all, which is a structural difference rather than a quality difference.
• The efficiency framing cuts both ways. 284B total parameters landing three points behind a 2.4T model is a genuine engineering result. It is also irrelevant to your invoice unless you are self-hosting: through an API you buy tokens, not parameters, and DeepSeek’s pricing is what converts its efficiency into your savings.

What nobody in the thread priced was the thing we measured: the same three tasks, 345x apart on cost and 6x apart on wall clock. Parameter efficiency was the debate; token efficiency was the number that changes budgets.

How Would You Route Between Them?

Cheap by default, escalate on a rule you can state in one line. Both models sit behind the same endpoint, so the routing decision lives in your own code rather than in a second integration.

A ladder that matches what we measured:

• Default to deepseek/deepseek-v4-flash. Text in, text out, high volume, 21.4x cheaper on output.
• Escalate to bailian/qwen3.8-max when the request carries an image or a video frame. This is not a quality call, it is a capability check, and it can be a one-line branch on the content type.
• Escalate when the output must match a fixed shape. Validate DeepSeek’s response against your schema, and retry on Qwen when validation fails. Given the 345x cost ratio on our tasks, you can afford to validate-and-retry rather than route everything to the expensive model.
• Escalate on repeated failure, not on anticipated difficulty. Two DeepSeek attempts plus one Qwen attempt still costs a fraction of routing everything to Qwen, and it gives you data on how often the three points actually matter for your prompts.

That last rule is the one worth taking seriously. The index gap is a population statistic. Your traffic is not the population, and the only way to find out where the three points bite is to let the cheap model try first and keep score.

When Should You Pick Qwen 3.8 Max?

When the job is visual, or when the last three points decide whether the output is usable. Those are the two cases that survive a 21x output price.

• Any pipeline where an image or video frame can show up in the request.
• Fixed-schema generation. In our run it produced all 40 requested rows while DeepSeek produced 29 and drifted outside the range.
• Hard reasoning at low volume, where the bill is small enough that a 15x multiple on $25 is not a real number to anyone.
• Work where web search matters and you would otherwise wire a retrieval layer yourself.

Where it bites: 19.7x the output tokens, 6x the wall clock on our tasks, a 131K output ceiling, and no model page on Artificial Analysis, so you cannot look up its cost-per-index-point the way you can for its rivals. The launch details, including open-weights status and the full spec sheet, are in the Qwen 3.8 Max release breakdown.

When Should You Pick DeepSeek V4 Flash?

When the work is text in, text out, and the volume is real. Three index points behind, 21.4x cheaper on output, six times quicker end to end on our three tasks (mostly because it writes far less, not because it streams faster), and the cheapest cache-hit rate Artificial Analysis currently ranks. Artificial Analysis clocks it at 122.7 output tokens per second on its own harness.

• Batch classification, extraction, summarization, tagging.
• Coding agents with a stable system prompt and repository prefix, where the $0.0028 cached read rate does the work.
• Long single responses, thanks to the 384K ceiling.
• Anything where you would rather spend the difference on more attempts than on a better model. At these rates you can run a task ten times and still pay less than one Qwen call.

Where it bites: no image input, and a looser grip on strict output specs. Validate the shape of the response rather than trusting it. The tier comparison against DeepSeek’s own flagship is in DeepSeek V4 Pro vs Flash, and the free-access paths with their real caps are in DeepSeek V4 Flash free.

When Should You Not Use Either Model?

When you need the top of the index, or when you are optimizing cost per point rather than cost per token.

• Frontier reasoning. Kimi K3 scores 57 on the same index against Qwen’s 53, and the cost of that gap is worked out in Qwen 3.7 Max vs Kimi K3 vs DeepSeek V4, which prices what Artificial Analysis spent running its own evaluation on each model.
• Open weights with a permissive license. DeepSeek V4 Flash is MIT-listed on the Arena board; Qwen 3.8 Max is proprietary on the API, with open weights announced but not shipped as of 2026-08-04.
• A cheaper model at the same score. Gemini 3.6 Flash also scores 50 on this index, and the token-count trap in that matchup is covered in DeepSeek V4 Flash vs Gemini 3.6 Flash.
• A budget Qwen instead of the flagship. Qwen3.6 Flash costs $0.25/$1.50 on ofox and still carries vision, which puts the same capability line at one quarter of Qwen 3.8 Max’s output rate.

Try Both via ofox: Swap One String

Both models sit behind one ofox key on an OpenAI-compatible endpoint. Live rates are on the model pages: bailian/qwen3.8-max and deepseek/deepseek-v4-flash.

Python: same prompt, both models, printed usage

import os, time
from openai import OpenAI

client = OpenAI(base_url="https://api.ofox.ai/v1", api_key=os.environ["OFOX_API_KEY"])

MODELS = ["bailian/qwen3.8-max", "deepseek/deepseek-v4-flash"]
PRICES = {"bailian/qwen3.8-max": (2.00, 6.00), "deepseek/deepseek-v4-flash": (0.14, 0.28)}
PROMPT = "Rewrite this changelog as 5 release-note bullets:\n\n" + open("CHANGELOG.md").read()

for model in MODELS:
    t0 = time.time()
    r = client.chat.completions.create(model=model, messages=[{"role": "user", "content": PROMPT}])
    pin, pout = PRICES[model]
    cost = r.usage.prompt_tokens / 1e6 * pin + r.usage.completion_tokens / 1e6 * pout
    print(f"{model:<28} out={r.usage.completion_tokens:<6} {time.time()-t0:5.1f}s  ${cost:.6f}")

Print the cost, not just the answer. The rate card is a per-token number and your invoice is a per-task number, and on our three tasks those two differed by a factor of five.

Node: the same shape

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.ofox.ai/v1",
  apiKey: process.env.OFOX_API_KEY,
});

for (const model of ["bailian/qwen3.8-max", "deepseek/deepseek-v4-flash"]) {
  const r = await client.chat.completions.create({
    model,
    messages: [{ role: "user", content: "Summarize this incident report in 5 bullets:\n" + report }],
  });
  console.log(model, r.usage.completion_tokens, r.choices[0].message.content.slice(0, 200));
}

Qwen only: send it a screenshot

Swap the model string to deepseek/deepseek-v4-flash and this request fails on the content type, which is the fastest way to see the capability line for yourself.

import base64, os
from openai import OpenAI

client = OpenAI(base_url="https://api.ofox.ai/v1", api_key=os.environ["OFOX_API_KEY"])
img = base64.b64encode(open("dashboard.png", "rb").read()).decode()

r = client.chat.completions.create(
    model="bailian/qwen3.8-max",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Which number on this dashboard contradicts the chart above it?"},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img}"}},
        ],
    }],
)
print(r.choices[0].message.content)

FAQ

Is three index points a real difference? Yes, but it lives in the hard tail. On our three routine tasks both models were correct, and the gap did not surface as right-or-wrong. Expect it to matter on the problems you would not hand to a cheap model in the first place.

Why is DeepSeek so much cheaper if the scores are close? Size. 284B total and 13B active per token against 2.4T and 95B. Serving 13B active parameters costs a fraction of serving 95B, and DeepSeek passes that through instead of pricing to the score.

Does Qwen 3.8 Max have open weights? Not as of 2026-08-04. Alibaba announced open weights for the Max tier at launch without a license or a date. DeepSeek V4 Flash is already listed as MIT on the Arena leaderboard.

Which should I default to in an agent loop? DeepSeek V4 Flash, unless the loop can receive an image. The cached read rate ($0.0028 against $0.25) matters more than any other number once your prefix stabilizes, and you can afford to retry failures rather than prevent them.

Sources Checked for This Refresh

• Our own A/B run, 2026-08-04: three prompts (receipt extraction, median() bug fix, 40-row CSV), one call per model per task through https://api.ofox.ai/v1/chat/completions, default parameters, no system prompt. Token counts from the API usage object; both median functions executed against four cases before being called correct.
• ofox model catalog pages, read 2026-08-04: https://ofox.ai/models/bailian/qwen3.8-max · https://ofox.ai/models/deepseek/deepseek-v4-flash
• Arena text leaderboard and Arena WebDev leaderboard, read 2026-08-04
• LiveBench, release LiveBench-2026-06-25, read 2026-08-04: DeepSeek V4 Flash 0731 74.2, no Qwen 3.8 entry
• Artificial Analysis Intelligence Index v4.1 chart, read 2026-08-04. Qwen 3.8 Max has no Artificial Analysis model page; its 53 appears only in the index chart. Cross-checked against the model pages that do exist: https://artificialanalysis.ai/models/deepseek-v4-flash
• Qwen 3.8 Max launch post for parameter counts and open-weights status