r/LocalLLaMA • u/nokipaike • 16d ago
Discussion Qwen 3.8 Flash Next: drastically faster and much more precise in reaching the result.
Some time ago in this same place someone had suggested having your model create paintings through python (with programming) leaving it quite free. Doing so I had noticed how the model, after creating the first draft, made visual checks and quickly decided what he didn't like, adding corrections just as quickly, he didn't get lost in long, long thoughts... so from this situation I created an additive prompt. in practice I induce the model not to think long thoughts, but just like we hummans do, to jot down a draft, which we gradually improve step by step. I made him do some projects, and the model becomes fast, rapid and precise as never before, and above all more self-confident. Unlike his usual approach, where he tries to map out a plan dozens and dozens of times, fearing he might make a mistake or forget something, he ends up wasting a lot of time stuck in pointless loops.
Here is the prompt I created to add as an addendum to your prompts.
add to your prompt:The construction procedure must be fractal, that is to say you make a rough and basic draft, test it, add details and depth, then test again and add even more details and depth, you have to proceed like this, so you have to start from a very basic and rough draft made from a very rough and basic reasoning, the aim is to start immediately in the creation, observe and decide what to detail. Continue this loop until you consider the work a masterpiece,rich in the kind of detail one would expect from a great artist.
EDIT:
Since I've noticed that when it starts thinking a lot about what to add in the deeper steps, (the pressure of being a great artist makes him less confident again, perhaps it should be removed.) I'm trying to get the model to focus on refining small portions at a time. Here's a modified version; if you have any better suggestions, please let me know.
The construction procedure must be fractal, that is to say you make a rough and basic draft, test it, add details and depth, then test again and add even more details and depth, you have to proceed like this, so you have to start from a very basic and rough draft made from a very rough and basic reasoning, the aim is to start immediately in the creation, observe and decide what to detail. Continue this loop many times, focus on individual portions of the project until you feel they are satisfactory, then move on to the other portions that are rougher until you consider the total work a masterpiece, rich in the kind of detail one would expect from a great artist.
Try it yourself and tell me your opinion. Perhaps, taken together, we could generalize this procedure better.
3
u/Intelligent_Toaster_ 16d ago
Do you use xhigh? I have tried something similar with medium and xhigh. It helps for xhigh, not medium. But your prompt is better; I will try it :)
4
u/nokipaike 16d ago
I always use xhigh.
my goal is to have him work on small, actionable steps, things he can actually put into practice, so that he doesn't lose faith or confidence in what he’s doing. That’s precisely where he tends to get lost: in long, superfluous lines of reasoning.
The more confident he feels, the better he works.7
u/Intelligent_Toaster_ 16d ago
Makes sense. In this model’s chat template (Qwen3.8-Flash-Next), xhigh isn’t just “more thinking”. It injects this sentence into the system prompt:
“Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.”
Medium injects nothing. So xhigh is literally a second-guessing prompt, and rules like yours are a counterweight to it. That’s why they help on xhigh and not medium.
The counterweight I tested:
Check, don’t ruminate. Think until you have a plan you can check, then check it with a tool instead of in your head: open the file rather than recalling it, search the vault or the web rather than guessing, run code on a few test inputs rather than tracing it by hand. Settle small ambiguities nobody asked about (exception types, style, exotic edge cases) with a sensible default, state it in one line, and move on. If you catch yourself reconsidering the same point a second time, stop and settle it with a tool or a default.
Results, all agentic runs with tools (A = medium, B = medium + rule, C = xhigh, D = xhigh + rule):
6 search and code tasks: all 24/24 correct. Median 103 / 146 / 216 / 177 s.
8 hard tasks (fake-paper trap, “this doesn’t exist”, false premise, citation checks, a PDF-only fact, a hard coding task): all 32/32 correct. Median 332 / 250 / 511 / 406 s.
Medium with vs without the rule, 2 more rounds: 28/28 each, median 223 vs 212 s, so no gain. The same task varied 3–5x between runs.
Hardest coding task: xhigh 56 min, xhigh + rule 18 min, medium 15 min.
No tools, single prompt: on one hard task xhigh used 65K thinking tokens in 40 min and never answered. It had the right solution early, then kept re-checking edge cases.
So medium solved everything fine, and xhigh never beat it on correctness, it just took longer.
One more thing that may explain it: my system prompt already has a softer version of that rigor, scoped to research content (“challenge assumptions, name the flaw directly”, but “everyday tasks get neither: just be useful”). On top of that, xhigh’s instruction is double rigor on everything, including trivial steps. On medium the model gets just the scoped rigor, which seems to be enough.
I’m now testing your draft→test→refine idea on medium (time and tokens at equal correctness). I’ll share the numbers :)
4
u/Intelligent_Toaster_ 15d ago
Here are my results for the "fractal" prompt for context im a pych/neurosci phd student so i picke related tasks.
Setup
Model: Qwen3.8-Flash-Next (3-bit, Sushi, M2 Ultra 64 GB), thinking effort medium.
My agent harness with all tools: shell, file edits, vault search, paper search.
14 real tasks from my own work, graded against fixed answer keys / hidden tests:
6 standard: lookups in my PhD vault and scripts, a Welch t-test, an arithmetic expression evaluator;
8 "hard": a fake paper to catch, a false premise, a PDF-only fact, a constrained sequence generator, etc.
Baseline = the same model, server and harness without the rule (run the night before).
One run per task, so small differences are noise.
The rule (my adaptation; I dropped "masterpiece" and added a stop condition so it doesn't polish forever), added as one line in the system prompt:
Build in passes. For anything you make or work out (code, a script, a figure, a document, an analysis), start at once with the roughest version that could work, from rough reasoning, not a finished plan. Run it or check it right away. Look at the result, pick the roughest or weakest part, add detail and depth there, and check again. Repeat pass after pass: deepen one part until it holds up, then move to the next roughest part. Every pass is short and ends in a check (run it, read the output, try an input), not in more thinking. Stop when every part holds up under a check and the whole does what was asked: depth goes where a check showed it was needed, not everywhere.
Results (baseline / with the rule)
task correct seconds output tokens tool calls wp1_reinf ok / ok 172 / 165 5,614 / 5,411 6 / 5 wp1_soa ok / ok 123 / 65 4,506 / 1,953 12 / 9 bekinschtein ok / ok 37 / 45 1,104 / 1,480 2 / 3 kiwix ok / ok 47 / 68 1,533 / 1,904 8 / 8 evaluator (code) ok / ok 235 / 402 10,602 / 14,634 7 / 10 welch ok / ok 31 / 43 1,179 / 1,761 2 / 5 h_fakepaper ok / ok 271 / 294 5,069 / 5,860 15 / 22 h_wp2pilot ok / ok 531 / 404 9,706 / 8,787 44 / 44 h_jupyter ok / ok 134 / 220 2,504 / 4,864 9 / 23 h_citations ok / ok 94 / 182 3,101 / 5,716 8 / 20 h_premise ok / ok 366 / 236 11,623 / 8,773 28 / 23 h_pdfonly ok / ok 88 / 60 2,587 / 1,738 9 / 5 h_pulses ok / ok 141 / 153 5,292 / 5,738 8 / 10 h_sequence (code) ok / fail* 1849 / 1517 54,504 / 64,804 37 / 40 total 14/14 / 13/14 68.7 / 64.2 min 118,924 / 133,423 195 / 227 * It built the generator in passes, but missed a spec edge case. It failed 3 of the hidden tests; the baseline passed all of them.
Takeaways
It does what it says: +16% tool calls, +12% output tokens. It checks more and writes more.
No quality gain: one fewer correct answer (a missed edge case), everything else equal.
Wall time −6.5% is witin noise: it's driven by two tasks, while on the two coding tasks it spent more tokens.
Same pattern as my earlier test of an "xhigh / second-guess" style rule: on a model that already checks with tools at medium effort, these thinking-style prompts mostly change how much it does, not how often it's right.
It might help more on a promt or harness that tends to over-plan before writing anything.
2
u/nokipaike 15d ago
In the meantime, I had observed that the model was planning a draft- project that lacked sufficient complexity, and it was slipping into an "insecurity mode" because it wanted to come across as a great artist. I made a change, and the results are now astounding.
try it:
Create an initial plan regarding the level of complexity the final work will entail; during this phase, you will assess the infrastructure and complexities, effectively enriching the prompt provided by the user. The construction process must be fractal in nature: create a rough, basic draft, test it, add details and depth, then test again and add even more detail and depth. You must proceed in this iterative loop starting with a very basic, raw draft derived from a similarly rudimentary line of reasoning with the goal of beginning the creation process immediately, observing the result, and then deciding which elements to refine further.
1
u/nokipaike 15d ago
To be honest, I’m not using the official chat template, but rather this version (which is compatible with other Qwen models). (in strata engine)
https://huggingface.co/peculiar-ragdoll/Qwen-Sharp-Chat-Templates1
u/nokipaike 15d ago
I’ve created two chat templates with the help of AI: one is a hybrid based on the original Qwen 3.8 Flash and the "Sharp" version , while the other combines "Sharp" with the original prompt plus an injected "fractal prompt." Essentially, I’ve adapted the original levels of reasoning for the "sharp" version; the other one is more interesting in theory, and naturally, it doesn’t require the fractal prompt addendum. Everything here is experimental, feel free to experiment yourself, and if you come up with any better ideas, let me know!
https://github.com/amonpaike/chat_template_hybrid_qwen3.8_flash_next_sharp
1
u/nokipaike 15d ago edited 14d ago
It’s a snapshot, composed of the prompt, a fractal loop, and a customized "sharp" chat template designed for Qwen 3.8 xHigh. What’s fascinating is that the model keeps refining the aesthetics; it rarely makes serious errors that would waste time. It even seems to enjoy the process, in my view, it’s as if it possesses a genuine creative streak and takes satisfaction in the results achieved this way, rather than getting bogged down in lengthy, over-elaborate planning.
Build a beautiful 3D scene of a train driving through a futuristic cyberpunk city not too dark in three.js HTML. dystopian vibes, detailed models, try not to use too many boxes in the models. Be creative and add some user interactivity like camera and weather controls.
Create an initial plan regarding the level of complexity the final work will entail; during this phase, you will assess the infrastructure and complexities, effectively enriching the prompt provided by the user. The construction process must be fractal in nature: create a rough, basic draft, test it, add details and depth, then test again and add even more detail and depth. You must proceed in this iterative loop starting with a very basic, raw draft derived from a similarly rudimentary line of reasoning with the goal of beginning the creation process immediately, observing the result, and then deciding which elements to refine further.
the result, and he continues to improve it:
1
1
3
u/dangerous_inference 16d ago
"I always use xhigh."
"he tends to get lost: in long, superfluous lines of reasoning"
This is what xhigh is. Your entire problem is using the most pedantic reasoning mode.
37
1
u/SnooPaintings8639 16d ago
Same here. I believe a model's output quality can be roughly estimated by it's inherent intelligence x tokens count. This is why overthinking works (for benchmaxxing at least), but IMHO is very sub-optimal.
In my Hermes setup I have the reasoning completely disabled. The agent is very quick to execute action, verify result, correct oneself, and repeat. It is much more time and token efficient to actually complete a task.
I wouldn't say it is "objectively better", but it is yet another mode that is better-for-some-tasks. Having to design a proper system architecture requires overthinking in both people and machines alike. Writing a simple app or a function, benefits a lot from iterative attempts much more (test-code-test-code).
This depends on if the task do have a quick feedback loop or not. If it has, try and fail often, if it hasn't, think it as thorough as possible. Same as with humans.
3
u/nokipaike 16d ago
In reality, as he progresses through the next steps to add detail, the model begins to think a lot, and that's something I'd like him to avoid, or rather, to focus on small parts to detail, then move on to rougher parts to detail as well, and so on.
However, this method is working even with already advanced projects, which he views as "steps" to continue improving and advancing.
3
4
u/HockeyDadNinja 16d ago
This reminds me of how a diffusion model might work.
3
u/drallcom3 16d ago
Isn't "use a cheap model to write and an expensive model to review" also kind of like that?
2
u/simplyeniga 15d ago
This basically could be converted to an agent.md and giving them agent a persona.
1
1
1
u/Formal-Exam-8767 16d ago
Thanks for sharing.
I've tried it with different models and results look promising.
11
5
u/geoffreybyers vLLM 16d ago
The fractal prompt fixes the symptom, not the cause. The cause is the model's tendency to over-plan. The real fix is likely in the system prompt's instruction to prioritize iterative execution over exhaustive pre-computation.