Up to 70tok/s Qwen3.8-Flash-Next-Int4-AutoRound

It’s incredible! I was reviewing my posts from April when I first setup my GB10 and it looked like I was reading a 10 year old post because of the restuls we were getting :) Kudos to the Qwen team for this model and this amazing community that taught me a lot throughout this journey, yourself included !

BTW, keep an eye here: Swift 1.5 Qwen3.8-Flash-Next : 63.4% fewer thinking tokens - #19 by azampatti I’m now wrapping up testing after 24hours of torture tests, this fine-tune might be a fun to try as running this head at xHigh thinking should be about the same tokens than my original at medium but with increased quality.

Stay tuned!

Swift1.5 version posted. It’s a patch that runs on top of this project, so if you’re already using my model, this is just an extra 3GB download

More options for those who like to try it. This Swift Variant defaults to xHigh thinking effort.

Me testing the jev mode on this model…

What the hell is that prefill…

Prefix Caching in action :) That’s it.

@azampatti Anything useful in this one?

GitHub - myllmbox/qwen38-flash-next-recipe: qwen38-flash-next recipe for solo GB10 · GitHub

2,700 PP and .57 TTFT is blazing fast, but is this because v30 vLLM and their hybrix MTP 3-7 setting?

vr8vr8 on X: “Dynamic MTP depth: very good on paper, still good in practice” / X

I’ll add it to my list. There are SOO many new engines/optimizations and versions out there that it’s hard to keep up :)

This test, though, should be pretty straight forward and I might get this version running with my model by tomorrow (I’m flying out tonight, so I might take a bit longer) and a quick test should tell me very quickly if it’s better or worse.

I’m still testing the latest b12x because that one is really way faster, but still spits garbage after a few minutes (probably QSA issue). I know that Eugr is working on that and I provided him with a repro scenario.

I’m mentioning this just so you’re aware that there are issues out there and it’s always good to have a longer scenario (20-40 mins) to test with. Just so you know, last night I did a 5-hour non-stop single-prompt validation test on a slight tweak I made to the recipes, and it output a perfect result. That’s the slowest part of validating a new image.

Perfectly understand that issue, I changed b12x version to MTP=3 and corrected 95% of them and now my harness recognizes the bad output and resubmits an optimized prompt, allowing for 30-90 minute with 100% completion.

5 hours - wow :-) Have a safe trip.

I just give it a more detailed look and that’s TP2 for 2700 PP which should be in the ballpark of what my recipe gets and he’s getting that with my model, which makes sense @vr8vr8

I would have to run a side-to-side but it might be a wash. Dynamic drafting is interesting and I looked into it a few weeks ago but it didn’t work well then. But in the ideal world you would draft 2 or 3 tokens for prose and 6 or 7 tokens for code. That’s the best of both worlds together, so that might buy some performance.

Think you might want to check out myllmbox v5.2 — they seem to be onto something. That’s our highest score to date, with the fewest fails to date: 96/100, held across two independent full runs



The v30 vLLM in their image myllmbox/qwen38-flash-next-vllm:v5.2 (22.2 GB) is a little lighter than @eugr b12x build. I ran a clean pure-docker-to-docker test, matched line-for-line to our live production config (recipe set to MTP=3, same pinned weights, no re-download):

  • 96/100, same median turn as production, and notably: zero safety-critical failures in both runs — a tool-sequencing scenario that fails on our current stack passed on theirs, twice.
  • The whole prefill path jumped: first-token latency ~20–25% better on short prompts, and long-prompt TTFT (4k/8k context) improved 20–28% — consistent with their advertised ~2,700 tok/s prefill claim. Decode throughput ~3% lower — a fair trade for the faster first token, especially on long-context work.

I also ran his full recommendation (MTP=7 dynamic draft depth + everything else as shipped): results came in off (92/100, slower). Re-tested with just the engine/method, fixed depth in — nearly identical to the runs above. So the win here is v30 + their engine patches, not the dynamic-depth feature. Worth a look…

Full recipe we ran (recipe.yaml, everything else exactly as shipped in v5.2 — our edits are in the vllm: section, marked ✏️):

server:
  image: myllmbox/qwen38-flash-next-vllm:v5.2     # vLLM 0.30.0 + their patches (RecoverSSM, table reader, MTP draft)
  docker_args: --security-opt seccomp=unconfined
  cpuset: "5-9,15-19"                             # GB10 X925 cores only
  model: azampatti/Qwen3.8-Flash-Next-125B-A5B-INT4-AutoRound   # pinned to revision 14642741…
  port: 8000
  models_dir: ./models
  cache_dir: ./cache                              # ~52G table map on first boot

env:
  MBX_PLE_MMAP: "1"
  MBX_PLE_MMAP_MODE: "nvme"
  MBX_PLE_MMAP_PREWARM: "0"
  VLLM_USE_BREAKABLE_CUDAGRAPH: "1"
  PYTHONUNBUFFERED: "1"
  VLLM_MARLIN_USE_ATOMIC_ADD: "1"
  TORCH_CUDA_ARCH_LIST: "12.1a"
  FLASHINFER_CUDA_ARCH_LIST: "12.1a"
  MALLOC_MMAP_THRESHOLD_: "65536"
  MALLOC_TRIM_THRESHOLD_: "131072"

vllm:
  served-model-name: qwen3.8-flash-next            # ✏️ was Qwen/Qwen3.8-Flash-Next — set this to match YOUR client id or it breaks
  engram-config: '{"cpu_offload": false}'
  gdn-prefill-backend: triton
  moe-backend: marlin                               # (run.sh drops this automatically for INT4-AutoRound)
  distributed-executor-backend: mp
  gpu-memory-utilization: 0.70
  kv-cache-memory: "27000000000"                    # INT4-AutoRound profile: run.sh rewrites to 24G
  load-format: fastsafetensors
  max-model-len: 262144
  block-size: 16                                    # ✏️ was 1632 (that's their K=7 sizing; correct for fixed K=3)
  compilation-config: '{"cudagraph_mode":"PIECEWISE","cudagraph_capture_sizes":[1,2,3,4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64],"compile_ranges_endpoints":[32]}'
  max-num-seqs: 16
  max-num-batched-tokens: 8192
  enable-prefix-caching: true
  enable-auto-tool-choice: true
  tool-call-parser: qwen3_coder                     # ✏️ was qwen3_xml — matched to our fleet parser
  reasoning-parser: qwen3
  chat-template: ".../medium_chat_template.jinja"   # ✏️ pinned our production template
  speculative-config: '{"method":"mtp","num_speculative_tokens":3,"rejection_sample_method":"block","draft_sample_method":"probabilistic"}'
                                                    # ✏️ fixed K=3, not dynamic 3..7
  async-scheduling: true
  use-replayssm: true

mtp_depth:
  mode: off                                         # ✏️ was dynamic — this is the change vs his shipped default

Launch is just:

git clone https://github.com/myllmbox/qwen38-flash-next-recipe.git && cd qwen38-flash-next-recipe
# apply the edits above, then:
./run.sh        # first boot builds the ~52G table map (few extra minutes, once); healthy ~4 min

Tip if you run it: set served-model-name to whatever id your clients expect (see above — ours broke until we aligned it).


Would you happen to have a --hardmode --seed 42 result to compare?

Tried the Swift build but I found it below the ideal speed and at least for my use case, the xHigh from medium thinking effort change didn’t affect the output much but the overall responsiveness due to the thinking was a bit slower. So I went back to the non-swift build.

IMPORTANT - Bug fix!

TLDR : In some circumstances, running multiple parallel sessions will lower the MTP acceptance to 0 and slow everything the heck down.

git pull && ./eugr-setup.sh

And restart vLLM, and you should be all set. If you want to learn more, read here :)

@azampatti I’ve moved on to Deepseek-4.1-Flash – when are you going to refocus your energy on that? :)

Hi @azampatti - thanks for your work on this, it’s incredible!

I was wondering if you had the original 16 bit version of your adjusted model that could be quantised to other formats so it could be used with harnesses other than vllm? I was thinking of both veloGB10 and Strata - I guess this would mean making the bf16 version of your model available if possible/you can/want to/etc… and then letting other people quantise it into these other formats?

Thanks again.

Repeatable results, up to hard mode tool calls.


The new 2 partials and 3 fails compared to the above are in the hard mode calls.

My tp=2 is out pp is ~4k for your quant and got peek of 177 on c=1 GitHub - myllmbox/qwen38-flash-next-cluster-recipe: qwen38-flash-next recipe for tp=2 GB10 · GitHub

I know it’s not rtx6k thread but if anyone wants to try it out… GitHub - technigmaai/qwen3.8-flash-next-int4-rtxpro6000-tp1: Qwen3.8-Flash-Next AutoRound INT4 on NVIDIA RTX PRO 6000 Blackwell 96GB: vLLM TP1, 512k, MTP3, FP8 KV and enforced tools · GitHub @azampatti great work with the model :) thanks TAI

Hey, for all of those who are using other launchers, please try this Qwen3.8-Flash-Next-Int4-FAST/tools/mtp_drafter_check.sh at main · azampatti/Qwen3.8-Flash-Next-Int4-FAST · GitHub

That will check if you have the MTP bug (with any model) that might impact concurrent sessions when running prefill/decoding at the same time.

i have it… And the fix (eugr-setup) did the trick! Thanks!

Well done, @azampatti !! I used the swift patch and its amazing! Now, xhigh is my new default. The leap in intelligence is incredible without the mind-numbing overthinking.

I was doing some tests… and i cut part of the model off… so i started some benchmark without MTP…