How was the Qwen Flash Next benchmark collected?

From 10 posts and 260 comments on r/LocalLLaMA sampled over the past month window.

Which categories does the Qwen Flash Next report score?

Intelligence, Speed, Coding quality, Instruction following, Long context, Price / value, Reliability & uptime, Creativity & writing, Multimodal & vision, Agentic & tool use.

What are the main community pros and cons for Qwen Flash Next?

Top pros: Consistently rated above Qwen 3.8 27B on reasoning at comparable or even lower precision ("Q4 is definitely better than 27b at Q8 in my experience", u/DigitalguyCH, 107 points).; Best-in-class fit for bandwidth-constrained unified-memory machines (Mac, Spark, Strix Halo, AMD Max, CMP cards) where it is often both smarter and faster than 27B.. Main cons: Slow or uncompetitive in llama.cpp during the sample window: missing MTP support, roughly 400 tok/s prefill versus 1200 tok/s in Halogen or pwilkin's fork, and reported decode of 8-30 tok/s on some rigs.; Poor long-context scaling for several users - "scales badly with large context" (u/SnooPaintings8639) and generation dropping from 38-40 t/s to ~18 t/s near 250k tokens (u/H_DANILO)..

When was the Qwen Flash Next data collected?

Collected on September 27, 2026; the report was generated on September 28, 2026.

r/LocalLLaMA · past month

Qwen Flash Next

Community sentiment from 10 posts · 260 comments · collected September 27, 2026 · generated September 28, 2026

Qwen Flash Next scores 63/100 overall in the r/LocalLLaMA community benchmark, collected September 27, 2026 from 10 posts and 260 comments. Its strongest category is Intelligence at 78/100, and its weakest is Creativity & writing at 45/100.

63/ 100

Confidence: medium — 260 comments across 10 posts collected over roughly one month (2026-09-01 to 2026-09-27) give a decent but skewed picture. Three limitations lower the confidence. First, the sample is dominated by head-to-head comparisons against Qwen 3.8 27B on specific machines, so most numbers are anecdotal, self-reported tok/s figures with no shared benchmark protocol; u/mechkbfan makes this point himself - "there's so many other factors like harness, agents.md, are people one shotting or providing a detailed spec.md". Second, hardware bias is strong: unified-memory Apple, Spark and Strix Halo users are over-represented relative to pure GPU owners, and three of the ten posts are llama.cpp PR-news threads with only 12-20 comments, plus one hardware post (CMP170HX) where the model is mentioned only in passing. Third, the serving software was changing weekly during the window, so speed and reliability scores describe a snapshot that later builds likely improved. Multimodal vision could not be scored at all because no participant evaluated it.

Category scores

Intelligence 78: Most of the sample judges Flash Next against Qwen 3.8 27B rather than against frontier models, and on that axis it usually wins. The top-voted answer in the Q2/Q4 thread states "Q4 is definitely better than 27b at Q8 in my experience" (u/DigitalguyCH, 107 points), u/CoffeeToCode99 calls it "the better model overall", and u/loadsamuny describes one quant as "a good amount better than 27b, much more aware and intelligent". u/Proper-Damage-1777 reports it "managed to brute force it way to extract game sprites from a Japanese PS1 game in one day" where 27B got stuck in a rabbit hole. The dissent is loud and quant-related: u/Ok_Replacement2229 (98 points) "went back to 3.8 27b" because it "seems stupider and is slower than q8 3.8 27b", u/grumd saw INT4 "missed a few bullet points of the task here and there", and u/Heathen711 measured better Python output from 27B in less wall-clock time on MLX. Domain limits are also flagged: the OP u/Zeeplankton says Qwen is "abysmal at say, writing, or arguing anything substantial" and "completely saturated with code / maths", and u/Big_Wave9732 reports it "hallucinates cases and statutory authority" in legal work.
Speed 58: Speed opinions split almost perfectly along hardware lines. On bandwidth-bound unified-memory boxes it wins: u/my_name_isnt_clever says it is "basically perfect" on Strix Halo and "much faster" than 27B, u/Durian881 reports it "runs faster" on an M3 Max 96GB, u/_w0n and u/PrettyMuchAVegetable say the same for Mac and Spark, and u/walden42 quotes "10k prefill and 140tg/s, which is much faster than 27B" with sglang on an RTX Pro 6000. On everything else it often loses: u/SnooPaintings8639 says "flash next starts at half the PP speed of it's smaller cousin" and "scales badly with large context" making it "a chore to use under Hermes", u/Proper-Damage-1777 measures "~25-40t/s versus ~60-70t/s" versus 27B, and u/specify_ saw only "20 tokens/sec decode" in a CPU+GPU hybrid setup. The recurring technical reason given by several users (u/SpicyWangz, u/audioen, u/karmaisnonsense) is runtime maturity: "flash next doesn’t support MTP yet" in llama.cpp and vanilla llama.cpp delivers "a small fraction" (about 400 tok/s prefill) of what Halogen or pwilkin's fork reach (1200 tok/s). A stream of merged llama.cpp PRs summarised by u/Chromix_ shows double-digit percent gains still landing during the sample window, so the number reflects a moving target rather than a fixed property.
Coding quality 76: Coding is where the model is praised most concretely. u/SnooPaintings8639 says "I take Q4 of Flash Next when I need to code or analyze something hard, in my experience it is much better"; u/Proper-Damage-1777 credits it with extracting PS1 game sprites in a day where 27B looped; u/BoboThePirate finds it "easily 4x as comfortable to use compared to fp8 27b", with "way less thinking" and "limited switchbacks"; u/cezarducatti says it "has solved 100% of my problems" at Q3 XL; and u/OvertaxedOne notes that "smarts in the model can be supplemented pretty easily with MCP/tool calling". Reliability criticism tempers this: u/grumd prefers "27B at Q6_K" for agentic coding because it "stays stable, ensures the full list of requirements is done correctly" while Flash Next INT4 "missed a few bullet points" and "looped and exhausted the context window a couple times"; u/Artistic_Okra7288 says "Flash-Next at Q4 isn't reliably beating Qwen3.8-27B at Q3" for instruction-heavy coding; u/DiscipleofDeceit666 reports that "sometimes it’ll just create you a one off script instead of integrating with the rest of your project" and that "you have to steer it"; and u/Heathen711's MLX Python comparison favoured 27B on equal-quality-per-second grounds. The overall tone is strong ability with residual instability.
Instruction following 60: Evidence here is mixed and leans negative. The sharpest report comes from u/Big_Wave9732, who says the model "doesn't follow instructions no matter how limited / tailored" and "over analyzes"; u/grumd says it "just missed a few bullet points of the task here and there"; u/Artistic_Okra7288 prefers 27B "for actually following instructions and coding"; u/DiscipleofDeceit666 says that given an existing project it "sometimes it’ll just create you a one off script instead of integrating with the rest of your project"; and u/Zeeplankton reports that in roleplay use "We also ask the model return fairly simple JSON but it starts to ignore this". On the positive side u/BoboThePirate praises "limited switchbacks" in an agent loop, and u/Proper-Damage-1777 finds starting-from-scratch tasks handled far better than by 27B. The pattern in the data is that broad intent is understood quickly (u/BoboThePirate) while fine-grained requirements are occasionally dropped.
Long context 62: The architecture is explicitly aimed at cheap long context: u/Commander_Skilgannon points out that "the whole design of qwen3.8-flash-next is to make long contexts as cheap as possible" with QSA blocks that "are sparse with a blocked indexer so attention compute growth is linear and almost flat for 256K tokens", and users do run very long windows in practice ("196k context" from u/No_Lingonberry1201, "250k on 68G of vram" from u/loadsamuny, "240k context" from u/while-1-fork, 262144 max-model-len in u/Miserable-Dare5090's vLLM command). Real-world behaviour is rougher: u/SnooPaintings8639 says it "scales badly with large context", u/H_DANILO reports "start at 38-40tg, ends at about 18tg close to 250k context", u/segmond calls a build a "regression nightmare", and u/Chromix_'s PR summary lists open llama.cpp bugs including "CUDA abort at 262k KV" and "cross-sequence KV pooling under --kv-unified". The u/Zeeplankton thread also shows severe degradation after ~120-140 messages of summarised conversation, although u/quietgradient argues that is distribution shift from a half-narrative prompt rather than a context-length limit.
Price / value 72: There is no API pricing discussion in this sample - everyone self-hosts - so this score reflects value per hardware dollar, which the community discusses heavily. u/cibernox calls a two-card CMP170HX box at about "3000$" running this model "the budget king setup for running models below 200B"; u/Ne00n reports "It runs fine with 8GB VRAM and 64GB DDR4"; u/loadsamuny gets "250k on 68G of vram"; u/ubrtnk measures "8200 PP an 75-100 TG with MTP 2" on those cards; and u/OvertaxedOne's framing that "these models are designed for different hardware markets" recurs throughout, i.e. the model gives near-Spark/DGX-class quality to cheap unified-memory machines. The counterweight is that the same hardware class has become expensive during the window (CMP cards going from "Could have bought at $650" per u/OnlineParacosm to "and now they are ~2200" per u/Miserable-Dare5090, while u/WeAreSven draws the line at "$1500 made sense for these cards assuming all of the inherent issues but 2500+ is crazy") and that several users must buy quants, not quality, to fit their VRAM.
Reliability & uptime 48: No hosted-service uptime data appears in the sample (everyone runs locally), so this score covers day-to-day runtime stability, which is the weakest area discussed. Users report concrete defects rather than impressions: u/audioen warns QFN "doesn't work correctly in llama.cpp unless you disable unified KV cache", that the sparse attention indexer can leave the model "unable to perform tool calls because it can't see the tool definitions", and that it "can wedge doing stuff like 'Now do it. Do it. Yes. Finish.'"; u/karmaisnonsense found "KVU and parallelism just straight up broken in llama.cpp"; u/Chromix_'s merged-PR roundup lists open correctness fixes for "silent wrong output via OpenAI `n` param" and "corrupt-GGUF aborts"; u/segmond calls a recent build a "Freaking regression nightmare"; and the dedicated u/pilibitti thread documents "thinking into the air" blocks that u/returnity reproduced across two different inference runtimes. u/Ecstatic-Wash-7667's summary - "flash creates mountains out of molehills" - captures the practical effect. Because fixes were merging weekly during the window, several of these were probably already resolved by later builds.
Creativity & writing 45: Thin but consistently negative. The OP u/Zeeplankton says "Qwen is abysmal at say, writing, or arguing anything substantial" and that it "feels completely saturated with code / maths"; u/XiRw confirms that "people do say it’s not the best when it comes to writing material. You need something like Gemma for that which feels more natural", and u/Atretador reacts to the idea of using it for long roleplay with "I thought that was what people used Gemma4 for". Defenders exist: u/XiRw elsewhere says "Both 3.8 and 3.8 Flash do a great job with other non code related tasks", and u/Striking_Problem_330 finds local Q4 quants "solid enough for my chatbot sessions". Nobody in the sample reports using it as a creative-writing first choice, hence the low mark rather than a null.
Multimodal & vision no data: No data in the sample — there is no discussion of the model's image or multimodal quality at all. The only hints that vision exists are indirect: u/while-1-fork mentions "needing to run the mmproj on cpu" (a multimodal projector file), u/wgaca2 says his fork will ship once "dflash2 gets properly merged into llamacpp with vision" and elsewhere explains that it is "not updated since i am waiting for dflash2 fixes", and u/Chromix_'s PR summary mentions an open fix for "image mis-scoring under M-RoPE". None of these constitute user evaluation of multimodal output, so the parameter is left unscored.
Agentic & tool use 58: Agent use is the most actively discussed workload and the feedback is genuinely two-sided. On the positive side u/BoboThePirate reports "way less thinking, arriving at correct answers soon, limited switchbacks", u/Kiseido runs a memo/truncation harness "with qwen3.8 next since the model came out" and finds "the model seems to stay coherent the vast majority of the time", and u/OvertaxedOne notes tool calling requires less quantisation precision than other work. On the negative side, tool-call reliability is specifically implicated: u/pilibitti's thread documents the model thinking "into the air" right after a tool call, u/returnity attributes it to the QSA "context anchor" resetting after each tool call, u/audioen ties it to the unified-KV-cache indexer bug that leaves the model "unable to perform tool calls", u/grumd says it "looped and exhausted the context window a couple times", and u/specify_ dropped it because the throughput was "too slow for my multi-agentic needs". Concurrency is also limited in practice: u/Refefer stays on 27B because with Flash he "can't spin up 4-5 agents concurrently with the available kv cache".

Summary

Qwen Flash Next (referred to in the threads as Qwen3.8-Flash-Next / QFN / qwen4exp) spent this month as the de facto reference "big local model" on r/LocalLLaMA, and almost every discussion frames it as a head-to-head with Qwen 3.8 27B rather than as an absolute benchmark. The dominant thesis, stated most cleanly by u/OvertaxedOne (68 points), is that the two are aimed at different hardware: Next suits memory-bandwidth-constrained machines (Mac, Spark, Strix Halo, AMD Max, CMP boxes) while 27B suits VRAM-capacity-constrained ones (5090, RTX Pro 6000, 170HX). Where the hardware matches, users report it as clearly superior and often faster; where it does not, particularly with llama.cpp during this window, users report it as slower and harder to serve.

Capability sentiment is positive but conditional on quantisation, which is itself one of the loudest debates in the sample. Q4-class quants repeatedly beat 27B at Q8 in user experience ("Q4 is definitely better than 27b at Q8 in my experience", u/DigitalguyCH, 107 points), yet several users insist quantisation damage is real and cumulative: u/PrysmX warns "a Q4 quant is quite destructive to many capabilities", u/sleepy_roger says int4/nvfp4/awq "have performed noticeably worse for me than fp8 and bf16" on long-horizon tasks, while u/GCoderDCoder pushes back that good NVFP4 dynamic quants can score higher than FP8. A second axis of disagreement is domain: multiple users describe the model as code-and-maths saturated, while u/BoboThePirate and u/my_name_isnt_clever report it as comfortable and broadly capable.

Serving maturity, not the weights, drives most of the complaints. During the sample window llama.cpp lacked MTP speculative decoding for Flash Next ("flash next doesn't support MTP yet", u/SpicyWangz), had a broken unified KV cache path that u/audioen and u/karmaisnonsense tie to lost tool definitions and parallel-sequence corruption, and took heavy criticism for slow review of community speed work. Users who switched to sglang, vLLM, Halogen or pwilkin's fork report 3x faster prefill and usable concurrency, and u/jacek2023's recurring "speedup" PR posts show the steady stream of merged optimisations that kept changing the performance picture week to week.

Behavioural quirks define the rest of the negative feedback: "thinking into the air" right after tool calls (reproduced across runtimes per u/returnity), circular reasoning loops that exhaust the context window (u/grumd), dropped requirements when agent coding (u/DiscipleofDeceit666, u/Artistic_Okra7288), and illusion-of-recall behaviour such as inventing user statements or a graph-theory proof mid-session (u/Jorlen, u/Risen_from_ash, u/ZaltyDog). Most of these reporters keep using the model anyway - u/Jorlen's summary of the mood is "I like the model; I'm willing to deal with the quirks" - which is why the aggregate scores land in the solid but not glowing range.

Pros and cons

Pros

Consistently rated above Qwen 3.8 27B on reasoning at comparable or even lower precision ("Q4 is definitely better than 27b at Q8 in my experience", u/DigitalguyCH, 107 points).
Best-in-class fit for bandwidth-constrained unified-memory machines (Mac, Spark, Strix Halo, AMD Max, CMP cards) where it is often both smarter and faster than 27B.
Very long practical context windows reported in real setups: 196k, 240k, 250k and 262144-token vLLM configurations.
Strong from-scratch coding performance, including brute-forcing a PS1 sprite extraction task in a day where 27B looped (u/Proper-Damage-1777).
Broad knowledge advantage over a dense 27B model despite only ~6B active parameters, which several users credit for better decision-making on ambiguous tasks.
A healthy quant ecosystem (Unsloth, ISTA-DASLab, APEX, Swift, Atomic Chat, NVFP4/INT4/AWQ) with per-hardware trade-offs discussed in detail.
Rapidly improving serving stack: dozens of merged llama.cpp and community PRs during the month delivered double-digit prefill and decode gains, plus MTP work in progress.
Fewer reasoning switchbacks and faster arrival at answers in agent loops according to users comparing it with FP8 27B (u/BoboThePirate).

Cons

Slow or uncompetitive in llama.cpp during the sample window: missing MTP support, roughly 400 tok/s prefill versus 1200 tok/s in Halogen or pwilkin's fork, and reported decode of 8-30 tok/s on some rigs.
Poor long-context scaling for several users - "scales badly with large context" (u/SnooPaintings8639) and generation dropping from 38-40 t/s to ~18 t/s near 250k tokens (u/H_DANILO).
Unified KV cache / sparse-attention indexer bugs that can leave the model unable to see tool definitions, produce silent wrong output, or wedge mid-turn.
"Thinking into the air" right after tool calls, with the model narrating a context that does not exist; reproduced across llama.cpp and other runtimes.
Quantisation sensitivity is a recurring complaint, especially below Q4: models with few active parameters "do not tolerate quantization well" per u/Ardalok, and users report dropped requirements, loops and hallucinations at IQ4/Q2.
Weak reputation for writing and argumentation - described as "abysmal" and "completely saturated with code / maths" by the OP u/Zeeplankton, with Gemma-class models preferred for prose.
Concurrency limits hurt multi-agent workflows: users stay on 27B because with Flash Next they "can't spin up 4-5 agents concurrently with the available kv cache" (u/Refefer).
Occasional self-generated recollections (invented user quotes, a stray graph-theory proof) that suggest the model sometimes confuses its own output for input.

Top quotes

“Can't speek for Q2 but Q4 is definitely better than 27b at Q8 in my experience.”
DigitalguyCH · 107 points positive view on Reddit ↗
“I went back to 3.8 27b. Have 96gb VRAM, so not running bigger flash than q4/q5. Seems stupider and is slower than q8 3.8 27b,”
Ok_Replacement2229 · 98 points negative view on Reddit ↗
“IMHO, these models are designed for different hardware markets. Next is for memory bandwidth constrained systems (Mac, Spark, AMD Max).”
OvertaxedOne · 68 points neutral view on Reddit ↗
“I have a 128GB Strix Halo and Q3.8FN is basically perfect for it. I've found it to be better than 27b and much faster on this hardware.”
my_name_isnt_clever · 57 points positive view on Reddit ↗
“If it a topic where I need to start from scratch, Flash Next is wayyyy much better than 27B in the overall reasoning.”
Proper-Damage-1777 · 27 points positive view on Reddit ↗
“Not much contest, to be honest. QFN is extremely good, but it doesn't work correctly in llama.cpp unless you disable unified KV cache for example.”
audioen · 16 points negative view on Reddit ↗
“It over analyzes, doesn't follow instructions no matter how limited / tailored, and straight hallucinates cases and statutory authority no matter how segmented the task is.”
Big_Wave9732 · 16 points negative view on Reddit ↗
“For me 27B at Q6_K feels more robust for long context agentic coding. Just a solid model that does what it's told to do and stays stable, ensures the full list of requirements is done correctly”
grumd · 11 points negative view on Reddit ↗
“It always happens after a tool call, when the context anchor resets for QSA, but it doesn't seem to affect anything -- it always recenters itself with its next tool call”
returnity · 8 points neutral view on Reddit ↗
“96GB vRAM, I take Q4 of Flash Next when I need to code or analyze something hard, in my experience it is much better. But for daily use, I got for 27B due to speed”
SnooPaintings8639 · 6 points neutral view on Reddit ↗
“The QSA attention blocks are sparse with a blocked indexer so attention compute growth is linear and almost flat for 256K tokens.”
Commander_Skilgannon · 3 points neutral view on Reddit ↗
“At least in my experience, Qwen is abysmal at say, writing, or arguing anything substantial. It feels completely saturated with code / maths.”
Zeeplankton · 1 points negative view on Reddit ↗

FAQ

What is Qwen Flash Next's overall community score?: 63 out of 100, with medium confidence: 260 comments across 10 posts collected over roughly one month (2026-09-01 to 2026-09-27) give a decent but skewed picture. Three limitations lower the confidence. First, the sample is dominated by head-to-head comparisons against Qwen 3.8 27B on specific machines, so most numbers are anecdotal, self-reported tok/s figures with no shared benchmark protocol; u/mechkbfan makes this point himself - "there's so many other factors like harness, agents.md, are people one shotting or providing a detailed spec.md". Second, hardware bias is strong: unified-memory Apple, Spark and Strix Halo users are over-represented relative to pure GPU owners, and three of the ten posts are llama.cpp PR-news threads with only 12-20 comments, plus one hardware post (CMP170HX) where the model is mentioned only in passing. Third, the serving software was changing weekly during the window, so speed and reliability scores describe a snapshot that later builds likely improved. Multimodal vision could not be scored at all because no participant evaluated it.
How was the Qwen Flash Next benchmark collected?: From 10 posts and 260 comments on r/LocalLLaMA sampled over the past month window.
Which categories does the Qwen Flash Next report score?: Intelligence, Speed, Coding quality, Instruction following, Long context, Price / value, Reliability & uptime, Creativity & writing, Multimodal & vision, Agentic & tool use.
What are the main community pros and cons for Qwen Flash Next?: Top pros: Consistently rated above Qwen 3.8 27B on reasoning at comparable or even lower precision ("Q4 is definitely better than 27b at Q8 in my experience", u/DigitalguyCH, 107 points).; Best-in-class fit for bandwidth-constrained unified-memory machines (Mac, Spark, Strix Halo, AMD Max, CMP cards) where it is often both smarter and faster than 27B.. Main cons: Slow or uncompetitive in llama.cpp during the sample window: missing MTP support, roughly 400 tok/s prefill versus 1200 tok/s in Halogen or pwilkin's fork, and reported decode of 8-30 tok/s on some rigs.; Poor long-context scaling for several users - "scales badly with large context" (u/SnooPaintings8639) and generation dropping from 38-40 t/s to ~18 t/s near 250k tokens (u/H_DANILO)..
When was the Qwen Flash Next data collected?: Collected on September 27, 2026; the report was generated on September 28, 2026.

Qwen Flash Next

Category scores

Intelligence

Speed

Coding quality

Instruction following

Long context

Price / value

Reliability & uptime

Creativity & writing

Multimodal & vision

Agentic & tool use

Summary

Pros and cons

Pros

Cons

Top quotes

Top sample posts

FAQ

Related models

r/LocalLLaMA — same family