Have Qwen3.8-27B draw a pelican riding a bicycle, and it may never be able to stop

Asking a model to draw a pelican riding a bicycle is a somewhat absurd long-thinking test in the community. The prompt asks for a complete HTML page with an SVG animation of the pelican pedaling. The task is strange enough, and long enough, to force the model to reason continuously for tens of thousands of tokens in thinking mode. The GGUF quantized version of Qwen3.8-27B exposes the problem here: short chats work normally, but long thinking may never end.

Poster Jerryccccc documented the reproduction process in the unsloth/Qwen3.8-27B-GGUF discussion area on Hugging Face. The test machine had 2× RTX 5060 Ti 16GB, and the models used were UD-Q4_K_XL and UD-Q6_K_XL. thinking was enabled, reasoning_effort was set to xhigh, and temperature was 1.0. The pass criterion was simple: the model should finish within about 15K to 20K thinking tokens and output a working HTML file.

llama.cpp results were not promising. With a 32K budget, UD-Q4_K_XL burned the entire budget in thinking and actually output 0 characters. With a 76K budget, UD-Q6_K_XL did not stop, and in the final roughly 2K characters, 97% were repeated 8-grams. Forcing use of the chat template embedded in the GGUF, i.e. --jinja, still did not terminate.

To rule out a runtime bug, the tester put the same GGUF file on vLLM plus the official vllm-gguf-plugin. The two runtimes share almost no code paths. The result still did not converge: one run returned HTTP 500 after 1325 seconds, with the engine crashing midway at about 30K tokens; another ran for 28 minutes to about 38K tokens, still did not finish, and was finally killed by an outer timeout.

The control group was a mixed-precision quantization of the same 27B model. The NVFP4 checkpoint compresses MLP and lm_head to FP4, keeps attention and Gated DeltaNet layers at FP8 W8A8, and converges in about 17K thinking tokens on SGLang, outputting a complete, usable SVG. Same machine, same prompt, same thinking mode.

The poster clearly labels the hypothesis: this is inference, not proof. Qwen3.8-27B is a hybrid architecture with Gated DeltaNet linear attention. Such models have a fixed-size recurrent state that is updated every time a token is generated. Uniform block quantization multiplies each state transition by a little rounding error. Over a few hundred tokens it is invisible; over tens of thousands of tokens in a chain of thought, the error may accumulate into a degenerate attractor: repeated loops, refusal to finish, or even engine instability.

This hypothesis explains a counterintuitive phenomenon. In the discussion, a commenter cited a quantization comparison table saying NVFP4's KLD is worse than UD-Q4_K_XL's, and even UD-Q3_K_XL's KLD is slightly better. KLD and perplexity are short-context metrics, teacher-forcing a few hundred tokens. They cannot see the drift of the recurrent state over long chains. Hence the inversion: the mixed-precision quantization with worse KLD can think cleanly, while the uniform GGUF with better KLD does not emit an end token within 50K tokens. The poster's response is that aggregate divergence does not say where precision is placed in the recurrent state transition.

Follow-up discussion added quality evidence. Plain UD-Q6_K can converge, but its thinking budget is 1.3 to 1.6 times larger than the mixed-precision control. UD-Q6_K_XL was 0/5 on llama.cpp and vLLM, failing to converge from 45K to 90K, and once crashed the engine. A closer inspection found that in the SVG output by uniform quantization, the fish in the pelican's beak was colored almost the same orange as the beak, so the fish visually merged into the beak; in one AMD Vulkan user's output, the fish was stuck outside a closed beak and was never covered by the throat pouch. There were also anatomical problems: multiple uniform quantization outputs drew human knees on the pelican, with knee bend angles up to 102 degrees, which a bird's tarsal joint cannot do.

There were also counterexamples in the discussion. Commenter jjanovsky got a converging result with 2× 5060 Ti and Q6_K_L, and posted an image. The poster pulled the source code and audited it, acknowledging that the engineering details were decent, but pointed out that the throat pouch of the beak was squashed into a 0.4px line, the leg color was not in the same color family as the beak, and the knees were still in a human riding posture. The counterexample did not overturn the problem; rather, it added a type of damage: the file runs, the hard constraints are still there, and the parts that require understanding what the subject is are degrading.

The impact is not small. Someone in the discussion counted that the 1,157 GGUF repositories for Qwen3.8-27B had 41.6 million downloads in the past 30 days. If long thinking commonly has problems under uniform integer quantization, many people may have run into it without noticing, because short evaluations, perplexity, and KLD are all still green. Someone mentioned that cdiamond's iMatrix-NVFP4-MTP-GGUF is a mixed-precision GGUF that can directly test this argument on llama.cpp, but it requires applying the patch in its recipe directory. Whether MLX 4bit is similarly affected is also queued up for testing.

The practical conclusion is not complicated. When running hybrid models like Qwen3.8-27B on consumer GPUs, if thinking mode matters, prefer official FP8 or NVFP4 mixed quantization over uniform GGUF. If you are locked into the GGUF ecosystem or limited by VRAM, turn off thinking, or set a hard cap on the thinking budget; everyday chat is indeed fine. When screening quantizations, don't just look at perplexity and short-context evaluations. Use a long-range canary, such as the pelican test, or count from 1 to 500 and then write the entire file, with thinking on, to see whether it can finish within budget. The poster also left a mechanism test still to be verified: use --override-tensor to keep GDN-related layers such as in_proj, conv, and gates at f16 or q8, while MLP stays at 6bit. If the pelican suddenly pedals normally, the mechanism is confirmed.

In the replies, someone mentioned that they had encountered the same thinking loop, and in the end it was the harness that pulled it out. This detail is worth remembering. When a model does not converge, outer timeouts and budget limits are the safety belt in production environments.

Sources:
X post
Hugging Face discussion
Reddit discussion