Qwen3.8-27B open weights: sizes, Q4_K_M, and real 4090/Mac speeds

On August 3, Alibaba's Qwen account said the open weights were coming "next week." That is the kind of sentence the AI industry has taught everyone to discount. Twelve days later there is nothing left to discount: the 2.4-trillion-parameter Qwen3.8-Max weights went up on Hugging Face on August 12, and the small one — Qwen3.8-27B, under a plain Apache 2.0 license — followed on August 14.

Then the interesting part happened. Within the same hour that Qwen finished publishing the 27B's model card, three separate community groups had already converted it into formats you can run on a personal computer. Two days after that, those community conversions had been downloaded more than a million times.

That number is the story, not the benchmark table. A 27-billion-parameter model from one of the world's leading AI labs went from "announced" to "running on a million-ish desks" in roughly 48 hours. This post is a plain-language guide to what that actually means: what shipped and under which license, what it takes to run the 27B on hardware you already own, how far this has come in three years, and — the part most coverage skips — what a local 27B still cannot do.

TL;DR:

• The promise was kept. Qwen3.8-Max (2.4T total / 95B active) landed August 12; Qwen3.8-27B landed August 14. Both are genuinely downloadable, not hosted previews.
• The licenses differ, and that difference matters more than the scores. The 27B is Apache 2.0 — no thresholds, no clauses, use it commercially and owe nothing. Qwen3.8-Max ships under a custom license with a revenue trigger for model-as-a-service businesses.
• Size decides everything about who can run what: Max is a 4,892 GB download; the 27B compressed to 4-bit is 17.1 GB, small enough for a 32 GB machine. Community 4-bit builds passed 1.07 million downloads within two days.

Image: Dejan Krsmanovic, Wikimedia Commons, CC BY 2.0. Running a frontier-lab model yourself means the machine — and its maintenance — becomes yours.

The promise came with a date, and the date held

Back on August 4 we covered the announcement itself and called the wait "measured in next week, not someday". That was as far as the evidence went at the time. It resolved cleanly.

Qwen3.8-2.4T-A95B — the model marketed as Qwen3.8-Max — appeared with its license file on August 12. Qwen3.8-27B and an efficiency-optimized FP8 version arrived on August 14. Both dates sit inside the window "next week" described. In an industry where announced models routinely never ship, a lab hitting a nine-day-old verbal deadline is worth noticing on its own.

The reception was immediate and large. The Hacker News thread on the 27B collected 1,351 points and 769 comments in a day. Within hours, practitioners were posting working serving configurations for specific hardware — one shared setups for both an NVIDIA DGX Spark and a consumer RTX 4090 graphics card. This is not how the industry treated open-model releases two years ago, when getting a new architecture to run at all was a weekend project.

A promise with a date attached, and the two deliveries that landed inside it. Dates from Hugging Face repository commit history, retrieved August 16, 2026.

Five terms, aimed at the question "can I run this?"

If you arrived from our earlier posts you already know what open weights are: the lab publishes the giant grid of learned numbers that constitutes the finished model, and you can download it, run it on your own hardware, and build on it without paying per request. Here we care about the follow-up question, which is entirely practical — what does running it actually cost you in hardware?

Parameters are those learned numbers, and their count sets the model's raw size. The rule of thumb is brutally simple: at the precision labs train in, every billion parameters is about 2 GB on disk, and you need roughly that much memory to hold the model while it runs. So a 27-billion-parameter model is a 55 GB download. A 2.4-trillion-parameter one is nearly 5 terabytes, which is why one of these is a laptop question and the other is a data-center question.

Quantization is what closes that gap, and it is the single most useful idea for anyone who wants to run models at home. Each parameter is normally stored at 16 bits of precision. Quantization rounds them to fewer bits — 8, 4, sometimes 2 — which shrinks the file roughly in proportion. Four-bit quantization turns that 55 GB download into about 17 GB. You lose a little accuracy, and you gain the ability to run the thing at all. GGUF is simply the file format these compressed versions ship in; it is what tools like llama.cpp, Ollama and LM Studio read. When you see "Q4_K_M," read it as "the 4-bit build most people use."

Dense versus mixture-of-experts decides how fast it runs once it fits. Qwen3.8-27B is dense: all 27 billion parameters fire for every word it produces. Qwen3.8-Max is a mixture-of-experts model — 2.4 trillion parameters total, but a router picks only about 95 billion of them per token, spread across 512 specialist sub-networks. The total tells you the storage bill; the active count tells you the compute bill. This distinction has a sharp practical edge, which we will come back to.

Context window is how much text the model can consider at once. The 27B handles 262,144 tokens natively — call it 200,000 words, or a stack of hour-long meeting transcripts — and can be stretched to a million with a configuration change.

The license is the part to read first

Here is the load-bearing finding, and it cuts against the assumption that a family of models shares a family of terms.

Qwen3.8-27B is Apache 2.0. That is the permissive end of the spectrum: use it, modify it, fine-tune it, ship it inside a commercial product, run a business on it, owe nothing and ask no one. No revenue thresholds, no attribution-on-the-UI requirement, no field-of-use carve-outs.

Qwen3.8-Max is not. It ships under a custom "Qwen3.8-Max License" that begins MIT-like and then attaches two conditions. If your product crosses 100 million monthly active users or 20 million US dollars in monthly revenue, you must display the model's name in your interface. And if you run a model-as-a-service or AI-work-assistant business whose revenue exceeds 50 million dollars over any twelve months, you need a separate agreement with Qwen before using it commercially at all.

For a solo developer or a company using either model internally, none of this bites. But it is the same asterisk we flagged when Kimi K3 shipped under a custom license instead of MIT, and the lesson repeats: "open weights" and "open license" are two separate questions, and a lab can answer them differently for two models released two days apart. Read the license before you fall for a score.

What it actually takes to run the 27B

The honest answer is: less than you would guess, and more than the headlines imply.

The lowest rung is one command. The 27B is in Ollama's library — ollama run qwen3.8 pulls an 18 GB build with a 256K context window and image input, and there are twelve variants including one tuned for Apple silicon. LM Studio, which gives you a chat window instead of a terminal, had its build up within minutes of the release. Neither asks you to understand any of the preceding section.

Then reality asserts itself in the form of tokens per second. Practitioners reporting in the release thread landed roughly where the hardware predicts. On an RTX 4090 running the 4-bit build, one measured about 48 tokens per second — comfortably faster than you can read. On a Mac mini M4 Pro with 64 GB of memory, another got 12.75 tokens per second: usable, but you will watch it type. And on a laptop with an AMD 7840U and 64 GB of ordinary DDR5 memory, the same 4-bit build produced about 4 tokens per second — technically running, practically a batch job you leave alone.

That last figure is where the dense-versus-experts distinction earns its keep. The same person measured an older mixture-of-experts model of larger nominal size on the same laptop at roughly 20 tokens per second — five times faster than the smaller dense model, because only a fraction of its parameters fire per word. If you are shopping for something to run on a CPU, active parameters are the number to shop on, not total ones. It is the least intuitive lesson in local AI and the most useful.

Two members of the same model family, separated by a factor of 290 in download size. Sizes summed from Hugging Face file listings, retrieved August 16, 2026.

Three years ago this took a leak and a weekend

To see how far this jumped, put it against where local models started.

In February 2023, Meta released the original LLaMA weights to approved researchers only. They leaked within about a week, and the entire hobbyist local-model scene was built on a file people were not supposed to have. On March 10, 2023, a developer published llama.cpp, a small C++ program whose party trick was running the 7-billion-parameter model on a MacBook. That repository now has 124,000 stars, and it is the ancestor of essentially every "run it locally" tool in use today.

Compare the two release days. In 2023: a leaked 7B, no license to speak of, a week of community effort to make it run, and a model that was interesting rather than useful. In 2026: a 27B from a frontier lab, published deliberately under Apache 2.0, with vision and video input, a 262K context window, and community builds finished before the lab's own documentation had stopped changing. The unsloth conversion's first commit landed at 14:56 UTC on August 14 — four minutes before Qwen's final model card update.

The adoption numbers say the same thing more bluntly. As of August 16, community 4-bit builds of the 27B had drawn 867,963 downloads from one publisher, 171,518 from a second, and 34,520 from a third: 1.07 million in two days. Qwen's own official 27B repositories account for another 215,000. Qwen3.8-Max, the far more capable model, sits at 17,126 across both of its repositories.

Read that ratio again. The frontier-scale model got about 1.6% of the attention that the laptop-scale one did. Capability is not what the market went and got. Reach is.

What a local 27B still cannot do

Now the correction, because the enthusiasm outruns the evidence in predictable ways.

Alibaba's own benchmark table has the 27B beating Opus 4.6 Max on several agentic coding and instruction-following measures — 61.7 against 53.4 on SWE-bench Pro, 79.5 against 62.5 on IFBench — while losing on others, including 30.8 against 40.0 on the broad-knowledge HLE benchmark. Every one of those numbers is vendor-reported. As of this writing Artificial Analysis, the independent evaluator we lean on, has no entry for the 27B at all; it does rank Qwen3.8-Max tenth of 188 models with an intelligence score of 58, which is excellent and is also a different model.

Practitioners were sharper than the spreadsheet. The most upvoted correction in the release thread, from a self-described long-time open-model user, was flat: these do not beat the top hosted models in real-world use; they are "good enough" for plenty of tasks and runnable on affordable hardware, which is a different and more modest claim. Another commenter put the ceiling in physical terms — you cannot compress the whole of human knowledge into a 30 GB file, so small models stay comparatively weak at recalling obscure facts however sharp they get at coding or tool use.

Two more limits show up only once you run it. Quantization is not free: a heavily compressed model tends to lose the thread over long contexts and can fall into repetition loops, which is why anyone with the memory to spare is advised to run the full-precision version. And this generation of Qwen thinks hard by default — one user prompted the 27B with two words, "svg owl," on a 64 GB Mac mini and watched it generate 21,769 tokens of reasoning over 17 minutes and 12 seconds before answering. It produced a good owl. It also produced a bill in wall-clock time that no hosted API would have charged.

Then there is the part nobody counts: you now own the operations. Model updates, quantization choices, memory headroom, driver versions, the machine's fan. The hosted API you were avoiding was also a team of people keeping something running.

The bottom line: the moat moved down the stack

Here is the point, and it is bigger than one release.

A frontier lab published a capable 27B on a Thursday. By Saturday, over a million copies of community-compressed versions were on people's machines, it was one command away in Ollama, and it was legally free to build a business on. Whatever advantage that model represents, it took roughly two days to become available to every competitor simultaneously. Call it the two-day moat — a model edge that now has about a 48-hour half-life.

This is not a prediction. It is a measurement, taken this week, on this release.

And it redefines what building an AI product means. When the model layer is a commodity that anyone can swap in an afternoon, the model stops being the thing you compete on. What survives is everything wrapped around it: reliability when the inference server falls over at 3am, data pipelines that capture and clean and retrieve the right context, evaluation that tells you whether it works on your data rather than a benchmark's, an interface a person will actually use, and the trust arrangements — privacy, retention, who can see what — that decide whether anyone hands you their meeting recordings in the first place.

None of those get commoditized in two days. None of them have a download button.

The layer that got cheap this week, and the layer that did not. Download figures from Hugging Face, retrieved August 16, 2026; the two-layer framing is ours.

So the correct response to a great open model landing on laptops is not "the model companies won" or "the product companies lost." It is that the interesting work moved one floor down the stack, to where it is much harder to copy and much less fun to write headlines about.

---

Where Telli.sh fits: we build exactly that service layer, on open models. Telli.sh already runs an open Qwen model in its summarization path, which means every jump in open-model quality — this one included — flows straight into meeting transcription, translation and summaries without a price change on your side. What we spend our time on is the part that does not arrive in a GGUF file: capturing audio reliably, keeping speakers straight, turning a 60-minute recording into notes you can search months later, and being clear about where your data lives.

Start a live AI note

Sources

• Qwen3.8-27B model card and license, Hugging Face
• Qwen3.8-2.4T-A95B model card and license, Hugging Face
• unsloth/Qwen3.8-27B-GGUF quantized builds and download counts
• Qwen3.8 in the Ollama model library
• Hacker News discussion of the Qwen3.8-27B release (August 14, 2026)
• Artificial Analysis model page for Qwen3.8 Max
• Qwen (@Alibaba_Qwen) open-weights announcement on X (August 3, 2026)
• llama.cpp repository, created March 10, 2023
• Wikimedia Commons image page