
Qwen3.8-27B Review: the open-weight 27B that's "Opus at home" — tested against the hype
- OrcaNEWOrcaCyber: Hy4 Flash Abliterated / Uncensored2026-11-18$0.07 / $0.28 per 1M tokens · 187 tok/s
- openaiNEWOpenAI: GPT-6.2 Astra2026-11-17$8.00 / $40.00 per 1M tokens · 80 tok/s
- openaiNEWOpenAI: GPT-6.2 Sol2026-11-17$2.00 / $10.00 per 1M tokens · 155 tok/s
- tencentNEWTencent: Hy4 Flash2026-11-16$0.02 / $0.07 per 1M tokens · 196 tok/s
- AlibabaNEWQwen: Qwen4 Max2026-11-16$1.50 / $4.50 per 1M tokens · 85 tok/s
- GoogleNEWGoogle: Gemini 4 Carbon2026-11-10$2.00 / $10.00 per 1M tokens · 705 tok/s
- AnthropicNEWAnthropic: Claude Fable 5.22026-11-09$8.00 / $40.00 per 1M tokens · 246 tok/s
- OrcaOrcaCyber: GLM 5.3 Abliterated / Uncensored2026-11-04$3.00 / $5.00 per 1M tokens · 97 tok/s
- OrcaOrcaCyber: Hy4 Abliterated / Uncensored2026-11-04$0.80 / $1.60 per 1M tokens · 139 tok/s
- OrcaOrcaCyber: Kimi K3.1 Pro Abliterated / Uncensored2026-11-04$2.00 / $5.00 per 1M tokens · 84 tok/s
- tencentTencent: Hy42026-11-04$0.83 / $2.50 per 1M tokens · 122 tok/s
- OrcaOrcaCyber: MiniMax M3.1 Flash Abliterated / Uncensored2026-10-29$0.80 / $1.60 per 1M tokens · 102 tok/s
- OrcaOrcaCyber: GLM 5.3 Flash Abliterated / Uncensored2026-10-27$0.80 / $1.60 per 1M tokens · 69 tok/s
- openaiOpenAI: GPT-6.1 Terra2026-10-26$1.00 / $5.00 per 1M tokens · 35 tok/s
- OrcaOrcaCyber: Qwen3.8 Flash Next Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 89 tok/s
- OrcaOrcaCyber: MiMo V2.6 Flash Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 38 tok/s
- MoonshotMoonshotAI: Kimi K3.1 Pro2026-10-2447Intelligence
- OrcaOrcaCyber: DeepSeek V4.1 Flash Abliterated / Uncensored2026-10-23$0.80 / $1.60 per 1M tokens · 230 tok/s
- minimaxMiniMax: M3.1 Flash2026-10-1929Intelligence
- OrcaOrca: OrcaCyber Ultra 1.02026-10-17$5.00 / $10.00 per 1M tokens · 101 tok/s
Qwen3.8 27B is the best open-weights 27B you can self-host right now, and it is not particularly close. Weights dropped August 14, 2026 under Apache 2.0: a dense 27B (28B counting the vision encoder) with 262K native context, native image and video input, and vendor-reported agentic-coding scores that sit at or above Claude Opus 4.6 Max — SWE-bench Pro 61.7, DeepSWE 1.1 42.2, LiveCodeBench v6 90.3. The headline price is zero: download 55.6 GB and run it. The caveats are real too — independent testing finds it roughly three times slower and more token-hungry than its predecessor, the vendor's benchmark table still has no reproduction behind it, and the 1M context is a hosted-only feature. The interesting movement since launch is below the spec sheet: on October 13 a community llama.cpp port reported running these weights on a jailbroken PlayStation 5's GPU at around 20 tokens per second. Verdict: if you have a 24 GB+ GPU and want frontier-adjacent capability without a metered bill, self-host it — but go in knowing exactly where the numbers are soft.
Verdict first: should you use Qwen3.8 27B?
Short answer — yes for local and private workloads; wait for third-party numbers before a procurement decision. Qwen3.8 27B is the rare model where the open weights are the product and the API is the convenience. Because the license is Apache 2.0, the per-token price is permanently zero once you have the hardware, and nothing you build on it can be re-licensed or billed retroactively. What you give up is speed, verification, and convenience.
If you already run Qwen3.6-27B and are happy with it, the upgrade is real but not free in wall-clock terms. If you came here from the Qwen3.8-Max launch, this is the smaller, self-hostable member of the same generation — a different tool for a different job.
The fast facts, checked October 15, 2026
• Released — weights went live August 14, 2026 at Qwen/Qwen3.8-27B on Hugging Face, mirrored on ModelScope; timezone-bracketed coverage also cites August 13, and the release landed about a week after the Qwen3.8 generation was announced.
• License — Apache 2.0: download, modify, redistribute, commercial use, with an explicit patent grant. Permanent.
• Parameters — 27B dense (28B counting the vision encoder), 64 layers, hidden size 5,120, vocabulary 248,320.
• Architecture — hybrid attention: 48 Gated DeltaNet linear-attention layers against 16 full Gated Attention layers (a 3:1 split). This is why a 27B dense model can carry 262K tokens of native context.
• Context — 262,144 tokens natively; extendable to 1,000,000 via YaRN on the hosted version.
• Input — native image and video alongside text; returns text. The vision encoder is why the parameter count reads 28B.
• Thinking — reasoning mode on by default and disableable per request; reasoning_effort (low/medium/high) and preserve_thinking for long agent runs.
• Weights — 55.6 GB of BF16 safetensors in 18 shards; FP8 and community GGUFs also ship.
The specs above come from the Hugging Face model card and config for Qwen3.8 27B, read October 15, 2026. The vendor's benchmark table is Alibaba-reported and still unreproduced. The one independent evaluation on record is Artificial Analysis's, which scores Qwen3.8 27B at 34 on its Intelligence Index and measures 41.2 output tokens per second — a single index against a card full of vendor figures, and it does not reproduce them.
What Qwen3.8 27B is genuinely good at
The strongest case is agentic software engineering. Alibaba reports a 3x jump on DeepSWE 1.1 over the previous 27B (42.2 vs 13.3) and a score above Claude Opus 4.6 Max on SWE-bench Pro (61.7 vs 53.4). Those are the numbers that earned it the "Opus at home" nickname — a dense 27B doing frontier-adjacent coding work on hardware a person can actually own.

Three things besides the raw numbers make it a defensible buy:
• Native multimodal. Image and video in, text out — a document with diagrams or a video walkthrough is not a separate model. The visual-reasoning scores (85.6 with the chain-of-thought feature enabled, 94.6 visual math, both vendor-reported) are where the vision encoder earns its keep.
• 262K native context. Long-horizon agent tasks, big codebases, and multi-hour transcripts fit in one window. The hybrid linear-attention design keeps the KV cost of that context lower than a pure full-attention model of the same size.
• Free, permanent weights. This is the whole point of the category: a closed API model is rented; Qwen3.8 27B is owned. At 4-bit it runs on a 24 GB card (RTX 3090/4090-class), and AMD shipped Day-0 support (up to 24.5 tokens/s on a Ryzen AI Max+ 395 and 51.8 tokens/s on a Radeon AI PRO R9700, per AMD's own blog).
Where the review gets ugly: speed, tokens, and verification
Independent testing so far is one tester's harness, not a lab — but it is the best signal we have. Running Qwen3.8 27B against Qwen3.6-27B on ten real-world tasks (judged by GPT-5.5 via the llmcompare harness), the 3.8 won nine of ten and scored 8.838 vs 6.862 on average — "one of the more impressive intelligence lifts" the tester had seen. It also used almost three times the tokens and was considerably slower; one task took roughly 600% longer. So the quality jump is real, and so is the price in wall-clock time.
Four more things to hold against it:
• Independent benchmarks, fewer than the card implies. The vendor card is detailed and every number on it is still Alibaba-reported. Artificial Analysis's Intelligence Index score of 34, read October 15, is the first independent evaluation this model has — one score, from one lab, that says nothing about SWE-bench Pro 61.7 or DeepSWE 1.1 42.2. If your decision needs the agentic claims reproduced, they have not been.
• VRAM floor is real. BF16 needs an 80 GB-class GPU. To fit a 24 GB card you must run 4-bit, and community reports (dev.to comment thread, days after release) say quantized builds "lose focus after long context." Official weights if you have the VRAM; quantized if you do not — and the quantization path now reaches hardware far below a 24 GB card, which the PlayStation 5 measurement below is the first real evidence of.
• 1M context is hosted-only. The open weights cap at 262K. The extendable-to-1M figure is a Qwen Cloud hosted feature, not something a local copy does out of the box.
• "Beats Opus" needs qualifiers. Agentic benchmarks reward harness-specific behaviors, and a top comment on the dev.to launch post put it bluntly: "they do not beat opus on real-world usage." Treat the scoreboard as an upper bound on a good day, not a promise.
How it sits in the Qwen 3.8 family
• vs Qwen3.6-27B — the same hardware class and 262K context, but a major capability jump at the cost of speed and token efficiency. If you already run 3.6 and are throughput-bound, staying is defensible.
• vs Qwen3-Coder-30B-A3B — the Coder is a MoE with roughly 3.3B active parameters that runs much faster (~90–110 tokens/s). The dense 27B is slower per token but inherits the generation's agentic gains; if the 27B's software-engineering scores hold up under independent testing, the Coder-30B's role shrinks.
• vs Qwen3.8-Max — the 2.4T MoE flagship is a datacenter model (API-only, around $2/$6 per million tokens in published coverage) with 1M context and video. The 27B is the deployable one. They answer different questions.
The hardware floor moved on October 13
PS5LM is a llama.cpp port that runs GGUF models on a jailbroken PlayStation 5, inside a console you already own. Its released build is modest — v0.1.1, a single payload limited to about 1.6 GB of model, which is Qwen3.5 2B at 4-bit and nothing larger, on CPU only. On October 13 the project picked up a pull request that changes what the hardware list looks like: a native-app path that links llama-server against a community Vulkan driver for the console, and reports Qwen3.8 27B at 20.7 tokens per second on the UD-IQ2_XXS quantization (6.77 GiB, 64k context) and 20.3 tokens per second on UD-Q2_K_XL (9.15 GiB, 32k context, q4_0 cache), with one 7,775-token answer sustained at 19.7 tokens per second. The same console returned 61 tokens per second on Gemma 4 E4B and 124 on Llama 3.2 3B Instruct, which is what makes the 27B figure worth reading: it is not a small model flattering a big number.
Label it before you act on it. Those figures are the pull request author's own measurements on an unmerged branch, not a vendor benchmark and not a released build. PS5LM's own repository still lists both GPU offload and Qwen 3.8 27B as roadmap items it has not shipped, and the maintainer's comment on the pull request says he will reproduce the numbers on his own console before the README carries them. A second tester reports the app running at all — firmware 4.50, 7B and 9B models at roughly 30 tokens per second — which corroborates the mechanism without reproducing the 27B result. Getting there also assumes a console you own, firmware 7.00 to 13.60, and a jailbreak.
What it changes is the shape of the cost question, not its answer. A dense 27B at roughly 20 tokens per second on a games console is slower than the same model served from a real GPU — Artificial Analysis measures 41.2 tokens per second through Alibaba's own API, and 20 tokens per second is the speed of the 2-bit build, with the quality loss that compression implies. So this is not a reason to skip the 24 GB card; it is evidence that the class is portable far below it. If what you actually want is to know whether the model is good before you spend a weekend on a jailbreak, the cheap route is a metered call: one key across 200+ models, no second contract, and automatic failover across providers if the endpoint wobbles while you are evaluating.
Cost: the local-versus-API question, settled
For a closed model you compare per-token prices. For Qwen3.8 27B the marginal token costs nothing on your own hardware — the real price is the upfront GPU and your time. At 4-bit that is a 24 GB card; at BF16 it is an 80 GB-class machine. If you lack the machine, or you want answers before committing 55.6 GB of disk, the hosted route exists: OrcaRouter lists Qwen3.8 27B at $0.33 per million input and $2.40 per million output tokens on the OrcaRouter model page, which is provider list price passed through at 0% markup (checked October 15, 2026). The free, rate-limited tier this page described in August no longer appears there — treat it as stale unless you see it stated. Alibaba's own API is the other hosted route, which Artificial Analysis lists at $0.50 and $3.00 per million for the Xhigh reasoning configuration. Qwen Cloud's hosted version, with the 1M context, is still marked "coming soon."

The honest framing: for an open-weights model, a provider is a convenience, not a dependency. A metered hosted call is the cheapest possible way to decide whether a 55.6 GB download is worth it; it is also the only way to test the model without first solving the hardware problem the PlayStation 5 paragraph describes. But once you have decided, the weights are the thing — and they are free.
How to actually try it
• Fastest evaluation — call it on a hosted endpoint at $0.33/$2.40 per million; a few hundred thousand tokens of real work costs cents and settles the question before you download anything.
• Real test on your hardware — download a community GGUF (the Q4_K_M build is roughly 17 GB and fits a 24 GB card) and run it in llama.cpp or Ollama. Pass the Jinja chat template or the model answers you in thought tags. For vision from a GGUF you also need the separate mmproj file. Our runbook on running Qwen3.8 27B locally walks through it.
• Full precision — huggingface-cli download Qwen/Qwen3.8-27B onto an 80 GB-class GPU.
• Verify what you downloaded — check the publisher is the Qwen org and validate shards against crc32.txt; lookalike repos appeared before release.
When this review is wrong (and who should skip Qwen3.8 27B)
• You have no GPU and will not rent one. The hosted tier is $0.33/$2.40 per million — a small API model may serve you cheaper and more reliably. This model is for people who want to own the inference.
• You need an SLA. The hosted tier went up in mid-August; the OrcaRouter model page, read October 15, shows a 2.8% error rate over the trailing seven days, p50 first-token latency of 3.23 s and 156 tokens per second output across 77.2M tokens routed in that window. Two months in, that is a working endpoint rather than a launch-day queue — but a trailing-week average is still not a production contract. Self-hosters should pin their download commit and keep a fallback.
• You need the vendor's agentic claims reproduced, not just one index score. Artificial Analysis's Intelligence Index score of 34 is the one independent number this model has, and it says nothing about SWE-bench Pro 61.7 or DeepSWE 1.1 42.2 — both still Alibaba-reported. Directional, not procurement-grade.
• 262K open-weights context is not enough. The 1M extension is hosted-only today.
• Throughput is your bottleneck. Bulk summarization or large batches will hurt: this is a dense 27B that also burns roughly 3x the tokens of its predecessor. For cheap-bulk work, a smaller or faster model wins.
• You are on a 12 GB card. 2-bit GGUFs squeeze in with visible quality loss — that is the configuration behind the PlayStation 5 datapoint above — so this is a model to experiment with, not to standardise on.

The bottom line
Qwen3.8 27B is the strongest open-weights 27B available today, and it is free forever under Apache 2.0. If you have a 24 GB+ GPU and want agentic coding, 262K context, and native image/video input without a metered bill, this is the buy. The reasons to hold off are equally concrete: you need the vendor's agentic-coding claims reproduced somewhere other than the model card, an SLA, more than 262K open-weights context, or higher throughput than a dense 27B gives you. The model is out, the weights are real, the one independent score so far is a respectable 34, and the hardware floor turned out to sit lower than the launch coverage assumed. Just remember which numbers came from a lab and which came from the vendor.
