Let me be clear up front about what this post is, and what it is not. It is not a review: Qwen 4 27B is not out, there are no weights, and there is nothing to download. It is a synthesis. I read through everything that has been published about the model so far, early benchmark results, the press release, a conference slide, some code, and a fair number of forum threads, and this is the picture that came out of it: a straight answer on what we actually know about Qwen 4 27B so far, what is still just guessing, and a few things you can do in your app’s settings tonight.
The setup, for anyone who has been sleeping on this: the local AI scene has been buzzing all week about a model that is not even out yet. There are no official weights, no model card, nothing you can actually download. And yet people are already calling it the model that almost beat Claude Opus, GPU prices are creeping up on eBay, and there are forum posts telling people to buy hardware right now, before the thing launches. So it is worth slowing the train down and separating signal from noise. Here is what I found, in order of how confident I am in each piece.
The hype gets its fair day in court
On November 7, a creator who runs a game development benchmark published some early numbers that set the community on fire. He had gotten access to a model through Alibaba’s coding app, Qoder, and was told the endpoint he was testing was Qwen 4 27B. On the benchmark it scored 44.6, while Claude Opus 5.5, one of the best models on the planet right now, scored 47.2. That is a 2.6 point gap between one of the most capable models available and a 27B model that fits on a single consumer GPU.
But the number that actually went viral was the cost column. The Qwen model came in at about 16 cents per run, while Opus came in at $2.60. That is 16 times cheaper for a score that is only 2.6 points lower. Other early testers piled on. One creator who posts a lot of local AI builds wrote that Qwen 4 used far fewer tokens and was dramatically more efficient, and another said it finished a build in 40 minutes that took DeepSeek R1 seventy. If that really is the 27B, you could argue it is the best small model ever made that runs on one card. I would not blame anyone for refreshing Hugging Face three times looking for weights after seeing numbers like that.
The endpoint was a moving target
Then the story got complicated, because Qoder itself explained what was actually going on. For four days it had been running a Qwen test build that was updated daily. The model you tested on Saturday was not the model you tested on Monday, and the size was never stated. One tester ran the same prompt twice and said the outputs looked like two completely different models had run them. That is not a consistent benchmark so much as a living experiment.
The benchmark author then ran the new Qwen 4 Max preview through the same benchmark. It scored worse than the viral 27B result, and actually worse than Qwen 3.8 Max. The author’s own words were, roughly, total chaos. And there was one more detail buried in the replies that I could not shake. If this is a 27B model at 8-bit precision, the file should be around 29 GB, the same as Qwen 3.8 27B. The size the testers were given was 35 GB: about 20 percent bigger for a model with the same name. None of that proves the demos were fake, but it does prove they were unattributable. And you cannot plan a hardware purchase around a model whose identity changed every single day of testing.
What is actually in writing
So I stepped back from the hype and read the official record myself, and it is shorter than you would think.
- September 22. Alibaba put out a press release saying Qwen 4 is currently in training. No sizes named, no timeline.
- A conference slide. An attendee photographed their screen, and it showed four names under “Qwen 4 series, coming soon”: Max, Plus, Flash, and 27B.
- One outlet. A Chinese outlet reported that on the open-weights side, the 27B gets priority.
- Alibaba’s own code. The Qwen Code agent merged a change in late October that assigns every Qwen 4 model ID a 1-million-token context window. The test list in that commit includes Qwen 4 Max, Qwen 4 Plus, and even Qwen 4.5 Max. It does not include Qwen 4 27B.
- Intel’s code. The only code that actually names the 27B came from outside Alibaba entirely. An Intel team merged a pull request on October 23 titled “Optimize Qwen 4 27B.” The repository was taken down quickly, but the Internet Archive caught a copy two days later.
That is the entire official record: a name on a conference slide, a priority claim from one outlet, and kernel optimization code that never fully ran. If you were hoping this post would end with a download link, I’m sorry. There isn’t one.
The Intel document is still worth reading
But that Intel document tells us more than nothing, because kernel code cannot be vague. It has to know the exact width of every layer, the number of attention heads, and the layout of everything, and what it describes matches the current Qwen 3.8 27B almost exactly. Same internal width: 5,120. Same attention structure: 24 query heads and 4 key-value heads. So the 4-bit file should come in around 16 to 17 GB, very close to what people are running today, and the document describes 4-bit running on one card and 8-bit on two. It also notes, plainly, that Intel never had the real weights for one of the new architectural components, so nothing ran end to end.
The practical upshot is a little anticlimactic, and I will say it directly: if Qwen 3.8 27B runs on your card, Qwen 4 27B almost certainly will too. Which means you should not buy a new GPU for this model. I know the pressure is real. Used Tesla P100s on eBay went from about $80 to $180 in two months, and the RTX 560 Ti with 16 GB jumped from $569 in July to around $770. But nothing in the confirmed architecture says we need a bigger card, and buying on a prediction we cannot verify means paying a peak price for a guess. Keep your money.
The wrong benchmark
Everyone is going to benchmark Qwen 4 27B against Claude Opus 5.5, because “can a local model beat Opus?” makes a great thumbnail. It is also the wrong question. Opus is not on anyone’s desk, in the local sense. The real choice is between the new 27B and the 27B you are already running, and on your own machine you don’t pay per token. You pay in time.
Artificial Analysis runs a real task index, actual coding and reasoning work rather than synthetic benchmarks, and the current Qwen 3.8 27B scores 20 on it, well above the median of 8 for models its size. By that measure it is already a good model. But look at what it cost to get there. Across the index it produced 128 million output tokens, where the median for its class is 77.7 million, and it needed 39.6 minutes per task where comparable models needed 13.6. That is nearly three times as long per task, on servers, not on a home GPU. Artificial Analysis’ own summary calls the model “very verbose” and noticeably slower per task, which is a model design problem, not a hardware problem.
So the real question for the new 27B is not whether it scores higher. It already scores well. The question is whether it finishes sooner, and to understand why that matters so much, we have to talk about why local models feel slow at all.
Why your GPU feels slow
Say you have an RTX 3090. It does roughly 35 trillion operations per second, which by any reasonable measure is an absurd amount of compute. So why does generating text feel like watching paint dry? The bottleneck is not the math. It is the reading. Every single token the model generates, the GPU has to read the entire model file out of its memory. The standard 4-bit Qwen 27B file is 16.46 GB, and a used 3090 reads memory at about 936 GB per second. Divide one by the other and you get a ceiling of around 57 tokens per second, and that is the absolute best case. Real runs are slower.
Now add thinking. The current 27B has a reasoning mode, where it works through the problem step by step, out loud, before answering. That is what makes it good, and what makes it slow. A fine-tuned team measured the base model on a science benchmark and found answers averaging about 15,000 tokens, and most of that is internal thinking nobody actually asked for. At 57 tokens per second, that is 4.4 minutes for one answer, at the ceiling. Real runs come in worse. So when the cursor is blinking, the GPU is not slacking off. It is doing exactly what it was asked, after asking itself a lot of follow-up questions first. Ask anyone who has run a local reasoning model: the first week is spent checking temperatures, running diagnostics, and restarting the app twice before realizing nothing was broken.
The dropdown most people never touch
Here is something I suspect a lot of people did without realizing: for the first months they ran Qwen 3.8 27B, they never changed the reasoning level, because most people didn’t even know it was a setting. The model has three levels, low, medium, and xhigh, and the default, if your app sends nothing explicit, is xhigh: the most thinking it can possibly do. Across all three levels, xhigh gets a score of 20 at 39.6 minutes per task, while low gets 16 at 26.6 minutes. Xhigh buys you four points on the benchmark for 49 percent more time per task and 66 percent more tokens.
Sometimes that trade is worth every second. You are debugging a nasty memory leak, working through a complex algorithm, doing a hard architectural refactor: let it think, let it cook, and go make coffee on purpose. But if you are renaming some variables, writing a boilerplate test file, or summarizing a document, you just sat there for an extra 13 minutes while the model overthought something a junior developer could have handled in 30 seconds. Anyone who has run a local assistant for routine tasks knows what it does to an afternoon.
And it matters for Qwen 4 specifically, because the same October commit that assigns the new family its context window also gives it the same three reasoning levels, with xhigh as the default. Whatever the new 27B achieves in raw capability, it will ship with the most expensive setting turned on. Which means the first performance gain you get on day one is not in the model at all. It is in a dropdown most people have probably never touched. Change that setting first, before you run a single benchmark, and set it on purpose.
Three expectations, ranked by how sure I am
1. The same file on the same card. This is the one I am most confident about, because it comes from kernel code, and kernel code does not have room to be vague. 5,120 width, 24 to 4 attention heads, about 16 to 17 GB at 4-bit. If the current 27B fits your card, the new one will.
2. Long chats finally stop slowing you down. This is where Qwen 4 should actually feel different, and it is the one I am most excited about. When you have a long conversation, a big code base loaded into context, 128,000 tokens, say, the model has to maintain what is called a key-value cache: the notes it keeps about everything it has already seen. At 128,000 tokens in full precision those notes take about 8 GB of GPU memory, and the model has to reread them for every new token it generates. On a 3090 running 8-bit notes, that adds more than 4 GB of extra reading per word on top of the 16 GB model file, and the ceiling drops from 57 tokens per second to about 45. After an hour of coding with a heavy context window, the model that felt fast in a fresh chat feels noticeably sluggish. Anyone who has run a long coding session knows the version where you thought your Ollama setup was breaking, only to realize the context had grown to 80,000 tokens and the model was drowning in its own memory.
Qwen 4 adds something called sparse attention. Instead of reading every single note for every new word, it checks an index and reads a fixed budget of 248 tokens of notes per word. At 128,000 tokens, that is about 1.6 percent of them, and the speed ceiling at long context stays near 57 instead of sliding off. One clarification, because I have seen this confused: sparse attention saves reading time, not memory. Every token is still written down in full, because the index might need any of them later, and the full 262,000-token window still will not fit on a 3090 next to the model. But for realistic coding sessions on a single card, this should feel meaningfully better.
3. Shorter thinking, maybe. This is the one I want most, and the one I am least sure about. The most-liked comment I could find on a preview clip says the 27B was ridiculously wordy and not actually outputting a product, and that this has been fixed in Qwen 4. Every early tester who mentioned token count said the same thing: dramatically more efficient. And there is real proof this is achievable on this exact architecture. A fine-tune called Swift 1.5 took Qwen 3.8 27B and trained it specifically to stop overthinking, and on the same science benchmark the average answer dropped from 15,000 tokens to about 8,700: a 42 percent reduction, and the score actually went up slightly. At 57 tokens per second, that is the difference between 4.4 minutes and 2.5 minutes per question, on the same hardware, with zero changes on your end.
My honest concern is that every “fewer tokens” claim so far came from that Qoder endpoint, the one that was changing daily and ended up becoming Max. Nobody outside Alibaba has taken a confirmed 27B model and measured thinking length on it. This is the expectation I will be watching most closely on launch day. If it is true, it changes everything. If it is not, the other gains are still real, just smaller than the community is hoping for.
The throne has two seats
One model has been quietly sitting in the background of all this: Qwen 3.8 Flash Next, which Alibaba released in August and described as an experimental preview of the architecture that will underpin Qwen 4. It matters because Flash Next is a mixture-of-experts model. It is huge in total size, something like 125 billion parameters, but it only activates about 6 billion of them per word. Instead of reading 16 GB of weights per token, it reads the slice that matters.
There is an engine called Strata running Flash Next’s 2-bit version on a 12 GB GPU with 64 GB of system RAM, and it is hitting 93 tokens per second at short context, dropping gracefully to 73 at 128,000 tokens. That is faster than the theoretical ceiling for a dense 27B on a 3090. The trade-off is real, though. A 2-bit file is a compressed approximation, and in the one side-by-side I could find, the dense 27B wrote better code. Quality still matters, and this is not a free upgrade. But if you are on a 12 GB card right now, wondering whether Qwen 4 27B is ever going to fit, this conversation already has an answer: the Flash family runs there, and it runs fast. Qwen 4 Flash, when and if it releases its weights, is the model to watch on smaller cards. The throne for local AI is not one seat. It is split by hardware: the 27B competes on quality per minute for 24 GB cards, and the Flash family already rules the 12 GB tier. Nothing in the upcoming release changes that.
A launch-day survival kit
When the weights drop, a few things will go wrong immediately, and none of them will actually be the model’s fault. Know them in advance.
- Your app might not load it. Qwen 4 introduces two new architectural features, sparse attention and new residual lanes, and both need updated code in the back end. LM Studio and Ollama both lean on llama.cpp for this, and the good news is that llama.cpp already added support for most of these features when Flash Next launched, so support could come quickly. Before you assume the model is broken, check the llama.cpp release notes and make sure your app is up to date.
- The context window default will silently wreck your agents. Ollama’s own documentation says any card under 24 GB gets a default context window of 4,000 tokens, while the same documentation recommends that agents and coding tools need at least 64,000 tokens to function properly. Launch an agentic coding session without changing that setting, and the agent will start forgetting everything after a few thousand tokens. People will spend hours blaming the model for having terrible memory when it is not the model, it is the default. Change it before your first run.
- Xhigh. Set the reasoning level yourself, on purpose, before you do anything. Medium for exploratory work, low for fast utilities, xhigh for the hard stuff.
- Fake weights. This one is annoying but real. There are already repositories on Hugging Face named Qwen 4 27B that are not from Qwen, and at least one appears to be just Flash Next with the name changed. How do you know it is the real thing? Two things: a model card under the official Qwen organization on Hugging Face, and a post from the verified Qwen account naming that specific model. If only one of those two is true, wait.
One more thing, if you build on these at work
Qwen 3.8 27B ships under Apache 2.0, the most permissive open license there is. You can use it in a business, in a product, commercially, without restrictions. But Flash Next does not. It ships under a separate Qwen Community License with different terms, and the open Qwen 3.8 Max weights use a third custom license. That is three different licenses for three models from the same company in the same generation. The license for the new 27B has not been announced anywhere. Some people in the community seem certain it will not be Apache 2.0, but there is no source for that either. If you are building at work and planning to integrate this into anything commercial, read the license file before you switch. Open weights and permissive weights are not the same thing. Finding out six months into a project that your license requires attribution, or prohibits certain use cases, is a painful conversation to have.
What I’d do, starting this week
If you run local models, here is the plan I would follow between now and launch day. It costs nothing.
- Keep running Qwen 3.8 27B. The architecture is so similar that every setting you have tuned, your context window, your system prompt, your reasoning level preferences, should carry over almost directly. You are not throwing away work by staying put.
- Set your reasoning level on purpose. Not xhigh by default. Think about what you are building and pick the level that fits: medium for exploratory work, low for scaffolding, xhigh for the bugs that have been sitting in your backlog for a week, and then go get a coffee on purpose.
- Raise your context window past the app default. Whatever it is, change it to 32,000 at minimum if your card can handle it, then check the docs for your specific setup.
- Time one real task, end to end. Pick something you do often, a full coding task, a document workflow, something that takes real time, and time the whole thing. Not tokens per second: end to end. That number is your baseline, and it is the only fair judge this new model will ever get.
- Do not buy a graphics card for a model nobody has measured yet.
Here is what I keep coming back to. The thing about local AI that gets lost in all the benchmark posts and viral demos is that the question was never really which model scores highest. It was always which model fits your life. A model that scores 44 and finishes in 15 minutes is infinitely more useful than one that scores 47 and ties up a machine for 45 minutes. Nobody has 45 minutes to stare at a loading bar, and most of us have work to do that doesn’t pause while a GPU overthinks a variable name. That is why Qwen 4 27B is the model to watch: not because of some chart on a leaderboard, but because if the efficiency gains are real, the thinking is tighter, and the long-context slowdown is actually fixed, more of a day gets spent doing things instead of waiting. And that is worth more than any score.
When the weights drop, the fair test is a simple one: real tasks, timed end to end, on the same machine with the same workload. Until then: set your reasoning level, change your context window, and stop watching the clock.
Permalink