With the release of ThinkingCap-Qwen3.8-27B, I thought it would be worthwhile to do a comparison between the original Qwen3.8-27B, the new ThinkingCap, and Swift-Qwen3.8-27B. Both Swift which I already reviewed, and ThinkingCap do exactly the same thing: they reduce the excessive reasoning loops that 3.8-27B is renowned for. In fact, their claims are almost identical: both models claim to reduce reasoning tokens by approximately 40%, with minimal degradation in performance. I wanted to put these claims to the test. I used my standard Aider eval suite, which I’ve found to provide good separation of models tested (~20 so far), and on which only one model (Qwen3.8-Flash) has scored over 90%. I am able to measure a number of useful metrics on this evaluation, including pass1/2, completion tokens, seconds/case, tokens/solve, and how many diffs were well-formed in the model’s attempts. Here’s the results of 2 runs per model, which should reduce the error bars to +/- 2-3% at most. All 3 models were evaluated at Q8_0 in llama.cpp 0.5.0: model First-try pass Retry pass well-formed diff median tokens sec/case tok/solve ThinkingCap-Qwen3.8-27B (xhigh) 27.1% 77.6% 100.0% 7436 777 12.8K Qwen3.8-27B (xhigh) 27.1% 77.6% 99.1% 12547 1481 19.3K Swift-Qwen3.8-27B (xhigh) 30.8% 75.7% 98.1% 7301 750 12.1K Shockingly, ThinkingCap and vanilla 27B score *identically*. I’ve never even had 2 runs of the same model score identically, so treat this as a total coincidence. However, this definitely supports BottlecapAI’s claims of minimal performance degradation. Swift performs within noise levels of the other 2 models, just 2% lower, but with a higher first-try pass rate than either of them. To swipe a phrase from Claude, the real story is the completion tokens: nearly 5k fewer median completion tokens for both fine-tuned models compared to the original. That almost *exactly* matches the claimed 40% reductions from their model cards. ThinkingCap uses slightly more tokens per solve, and therefore takes a little longer than Swift, but they’re within a few percent of each other here as well. One thing to note that’s not seen on the chart: the medians tie, but in mean completion tokens, ThinkingCap uses 8.5% more because its tail is longer — there are more cases on which it still overthinks significantly, while Swift achieves a more uniform reduction in reasoning token usage. Another distinction: both models spend more tokens on cases they fail than on cases they solve, but this is more pronounced for Swift (13.2k for fails vs. 5.9k for solves) than it is for ThinkingCap (9.4k median vs. 6.8k median). ThinkingCap gives up more easily, perhaps? Or it just knows when it’s beaten. In order to differentiate these two excellent fine-tunes, we need to take a more granular look at their performance. There are 3 languages which distinguish them on programming performance: model cpp javascript python ThinkingCap-Qwen3.8-27B (xhigh) 11.5% / 61.5% 35.4% / 85.4% 27.3% / 78.8% Qwen3.8-27B (xhigh) 7.7% / 69.2% 27.1% / 81.2% 42.4% / 78.8% Swift-Qwen3.8-27B (xhigh) 11.5% / 69.2% 37.5% / 81.2% 36.4% / 72.7% As you can see, ThinkingCap significantly underperforms Swift on C++, losing out on pass2 by 8%. However, it makes that ground back up on Javascript and Python, overperforming by 4% and 6%, respectively. This is notable if you use any of these languages more than the others. Performance on the other languages in Aider was statistically similar (p > 0.05). One last distinction — ThinkingCap is the only model with a perfect score on well-formed diffs: zero error outputs and zero malformed replies, whereas both other models had several. Anyways, I hope this helps anyone trying to choose between these two very well-crafted fine-tunes, both of which do what they say on the tin...   submitted by   /u/returnity [link]   [comments]