Qwen3.8-Max vs Kimi K3 vs DeepSeek V4 Flash

Evidence cutoff: August 18, 2026. This comparison updates Kingy’s August 3 controlled test with released checkpoints, current direct-API prices, independent long-context evidence and current licence terms. Prices and availability can change quickly.

The short answer is unusually clean. Qwen3.8-Max is the best hosted multimodal generalist. Kimi K3 is the strongest choice when coding and long-context capability matter more than token price. DeepSeek V4 Flash is the cost and throughput winner, and by a huge margin. For self-hosting, DeepSeek is also the least unrealistic of the three, although “least unrealistic” still means data-centre hardware.

That verdict needs an asterisk. “Qwen3.8-Max” can mean a hosted product or, incorrectly, a downloadable checkpoint that is merely related to it. Kimi’s API and checkpoint share a family name but add different service-layer features. DeepSeek’s live alias points to a dated model version. If those identities are blurred, every downstream comparison—pricing, context, vision, tools and licensing—becomes suspect.

This guide keeps them separate. It also preserves Kingy’s original 45-call test as a dated operational result rather than pretending an August 3 API bill is an August 18 price quote.

The verdict at a glance

Workload	Best first choice	Why
Hosted multimodal API	Qwen3.8-Max	Text, image and video input, configurable thinking, built-in tools and strong vision evidence in one managed product
Coding and long-running agents	Kimi K3	Best completion reliability in Kingy’s test, strongest exact-model independent score here, and the highest vendor coding/agent results—with harness caveats
Lowest API cost	DeepSeek V4 Flash	Roughly one-eighth to one-tenth of Qwen’s scenario cost even during DeepSeek’s peak windows
Long-document analysis	Kimi K3	Highest exact-model result in the independent AA-LCR long-context test
Text-only high-volume inference	DeepSeek V4 Flash	Low prices and 103.2 measured output tokens per second in Artificial Analysis testing
Self-hosting	DeepSeek V4 Flash	MIT licence and a 166.9GB official repository, far smaller than Kimi or Qwen
Most permissive licence	DeepSeek V4 Flash	MIT; Qwen and Kimi use custom open-weight licences

There is no universal winner. Qwen’s hosted product is the broadest. Kimi buys more capability and better reliability at the highest token price. DeepSeek wins the economics but needs stricter completion and quality controls.

Identity matrix: three product names, six artifacts

The most important table in this article is not the benchmark table. It is the identity table.

Family	Hosted product and exact API ID	Downloadable checkpoint	Relationship	Availability	Licence
Qwen	Qwen3.8-Max — `qwen3.8-max`	`Qwen/Qwen3.8-2.4T-A95B`	The hosted product is based on the checkpoint but adds vision input, non-thinking support, default 1M context and official built-in tools	QwenCloud/Alibaba API; checkpoint on Hugging Face	Custom Qwen3.8-Max License for the weights
Kimi	Kimi K3 — `kimi-k3`	`moonshotai/Kimi-K3`	Same model family; the API adds managed caching, uploaded-video handling, structured output and service limits	Moonshot direct API; checkpoint on Hugging Face	Custom Kimi K3 License
DeepSeek	DeepSeek V4 Flash — alias `deepseek-v4-flash`, actual version `DeepSeek-V4-Flash-0731`	`deepseek-ai/DeepSeek-V4-Flash-0731`	Exact dated release name is available as weights; the hosted service still adds its own serving stack and cache behaviour	DeepSeek direct API; checkpoint on Hugging Face	MIT

Qwen’s distinction is explicit in the official checkpoint card: the hosted Qwen3.8-Max is “based on” Qwen3.8-2.4T-A95B and has additional capabilities. It is therefore wrong to copy the QwenCloud hosted-product page’s vision, non-thinking or built-in-tool claims into a local-checkpoint spec sheet without qualification.

Kimi is less confusing but still needs service hygiene. The Kimi K3 model summary lists native text and image modalities, while Moonshot’s API documentation explains how uploaded video is supplied to the hosted model. A local inference engine does not automatically reproduce the entire Kimi platform.

DeepSeek has the tidiest mapping. Its live pricing table says the deepseek-v4-flash alias currently resolves to DeepSeek-V4-Flash-0731, which matches the official checkpoint repository. Even here, an API endpoint and a local deployment are not guaranteed to be bit-for-bit equivalent: quantization, system prompts, kernels and sampling defaults can differ.

Specs that actually affect deployment

Field	Qwen3.8-Max hosted / related checkpoint	Kimi K3 hosted / checkpoint	DeepSeek V4 Flash 0731 hosted / checkpoint
Parameters	2.4T total, 95B active	2.8T total, 104B active	284B total, 13B active
Advertised context	Hosted: 1M; checkpoint: 262,144 native, extensible to about 1.01M	1,048,576	1M
Maximum output	Hosted: 131,072	Default 131,072; API can be configured up to the remaining context window	384K
Input modalities	Hosted: text, image, video; checkpoint is a text-generation release	Checkpoint: text, image; hosted API also handles uploaded video	Text only
Reasoning modes	Hosted supports non-thinking plus low/medium/xhigh controls; checkpoint guidance keeps thinking enabled	Always thinking; low/high/max, with max as default	Thinking is default; high/max controls
Tools	Hosted function calling and built-in tools	Tool calling and dynamic tools	Tool calling, Responses API and text FIM
Cache	Implicit and explicit modes	Automatic prefix caching	Automatic best-effort prefix caching

The one-million-token labels are capacity claims, not proof of one-million-token recall. Output ceilings also consume the context budget: a huge requested completion leaves less room for input and can affect quota admission. Kimi’s rate-limit guide is particularly explicit that the gateway reserves against request input plus max_completion_tokens, not merely the number of tokens eventually generated.

API pricing per one million tokens

These are direct-provider list prices in US dollars on August 18, 2026. They exclude taxes, router markup, image charges, retries and any enterprise agreement.

Model	Cache-hit input	Uncached input	Output
Qwen3.8-Max	$0.25 implicit cache read	$2.00	$6.00
Kimi K3	$0.30	$3.00	$15.00
DeepSeek V4 Flash, off-peak	$0.007	$0.22	$0.66
DeepSeek V4 Flash, peak	$0.014	$0.44	$1.32

Qwen separately lists $2.50 per million tokens to create an explicit cache and $0.17 to read it. The table uses its automatic/implicit cache rate so the three rows describe the same broad mechanism. Kimi’s official price page lists $3 cache-miss input, $0.30 cache-hit input and $15 output. DeepSeek’s current peak and off-peak schedule applies peak rates from 01:00–04:00 UTC and 06:00–10:00 UTC; off-peak rates apply otherwise.

DeepSeek is no longer as cheap as the $0.14/$0.28 figures Kingy recorded on August 3 and that older comparison pages still repeat. It remains dramatically cheaper than Qwen and Kimi.

Three realistic cost examples

Scenario	Qwen3.8-Max	Kimi K3	DeepSeek off-peak	DeepSeek peak
Code review: 100K uncached input + 10K output	$0.2600	$0.4500	$0.0286	$0.0572
Document analysis: 800K uncached input + 20K output	$1.7200	$2.7000	$0.1892	$0.3784
Cached agent loop: 50 turns after warm-up	$3.600	$5.250	$0.191	$0.382

The agent-loop scenario assumes each subsequent turn reuses a 200K-token cached prefix, adds 5K uncached tokens and produces 2K output. It excludes the initial cache warm-up because that request varies by application. It also assumes every prefix qualifies for and receives a hit. In production, record actual cache-hit tokens; never budget from a theoretical discount alone.

The economic decision is not simply “choose DeepSeek.” A cheaper call that returns no usable answer, breaks a schema or requires several repairs can cost more per completed task. That is exactly what Kingy’s controlled test exposed.

Cost per successful task: what 45 controlled calls showed

On August 3, Kingy ran five original text-only tasks—code repair, constraint reasoning, structured extraction, evidence synthesis and editorial writing—three times on each model. All 45 calls used fresh conversations through OpenRouter, pinned to Alibaba, Moonshot AI and DeepSeek respectively. Provider fallback was disabled. Every request used the router’s normalized high-reasoning control and a 7,998-token completion request, with an independent 8,000-token ceiling check.

The shared envelope became the dominant variable. Qwen and DeepSeek often spent almost the entire allowance on reasoning and surfaced no answer. Every request returned HTTP 200 from the intended route; 22 of 45 still failed to deliver visible content.

Task median, three runs	Qwen3.8-Max	Kimi K3	DeepSeek V4 Flash 0731
Code repair	0	100	0
Constraint reasoning	100	100	100
Structured extraction	100	100	0
Evidence synthesis	0	92	0
Editorial writing	0	92	0
Descriptive mean	40.0	96.8	20.0

Kimi returned visible text in 14 of 15 runs. Qwen did so in six, and DeepSeek in three. The result is not a universal intelligence ranking. It is a reliability result under one deliberately tight reasoning-and-answer budget.

To make failure economically visible, divide each model’s entire scored-run spend by the number of runs that earned a score above zero:

Model	Historical scored-run spend	Non-zero results	Spend per non-zero result
Qwen3.8-Max	$0.5998460	6 / 15	$0.09997
Kimi K3	$0.9046278	13 / 15	$0.06959
DeepSeek V4 Flash 0731	$0.0301264	3 / 15	$0.01004

DeepSeek remained the cheapest even after failures, but it completed only the compact constraint task. Kimi was the most expensive route by raw spend and the best value for broad one-shot completion. Qwen’s six visible outputs all scored 100, suggesting capability was not the problem; budget management was.

Those dollars are historical observations from the August 3 routes and prices. They are not repriced at today’s list rates. Mixing the two would manufacture precision.

Coding and tool use: separate the evidence lanes

Kingy’s matched task

The code task supplied a multiply broken Python 3.11 inventory reconciler and ten executable tests. Kimi was the only model to return code: its three runs scored 90, 100 and 100. The 90-point repair raised TypeError where the contract required ValueError. Qwen and DeepSeek exhausted the shared completion allowance with reasoning and returned no visible code.

That result favours Kimi for one-shot coding under a constrained envelope. It does not prove Qwen or DeepSeek cannot repair code. A larger answer reserve, lower reasoning effort or direct-provider call could reverse the operational outcome.

Independent current evidence

Artificial Analysis reports Kimi K3 max at 60 on Intelligence Index v4.1.1, 38.2 output tokens per second and $0.84 weighted cost per task. Its exact DeepSeek V4 Flash 0731 page reports 52, 103.2 output tokens per second and $0.11 per task. This is a useful capability-versus-efficiency contrast: Kimi scored eight points higher; DeepSeek generated about 2.7 times faster and cost about one-eighth as much per indexed task.

The exact hosted Qwen3.8-Max does not have a current model page in that independent lane, so it is not inserted into the table by analogy.

Arena’s August 15 WebDev snapshot places Kimi K3 max at 1674±11 and Qwen3.8-Max at 1667±13, with Qwen marked preliminary. Their intervals overlap, so the honest reading is a statistical tie, not a seven-point Kimi win. The current DeepSeek row is V4 Pro 0813, not V4 Flash 0731; identity hygiene requires excluding it.

Vendor benchmark claims—not a matched leaderboard

Vendor-published result	Qwen3.8-Max	Kimi K3	DeepSeek V4 Flash 0731
Terminal-Bench 2.1	86.6	88.3	82.7
DeepSWE 1.1	56.6	67.5	54.4
Agents’ Last Exam	27.0	28.3	25.2
AutomationBench	27.3	30.8	25.1

These numbers come from the three official model cards. They are grouped because the benchmark names match, not because the runs do. Qwen reports Claude Code and mini-SWE-agent variants under different context limits; Kimi uses Kimi Code on important rows; DeepSeek uses its own harness and max reasoning. Some vendors cite third-party leaderboards, some report their own runs, and timeouts differ. The table is evidence of vendor positioning, not a defensible four-event championship.

The practical coding verdict is therefore layered. Start with Kimi when the cost of an unfinished attempt is high. Use Qwen when you also need first-class hosted vision or when your own structured-data tests resemble Kingy’s perfect extraction lane. Use DeepSeek when throughput and budget dominate, but reserve answer tokens and reject empty completions.

Context: capacity is not retention

All three advertise about a million tokens, but a model can accept a long prompt and still fail to retrieve, combine or reason over the right facts. A serious comparison needs a retention test, not three context-window badges.

Artificial Analysis’ AA-LCR benchmark uses 100 questions over 10K–100K-token documents spanning financial, legal, academic, government and industry material. It reports 82.7% for Kimi K3 max and 74.3% for Qwen3.8-Max. That is meaningful long-document evidence and supports Kimi as the first choice for document reasoning.

It is not a million-token needle test, and the exact DeepSeek V4 Flash 0731 has no result in the current table. The current DeepSeek V4 Pro score cannot be substituted. For V4 Flash, the responsible conclusion is “1M advertised, exact retention unmeasured here.”

Before adopting any of the three for a million-token workflow, test at several depths with your own material. Place answer-bearing facts near the beginning, middle and end; require cross-document arithmetic; introduce plausible distractors; grade exact citations; and repeat at 64K, 256K, 512K and the intended maximum. Track accuracy, answer rate, latency and billed tokens. A single needle lookup is too easy and an advertised window is not a quality score.

Vision, video and agent capabilities

Qwen has the cleanest hosted multimodal proposition. QwenCloud documents text, image and video input, while Vision Arena’s August 6 snapshot lists Qwen3.8-Max at 1301±9 from 5,344 votes. Although shown second, its rank spread is 1–16 and its confidence interval overlaps several nearby models. That supports “competitive,” not an absolute second-place claim.

Kimi’s open checkpoint is natively text-and-image, with a 401M-parameter MoonViT-V2 encoder. Its API can accept uploaded video, and its card emphasizes long-horizon coding and knowledge work. The important integration detail is history preservation: Kimi requires complete assistant messages—including reasoning and tool calls—to be passed back in multi-turn agent loops.

DeepSeek V4 Flash 0731 is text-only. It supports tools and long completions, and the official API offers both OpenAI- and Anthropic-compatible surfaces. Its reasoning history must also be preserved across tool turns. If the workflow needs screenshots, diagrams or video, DeepSeek requires a separate perception model.

Open weights: the download is only the beginning

The three checkpoints differ more in storage than their “active parameter” labels suggest.

Checkpoint	Official repository payload observed Aug. 18	Precision/format clue	Published deployment guidance
Qwen3.8-2.4T-A95B	4.892TB	Full giant checkpoint; 2.4T parameters	Distributed vLLM, SGLang or TokenSpeed
Kimi-K3	1.561TB	Native MXFP4 weights / MXFP8 activations	Official vLLM recipes start at eight GB300- or MI350-class accelerators for listed single-node setups
DeepSeek-V4-Flash-0731	166.9GB	FP8-class release files	Official card shows a four-GB300 vLLM example

Repository totals include more than a hand calculation, but the arithmetic is still useful. Qwen’s 2.4T parameters require about 4.8TB at BF16 or 1.2TB at an idealized four bits per parameter before scales and metadata. Kimi would be roughly 5.6TB at BF16; its native MXFP4 release lands around 1.56TB. DeepSeek’s 284B parameters would be about 568GB at BF16, while the official repository is roughly 166.9GB.

Active parameters govern how much of a mixture-of-experts model computes per token. They do not erase the inactive experts from storage. Runtime memory also needs KV cache, activations, communication buffers and framework overhead—especially at long context.

None of these is a sensible single-workstation download. If the real goal is private local coding on 24GB–48GB hardware, look at Qwen3.8-27B instead or use Kingy’s local AI hardware guide. Among the three giants, DeepSeek is the practical self-hosting winner only in relative terms.

Licence implications

“Open weights” answers whether files can be downloaded. It does not answer whether a licence is OSI-approved, whether a hosted derivative can be sold without conditions, or whether a very large business needs another agreement.

DeepSeek V4 Flash 0731 uses MIT, the simplest option here for commercial use, modification and redistribution subject to the licence notice and disclaimer.

Qwen’s custom licence broadly permits use, modification, distribution, hosting and commercial products. It also contains model-name display requirements for products above stated monthly-active-user or monthly-revenue thresholds and a separate-licence trigger for certain very large model-as-a-service or AI-work-assistant businesses. Kimi’s custom licence has similar display thresholds and its own separate-agreement condition for certain large MaaS businesses. The thresholds and definitions are not interchangeable.

Read the exact Qwen licence or Kimi licence against your corporate structure and product. This article is a technical comparison, not legal advice. Kingy has a broader 2026 open-weight licence comparison for teams doing that diligence.

Direct API access and model IDs

Model	OpenAI-compatible base URL	Model string	Access detail
Qwen3.8-Max	`https://dashscope-intl.aliyuncs.com/compatible-mode/v1`	`qwen3.8-max`	QwenCloud/Alibaba account and `DASHSCOPE_API_KEY`; confirm model availability in the intended account and region
Kimi K3	`https://api.moonshot.ai/v1`	`kimi-k3`	`MOONSHOT_API_KEY`; API access requires at least a $1 top-up and limits scale by account tier
DeepSeek V4 Flash	`https://api.deepseek.com`	`deepseek-v4-flash`	`DEEPSEEK_API_KEY`; alias currently resolves to `DeepSeek-V4-Flash-0731`

A minimal OpenAI-compatible pattern looks like this:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)

response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[{"role": "user", "content": "Return one JSON object."}],
    max_tokens=4000,
    extra_body={"reasoning_effort": "high"},
)
print(response.choices[0].message.content)

For Qwen, swap the key, base URL and model string, and use its documented enable_thinking control. For Kimi, swap to the Moonshot endpoint and kimi-k3. These examples are documentation-derived; validate supported fields in the current SDK and direct-provider docs before production. Kingy’s dedicated Qwen3.8-Max API guide covers coding-client setup in more depth.

Whichever endpoint you choose, log the returned model/version, provider, finish reason, visible content length, reasoning tokens, answer tokens, cache-hit tokens, latency and cost. Treat an HTTP 200 with empty visible content as a failed task.

Availability and rate limits are part of the product

Headline tokens per dollar do not guarantee that an endpoint can serve a production queue. QwenCloud lists high account-level throughput for the hosted Max product, but Alibaba’s Model Studio regions and model catalogues are not interchangeable; verify the intended endpoint from the workload’s deployment region. Kimi uses tiered concurrency, requests-per-minute, tokens-per-minute and tokens-per-day limits based on cumulative account top-up. Moonshot exposes the exact allowance in the console rather than promising one universal public quota. DeepSeek documents a 2,500-request account concurrency ceiling for V4 Flash and returns rate-limit errors above it.

Provider routes can change the picture again. A router may add markup, choose a different quantization, enable fallback or expose another data policy. The August 3 Kingy test prevented that ambiguity by setting both order and only to the intended official provider and by checking the returned route metadata. Production systems should do the same when model identity matters, or deliberately accept flexible routing and measure each provider as a separate product.

Before launch, run a canary in every target region and account tier. Confirm model ID, response schema, tool-call format, cache reporting, maximum accepted prompt, maximum usable answer, rate-limit headers and data-handling settings. A model that looks cheapest on a public price table can become the expensive option if capacity limits force queueing, multi-provider failover or a second compliance review.

A production evaluation checklist

A sensible bake-off is smaller than a public benchmark suite but stricter than a chat demo:

Pin the artifact. Record the requested ID, resolved version, provider, region, precision and date. Keep hosted endpoints and weight repositories in separate rows.
Use matched prompts and tool surfaces. Give every candidate the same data, tool definitions, timeout and answer contract. If a model needs a different harness, disclose that as a new lane.
Reserve answer headroom. Track reasoning and visible answer tokens separately. Fail empty content even when the transport succeeds.
Grade the deliverable. Execute code, parse JSON, verify citations and inspect tool-side effects. “Looked plausible” is not a pass condition.
Measure cost per accepted result. Include retries, cache misses, repair turns, failed calls and any perception model needed by a text-only endpoint.
Test context at several depths. Scatter required evidence through realistic documents and repeat at the sizes the application will actually send.
Recheck the volatile fields. Price pages, aliases, limits, model availability and custom licences belong in a dated release gate, not a one-time research note.

That process will usually produce a routing policy, not one winner. It also makes later price changes easier to absorb: rerun the economic layer without pretending the capability evidence has changed.

Which model should you choose?

Choose Qwen3.8-Max for a managed multimodal product: screenshots, documents, video, structured output and tools in one API. It is also the safest choice when you need a non-thinking mode. Do not assume its downloadable checkpoint has the same capability envelope.

Choose Kimi K3 when coding quality, agent completion and long-document reasoning justify the premium. It won Kingy’s exact 45-call protocol, leads Qwen on the independent AA-LCR result and is statistically tied with Qwen in current WebDev Arena. Budget for verbose reasoning and preserve the full assistant history in tool loops.

Choose DeepSeek V4 Flash for cost-sensitive, text-only workloads with strong validation. It is the price and measured-throughput winner, the easiest checkpoint to host and the only MIT option. Set a deliberate reasoning budget, reserve answer headroom and implement empty-output retries. If a vision front end is required, price that second model too.

For high-stakes production, route by task rather than declaring one corporate winner: Qwen for multimodal intake, Kimi for difficult coding or long synthesis, and DeepSeek for cheap text transforms and compact reasoning. Measure the handoff cost between models; a three-model stack is only efficient if orchestration does not erase the savings.

Limitations

Kingy’s controlled test was deliberately small: five English, text-only, one-shot prompts with three attempts per model. It used OpenRouter rather than direct APIs, a restrictive shared completion envelope and no tools. The median scores are descriptive, not confidence intervals. Writing tasks used blinded AI reviewers; deterministic tasks used executable or schema validators.

The independent sources answer different questions. Arena measures pairwise human preference. Artificial Analysis runs a composite suite and separate long-context test. Vendor cards use differing harnesses, budgets and sometimes in-house evaluations. None should be collapsed into one synthetic score.

We did not claim million-token retention for any model. The available matched independent long-context evidence covers 10K–100K documents, and the exact DeepSeek Flash row is missing. Prices, aliases, account access, provider availability and licences were rechecked for August 18, 2026 and can change after publication.

FAQ

Is Qwen3.8-Max the same as Qwen3.8-2.4T-A95B?

No. Qwen says the hosted Qwen3.8-Max is based on the downloadable checkpoint but adds vision input, non-thinking support, default 1M context and official built-in tools. Compare the API product and checkpoint as related artifacts, not identical binaries.

Which model is cheapest?

DeepSeek V4 Flash by a wide margin. A 100K-input, 10K-output code review costs about $0.0286 off-peak or $0.0572 at peak, versus $0.26 on Qwen and $0.45 on Kimi at direct list prices. Retries and failed completions can narrow the effective gap.

Which is best for coding?

Kimi is the best first choice when one-shot completion matters: it was the only model to return executable code in Kingy’s constrained test and has the strongest vendor coding rows. Qwen is close to Kimi in WebDev Arena and perfect on the structured tasks it completed. DeepSeek is attractive for high-volume coding when the workflow can enforce budgets, tests and retries.

Which is best for long documents?

Kimi has the strongest exact-model independent evidence here: 82.7% on AA-LCR, versus Qwen’s 74.3%. That benchmark uses 10K–100K-token documents, not the full advertised million. DeepSeek V4 Flash 0731 has no exact current AA-LCR row, so no three-way winner can be measured from that source.

Are all three open source?

All three have downloadable weights. DeepSeek uses MIT. Qwen and Kimi use custom licences with commercial conditions at specific scale thresholds, so “open-weight” is the more precise shared label.

Can any of them run on a gaming PC?

Not the full official checkpoints in a useful way. DeepSeek’s repository is roughly 166.9GB, Kimi’s 1.56TB and Qwen’s 4.89TB. Runtime overhead pushes memory needs higher. Smaller distillations or models such as Qwen3.8-27B are the realistic local options.

Does a 1M context window mean reliable 1M-token recall?

No. It means the service accepts roughly that combined input-and-output envelope under documented conditions. Retention, cross-document reasoning and citation accuracy must be tested separately at the depths and document types your application will use.

Why did Kimi “win” Kingy’s test while DeepSeek was cheapest per successful result?

They answered different business questions. Kimi returned useful work across all five task families. DeepSeek completed only the compact constraint task, but did so for so little money that its spend per non-zero result remained lowest. Breadth and unit economics are not the same metric.

Bottom line

Qwen3.8-Max is the best all-round hosted product. Kimi K3 is the best high-capability open-weight family for coding and long-document work. DeepSeek V4 Flash 0731 is the cost, speed and licensing winner for validated text pipelines.

The decisive lesson is not a benchmark point. It is artifact discipline. Price the endpoint you will call, license the checkpoint you will ship, test the context you will actually fill and measure the answer that reaches the user—not the reasoning tokens consumed before it.

Change log

August 18, 2026: Rebuilt the comparison around exact API/checkpoint identities; added released Qwen weights, current DeepSeek peak/off-peak pricing, independent AA-LCR and Artificial Analysis evidence, deployment sizing, licence terms, workload verdicts and direct API IDs.
August 3, 2026: Original 45-call controlled test published.

Trending on Kingy

Qwen3.8-27B: Benchmarks, Specs, Local Hardware and Verdict

Can You Run Kimi K3 Locally? The Brutal Hardware Math Behind Its 2.8T Open Weights

Qwen3.8-27B vs Qwen3.6-27B vs Gemma 4 31B: Which Is Best for a 24GB GPU?