Qwen3.8-27B reportedly went from 82 to 381 tokens/sec on a single RTX 3090 with 24GB of VRAM.
That is a 4.6× increase in throughput without changing the GPU or the model.
Developer TeksEdge achieved this by changing how inference is performed, combining speculative decoding, DFlash2, context lookup and optimized verification.
Here is the reported progression:
Baseline: 82 tokens/sec
Optimized MTP: 114 tokens/sec
DFlash2 + context lookup: 138 tokens/sec
Optimized lookup verification: 381 tokens/sec
The interesting part is that the final improvement did not come from a bigger GPU or a larger model. It came from reducing work the inference engine did not need to perform sequentially or repeatedly.
1. Speculative decoding reduces the cost of generating tokens
Most language models generate output autoregressively. Each new token depends on the tokens that came before it, which makes ordinary decoding inherently sequential.
Speculative decoding changes the process by using a faster draft mechanism to propose multiple tokens at once.
The main model verifies the proposals and can accept several tokens in a single verification step. When the draft predictions are accepted, the system advances through more of the output without repeating the usual sequential decoding process for every token.
DFlash2 is designed to improve this speculative decoding workflow.
However, the speedup depends on how well the draft predictions match the main model’s output, how many tokens are accepted, and how much computation verification requires.
2. Context lookup takes advantage of text the model has already seen
Some generation tasks involve substantial overlap between the input and the expected output.
For example, reproducing a document, copying structured text or transforming code may require the model to emit sequences that already exist in its context.
Context lookup searches for these reusable sequences and proposes them as candidate output instead of requiring the model to generate every token from scratch.
TeksEdge reports processing blocks of up to 16 tokens and accepting roughly 15 tokens per block in its setup.
On a 25,000-token document reproduction task, reported throughput increased from approximately 260 to 382 tokens/sec.
This is a particularly favorable workload for context lookup because the output contains substantial material that can be reused.
Open-ended conversation is different. When the model needs to generate new explanations, ideas or unfamiliar wording, there may be far fewer matching sequences available.
That is why the same optimization can produce very different results across workloads.
3. Faster verification helps unlock the remaining performance
Finding candidate tokens is only part of the problem. The inference engine must still verify them efficiently.
If verification is too expensive, the overhead can erase much of the benefit from speculative decoding and context lookup.
TeksEdge’s reported progression from 138 to 381 tokens/sec after optimizing lookup verification suggests that verification efficiency was a major bottleneck in this particular configuration.
The result highlights an important engineering principle: improving a draft mechanism is not enough if the rest of the inference pipeline cannot process its proposals efficiently.
The reported stages should be viewed as successive configurations, not independent speedups that can simply be multiplied together.
4. Prefix caching solves a different problem: waiting for the first token
Fast decoding does not automatically mean fast responses.
Before generating an answer, a model must process its input. This stage is called prefill, and it can be expensive when prompts contain long instructions, tool definitions or repository context.
Coding agents often reuse the same prefix across multiple requests. Without caching, the engine may repeatedly perform much of the same computation.
David Hendrickson