TL;DR: Qwen3.8-27B’s open weights landed on Hugging Face on August 14, 2026 — Apache 2.0, 27.78B dense parameters, now multimodal, 262K native context. The hardware story is almost unchanged from Qwen3.6-27B: 16.8GB at Q4_K_M, about 41 tok/s on an RTX 3090, 254 MiB more VRAM than its predecessor. A 24GB card runs it comfortably; a 16GB card still can’t.

	Used RTX 3090 (24GB)	Used RTX 4090 (24GB)	Rent (RunPod)
Best for	Cheapest card that runs Q4 with real context	Same fit, ~70 tok/s class speed	Trying it tonight, zero hardware
Price (Aug 2026)	~$1,100–$1,296 on eBay	~$2,268 average on eBay	A 24GB+ cloud GPU by the hour
The catch	~41 tok/s dense decode, 2020 silicon	Nearly 2× the 3090’s price for speed, not fit	You never own anything

Honest take: if you already run Qwen3.6-27B on a 24GB card, pull Qwen3.8-27B today — same footprint within 254 MiB, speed within 1%, and you trade nothing for a large jump in agentic and vision capability. If you’ve been waiting for a reason to buy a used RTX 3090, this model is it. A 16GB card was not enough for 3.6 and it is not enough for 3.8.

Alibaba announced the Qwen3.8 generation on August 3 and promised open weights “within about a week.” The flagship Qwen3.8-Max shipped its weights on August 13 — a 2.4T-parameter release almost nobody can run at home — and the model everyone was actually waiting for slipped a day past the ModelScope countdown before appearing: Qwen/Qwen3.8-27B went live on Hugging Face at 15:00 UTC on August 14, 2026, under Apache 2.0, per kingy.ai’s day-one specs breakdown. An official FP8 variant shipped alongside it, and Unsloth’s GGUF conversions followed within hours.

This is the release we flagged as the buy-signal model back when it was a countdown page. Now that the weights are real, here’s what changed, what didn’t, and the exact VRAM math — run your own card and context through the VRAM calculator before downloading 17GB of weights.

What Qwen3.8-27B actually is

The checkpoint is 27.78 billion parameters, dense — not a mini-MoE, which settles the pre-release speculation. Like Qwen3.6-27B before it, every parameter is read for every token, so decode speed is bandwidth-bound and unchanged by cleverness. Three things are new:

1. It’s multimodal. The model accepts text, images, and video — Qwen3.6-27B was text-only, and the vision-capable variants were separate downloads. The launch card evaluates it across browser, desktop, Android, document, chart, and visual-coding tasks.
2. 262,144-token native context, matching the class ceiling.
3. An MTP block ships in the base file. Multi-token prediction — the trick that took Qwen3.6-27B from ~40 to 60 tok/s on an RTX 3090 via community remixes — is now packaged in the release checkpoint itself, per InsiderLLM’s teardown. That’s where most of the (tiny) VRAM increase went.

The benchmark deltas Alibaba published are concentrated exactly where local users wanted them: agentic and computer-use work. From the official model card, versus Qwen3.6-27B: Terminal-Bench 2.1 rises 63.4 → 73.0, DeepSWE 1.1 jumps 13.3 → 42.2, OSWorld-Verified climbs 63.9 → 84.3, and SWE-MM goes 25.7 → 38.6, with 61.7 on SWE-bench Pro on the coding side (emergent.sh’s score-by-score breakdown, Yotta Labs’ verification roundup). The pattern: same decoder size, much better at driving a terminal, a browser, and a screen. If you run Cline-style local agents (our coding-stack picks live on aicoderscope.com), those are the numbers that matter.

Treat day-one vendor scores as vendor scores. Independent reruns take a week or two; the deltas are large enough that even a haircut leaves a real upgrade.

The VRAM math: 16.8GB at Q4, and what that means per card

The quant ladder, from Alibaba Cloud’s own “what it takes to run it locally” post and Unsloth’s model page:

Quant	Weights on disk	Fits 16GB?	Fits 24GB?	Fits 32GB?
IQ4_XS	15.4GB	Technically (0.6GB spare)	Yes, ~8GB spare	Yes
Q4_K_M	16.8GB	No	Yes, ~7GB spare	Yes
FP8 (official)	~28GB (1 byte/param)	No	No	Borderline — cache-starved
BF16	~56GB (2 bytes/param)	No	No	No — 2×24GB minimum

(The FP8 and BF16 rows are bytes-per-parameter arithmetic on the 27.78B count, not measured files — the 4-bit rows are the measured ones, and the ones that matter for consumer cards.)

The line that decides the tier question comes straight from Alibaba’s post: Q4_K_M’s 16.8GB exceeds what a 16GB card holds outright, and IQ4_XS at 15.4GB — the only 4-bit whose weights technically fit — leaves 0.6GB of headroom, less than the KV cache costs at everyday context lengths. That’s not a configuration to run; that’s an out-of-memory error with extra steps. Unsloth’s guidance says the same thing from the other direction: their 4-bit dynamic quants want 17–19GB of VRAM or unified memory — an RTX 5080, an RTX 4090, or a 24GB+ Mac.

So the tier verdict is identical to Qwen3.6-27B’s, and it’s the verdict our 16GB tier guide already carries: this class of model is the single best reason the 24GB line exists. On a 24GB card the Q4_K_M file leaves roughly 7GB for KV cache and buffers — 32K-class context without quantization tricks. On 16GB you’d be donating your entire cache budget to weights before the first token.

The problem you’ll actually hit: pull a Q4 on a 16GB card anyway (everyone tries), and llama.cpp either refuses to allocate or — worse, on Windows — silently spills into system RAM and decodes at single-digit speed. The fix is not a flag; it’s the 16GB tier’s models, a bigger card, or a rented one. Those are the three doors.

Day-one speed: within 1% of Qwen3.6-27B

InsiderLLM ran the head-to-head the day the weights dropped: RTX 3090, llama.cpp build b10088, both models on Unsloth UD-Q4_K_XL quants, five repetitions per cell across three context depths:

$ llama-bench -m Qwen3.8-27B-UD-Q4_K_XL.gguf -ngl 99 -fa 1 -p 512 -n 128 -d 0,4096,8192 -r 5
# tg128 @ d0:    ~41 tok/s  (3.8 trails 3.6 by 0.28 tok/s — under 1%)
# VRAM delta:    +254 MiB vs Qwen3.6-27B at the same quant

Their conclusion is the whole upgrade story in one sentence: if you run 3.6-27B on a 24GB card today, 3.8-27B loads at the same quant, fits with the same headroom, and generates at the same speed, within a percent you will never notice. The 0.28 tok/s deficit is real and repeatable — more than ten times the same-model repeat spread — and completely irrelevant in practice.

Anchors for other cards, carried over from the 3.6 generation since the architecture and size are unchanged: an RTX 4090 decodes this class at roughly 70 tok/s at Q4, and early community reports put an RTX 5090 around 45 tok/s at the heavier Q5 with llama.cpp at moderate context. The MTP block is the wildcard: once llama.cpp’s multi-token prediction path picks up the in-file block (the 3.6 remixes required community surgery), the 60 tok/s figure that tuned 3.6 setups reach on a 3090 should be the stock experience. Our tokens-per-second tuning guide applies unchanged in the meantime.

One honest caveat on multimodal: text generation is what day-one GGUFs do best. Unsloth’s docs list vision as supported in their conversions, but treat image-and-video input through llama.cpp-based stacks as week-one territory — if vision input is your primary use, the FP8 checkpoint through vLLM is the safer route while the GGUF toolchain catches up.

The buying decision in August 2026

The queue-era price assumptions did not survive the DRAM crisis, so here are the verified August 2026 numbers. Used RTX 3090 listings on eBay run $1,100–$1,296 with a market average around $1,248 (ResalePrices, BestValueGPU’s August tracker) — up from the ~$1,050 we cited in July. A used RTX 4090 averages $2,268 and clusters at $2,250–$2,500 (ResalePrices). Alibaba’s own post pegs the whole 24GB local route at “about $1,300 and an evening of setup,” which matches the 3090 path.

The decision tree:

• You own a 24GB card: download the Q4_K_M tonight. There is no hardware decision to make. The full 24GB model lineup explains what to run alongside it.
• You own a 16GB card: nothing changed for you today. Run the 16GB tier’s best or step up. The used 3090 remains the cheapest ticket — still the value king, though the crown costs $200 more than it did in spring.
• You’re buying from scratch: the 3090-vs-4090 question is speed, not capability — both fit the same files. $1,020 of price gap buys ~70% more decode speed and a warranty’s worth of newer silicon. Our GPU buying guide walks the full ladder.
• You want to try before buying: rent a 24GB+ GPU on RunPod for a few evening hours, point vLLM at the FP8 checkpoint, and see whether the agentic gains matter for your workload before committing four figures. The rent-vs-buy math is its own article.

For self-hosting setup beyond the hardware — serving, quantization pipelines, keeping weights updated — the FOSS side of this lives at aifoss.dev.

FAQ

Is Qwen3.8-27B really open weights, or another API-only “release”? Real weights: Qwen/Qwen3.8-27B on Hugging Face under Apache 2.0, with an official FP8 repo and third-party GGUFs already up. The Max flagship is the one whose local story is theoretical.

Will it run on my 16GB card at all? The weights alone at IQ4_XS leave 0.6GB for a KV cache that needs more than that at any useful context. Expect OOM or system-RAM spillover. The practical floor is 17–19GB per Unsloth — meaning 24GB cards in the real world.

Is it faster or slower than Qwen3.6-27B? Slower by under 1% at the same quant on the same card — 0.28 tok/s at depth 0 in InsiderLLM’s five-rep bench. You will not feel it. The MTP block in the base file is upside waiting for runtime support.

Should I upgrade from Qwen3.6-27B? Yes, and it costs you 254 MiB of VRAM. The agentic deltas (Terminal-Bench 73.0, OSWorld-Verified 84.3, DeepSWE 42.2) are the largest generation-over-generation jump this size class has posted, pending independent reruns.

What about running it on a Mac? Unsloth’s 4-bit guidance covers Macs with 24GB+ unified memory. Bandwidth rules apply as always: expect dense-27B decode in the 20s of tok/s on M4 Pro-class memory, faster on Max-class.

Recommended Gear

Products linked in this guide:

• RTX 3090 (used, 24GB) — the cheapest card that runs Qwen3.8-27B Q4_K_M with real context headroom; $1,100–$1,296 on eBay, Aug 2026
• RTX 4090 (used, 24GB) — same fit, ~70 tok/s class; ~$2,268 average used, Aug 2026
• RTX 5090 (32GB) — headroom for Q5/Q6 quants and fat KV caches; ~45 tok/s at Q5 in early community runs

No GPU yet? Rent a 24GB+ card by the hour on RunPod first.

Sources

• Qwen/Qwen3.8-27B — Hugging Face
• Qwen/Qwen3.8-27B-FP8 — Hugging Face
• Qwen3.8-27B: Specs, Benchmarks & Verdict — kingy.ai
• Qwen 3.8 27B vs 3.6 on RTX 3090: Speed and VRAM Tested — InsiderLLM
• What It Actually Takes to Run Qwen3.8-27B Locally — Alibaba Cloud Community
• Qwen3.8 — How to Run Locally — Unsloth Documentation
• Unsloth AI on Qwen3.8-27B 17GB RAM/VRAM setups — X
• unsloth/Qwen3.8-27B-GGUF — Hugging Face
• Qwen 3.8 Benchmark Scores: Every Number Explained — emergent.sh
• Qwen 3.8 Benchmarks: What’s Actually Verified So Far — Yotta Labs
• Qwen3.8-27B VRAM Requirements: 13GB to 54GB, Explained — OrcaRouter
• RTX 3090 Used GPU Price & Fair Asking Range — ResalePrices
• RTX 4090 Used GPU Price & Fair Asking Range — ResalePrices
• RTX 3090 Price Tracker US, Aug 2026 — BestValueGPU

Last updated August 15, 2026. Prices and specs change; verify current rates before purchasing.