A new iteration of Qwopus3.8-27B-Flash is now available:
Qwopus3.8-27B-Flash-V2
Rather than rebuilding the model from scratch, V2 continues the original Flash direction: preserve strong reasoning and coding capability while reducing unnecessary computation and making the model more practical for long-running agent workloads.
But before getting into the V2 changes, there is one important feature of Qwen3.8 that is worth highlighting: reasoning effort is no longer simply “thinking on” or “thinking off.”
From Qwen3.6 thinking mode to Qwen3.8 reasoning effort
One of the more interesting changes between Qwen3.6 and Qwen3.8 is in the chat template.
With Qwen3.6, reasoning control was primarily binary:
enable_thinking = True / False
Thinking could be enabled for reasoning-heavy workloads or disabled when lower latency was more important. preserve_thinking could additionally control whether previous reasoning traces were retained across turns, which is especially useful for agents.
Qwen3.8 extends this idea with three reasoning-effort levels:
low
medium
xhigh
with xhigh being the default. In updated templates, high can also be accepted as an alias and resolved to xhigh.
This is not three different model checkpoints, nor is it a strict token-budget mechanism.
The control happens at the chat-template level.
What is particularly interesting is that the reasoning levels are implemented through very simple natural-language instructions injected into the system context.
For low reasoning effort, the template uses:
Reasoning effort is set to low. Keep your thinking brief and focused,
moving directly to the conclusion without unnecessary elaboration.
The intention is straightforward: discourage unnecessary deliberation and push the model toward a shorter reasoning trajectory.
For the highest reasoning level, xhigh (high may be mapped to xhigh), the instruction essentially tells the model to reason carefully, validate important assumptions, consider plausible alternatives, and prioritize correctness and consistency before answering:
Reasoning effort is set to xhigh. Think carefully, validate key assumptions,
consider plausible alternatives, and prioritize correctness, consistency,
and clarity in the final answer.
medium is slightly different.
There is no additional reasoning instruction injected for medium. Instead, the template leaves the amount of reasoning largely to the model itself.
Conceptually:
low
→ explicit prompt encouraging short and direct reasoning
medium
→ no additional reasoning prompt; model decides naturally
xhigh / high
→ explicit prompt encouraging deeper validation and deliberation
This is an important detail because reasoning effort here is fundamentally a soft behavioral control through prompting, rather than a hard token budget.
The model is not technically prevented from thinking for a long time in low, nor is it forced to consume a fixed number of reasoning tokens in xhigh.
Instead, the chat template changes the model's prior behavior by modifying the instruction context before generation.
That distinction is particularly useful for agent systems. A difficult debugging task may benefit from xhigh, while routine edits, classification, or simple tool calls can often use a lower effort level.
The important metric for an agent is not just benchmark accuracy or tokens per second.
It is often:
How much useful work is completed per generated token and per second of wall-clock time?
Why Qwopus Flash focuses so much on reasoning efficiency
A normal chat interaction might invoke a model once.
An agent can invoke it dozens or even hundreds of times:
Read
→ Think
→ Tool Call
→ Observe
→ Edit
→ Test
→ Repeat
A small amount of unnecessary reasoning in one generation becomes much more expensive when multiplied across an entire agent trajectory.
That was one of the original motivations behind Qwopus3.8-27B-Flash: preserve enough reasoning capability for difficult tasks while reducing ineffective reasoning and improving practical inference efficiency.
V2 continues the same objective, but changes how the model is post-trained.
What changed in Qwopus3.8-27B-Flash-V2?
V2 is post-trained from the previous Qwopus3.8-27B-Flash, rather than directly restarting from Qwen3.8-27B.
The original Flash model already inherited a multi-stage pipeline involving high-quality SFT, reasoning-oriented training data, agent trajectories, and reinforcement learning.
For V2, another post-training stage was introduced with revised reward functions and different reinforcement-learning methods.
The objective was not simply:
make the model think longer.
Instead, the optimization target is closer to:
make the model spend reasoning tokens where they actually improve task completion.
This distinction matters because longer reasoning traces are not automatically better reasoning traces.
A model can spend thousands of tokens repeating hypotheses, revisiting already-solved branches, or entering long-tail reasoning loops without improving the final answer.
For an agent, that behavior is especially expensive.
V2 therefore focuses more heavily on completion efficiency, reasoning stability, and avoiding pathological long-tail trajectories while retaining the capabilities learned by the original Flash model.
Python formatting was another major target
One of the most useful outcomes of community testing on the first Flash release was the discovery of a Python indentation failure mode.
Certain generations could produce structurally correct Python logic while using malformed indentation, particularly in nested blocks.
This was important because coding benchmarks that focus mainly on semantic correctness may fail to expose formatting problems that make generated code impossible to execute.
The investigation suggested a possible training-side explanation.
Some reconstructed reasoning traces in the training mixture may have contained malformed Python formatting. If a verifier rewarded the semantic trajectory without reliably rejecting the formatting defect, reinforcement learning could unintentionally strengthen that behavior.
V2 was therefore developed with this failure mode specifically in mind.
In the reported local Python-formatting evaluation, the issue was substantially reduced under the recommended coding configuration.
The current recommendation for coding and agentic software-engineering workloads is:
enable_thinking = True
reasoning_effort = "xhigh"
temperature = 0.3
top_p = 0.95
top_k = 20
An interesting observation from local testing was that reducing the coding temperature to 0.3 did not simply stabilize formatting — it also reduced average reasoning length compared with a higher-temperature configuration.
For coding workloads, this combination appears to provide a better balance between deliberate reasoning and deterministic output structure.
These are still local results rather than a guarantee that every Python generation will be correctly formatted, but they provide a useful deployment starting point.
Capability was not sacrificed simply to shorten reasoning
The Flash objective has never been “shortest answer wins.”
A shorter reasoning trace only matters if the task is still solved correctly.
For the V2 evaluation, 2,500 questions were sampled from MMLU-Pro rather than running the complete benchmark.
On this 2,500-question subset, Qwopus3.8-27B-Flash-V2 achieved 92.33% accuracy, compared with 91.28% for the earlier Qwopus Flash evaluation and 92.73% for the reported Qwen3.8 base result.
Because this evaluation uses a sampled subset rather than the complete MMLU-Pro test set, and because the compared results were obtained under different evaluation configurations, these numbers should not be interpreted as a perfectly controlled full-benchmark A/B comparison.
What they do suggest is that the second round of post-training did not require collapsing the model's general reasoning capability simply to make inference more efficient.
The existing agentic software-engineering evaluation also remains an important part of the project: the reported 14-task hidden-test battery was completed successfully, with tasks evaluated through deterministic verifiers rather than an LLM judge.
The broader idea behind V2
Qwen3.8's reasoning-effort system points toward an increasingly important direction for local reasoning models.
The question is no longer only:
How intelligent is the model?
It is also:
How much reasoning should the model spend on this particular task?
For a local model running inside an agent, IDE, research pipeline, or autonomous coding loop, inference efficiency becomes part of model capability.
A model that reaches the same correct result with less unnecessary deliberation can often complete an entire workflow faster, use less GPU time, and support more concurrent workloads.
Qwopus3.8-27B-Flash-V2 is another experiment in that direction:
strong reasoning when it is needed, less wasted reasoning when it is not.
The model is available on Hugging Face as:
Qwopus3.8-27B-Flash-V2-GGUF
with GGUF builds also available for local inference.
Feedback from different hardware, quantizations, reasoning-effort levels, coding workloads, and agent frameworks is very welcome.
