Does Swift Qwen3.8 27B Really Think Less? Comparison with Original

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: Does Swift Qwen3.8 27B Really Think Less? Comparison with Original · Channel: Fahd Mirza · 14:03 · Watch on YouTube

Topics: AI evaluation and benchmarks, AI models, Local and open-source models

Summary

The video compares Swift Qwen3.8 27B with the original model on a task to generate a self-contained HTML latte-making simulation. Swift is presented as a fine-tune intended to reduce overthinking, but the test finds it used more output tokens and tool calls while finishing sooner. The original took longer, yet its generated simulation completed the full sequence, while Swift’s appeared to stall at step four. The presenter concludes that the speed advantage did not mean less work on this task and recommends the original model overall.

Key points

Swift Qwen3.8 27B is described as the same underlying 27-billion-parameter model, fine-tuned to penalize tokens associated with overthinking and using an efficiency transfer from Thinking Cap.
The test prompt asked both models to create a complete HTML simulation of a barista making a latte, including multiple stages and state logic.
The presenter ran both models locally with the same configuration and checked usage statistics directly in a database.
The Swift-generated simulation appeared to stop at step four, despite attempts to restart or reset it.
The original model initially reused an existing file, so the presenter moved that file and reran the test to make the comparison fairer.
On the rerun, the original took 47 minutes and 7 seconds and generated a simulation that completed all stages.
Swift finished in 35 minutes and 52 seconds, but generated 60,572 output tokens and made 21 tool calls, compared with 11,744 output tokens and 4 tool calls for the original.
The presenter notes benchmark results suggesting Swift can stay close to the base model on several measures, while showing larger drops on some multi-step mathematics benchmarks.
The presenter says Swift’s advantage may be wasting fewer tokens in some contexts, but recommends the original Qwen overall based on this test and prior comparisons.

Chapters

Start	Chapter	Summary
00:01	Introducing the Swift Qwen comparison	The presenter introduces the claim that Swift Qwen3.8 27B reduces overthinking and outlines the local setup for testing it.
01:37	The test prompt and Swift’s output	The presenter explains the fine-tuning approach, runs a multi-step latte simulation prompt, and inspects the resulting HTML.
06:46	Running the original model	The original model is tested with the same prompt, alongside a discussion of benchmark claims and the need for sustained reasoning.
08:50	Rerunning the comparison fairly	After discovering that the original reused an existing file, the presenter removes it and reruns the model in a clean working directory.
10:24	Results and recommendation	The presenter reviews the completed simulations and compares runtime, output tokens, and tool calls before giving a recommendation.

Quotes

same brain, shorter internal monologue. — 01:37

I didn’t think that was a fair comparison. — 08:50

Swift did more work in less time. — 12:30

Just go with the original coin. — 13:32

Concepts and entities

Qwen3.8 27B, Swift Qwen3.8 27B, Thinking Cap, vLLM, Hermes Agent, Mass Compute, Fahd Mirza

Full transcript (original language)

00:01 We have covered coin 3.8 27 billion a lot on this channel. The original, the finetunes, all of it. And one of the biggest complaints has always been the same. This model thinks way too long before it answers. Today we are testing something entirely different. A version that claims to have actually fixed that. And not only we are going to test it out, we are going to actually measure this swift coin 3.827

00:34 billion. This is Fahad Miraa and I welcome you to the channel. Recently I also have started this free weekly AI newsletter which you can subscribe at fahada.substat.com. What I’m going to do, I’m going to use V LLM to serve this model. And you can see I am already doing that on this local system with this configuration. And I have already knitted it together with Hermes agent where it is running locally. And this is how much VRAM it is

01:05 consuming. I have 80 GB VRAM. If you don’t have that, you have two options. either go with quantized GGF version or if you want to replicate what I’m doing just go to mass compute the link is in video description and rent a GPU on very affordable price. So that’s out of the way let me first talk through what exactly these guys have done just look at this diagram and this gives you the whole picture it is not a new model as I

01:37 mentioned earlier same coin 3.827 27 billion weights underneath. What they did is fine-tune it to penalize the tokens that trigger overthinking and pulled in an efficiency transfer from another model called thinking cap, which we already have covered by the way on the channel. End result, same brain, shorter internal monologue. So for the first test, I’m going to do this goal. I am going to give it one hard prompt. Generate a complete self-contained HTML

02:09 file simulating making a latte barista style. This isn’t a toy test. It needs multi-step state logic. Grinding, temping, pulling the shot with a timer, steaming milk, pouring. What we are checking here is two things. Is it actually faster? And does cutting the thinking tokens cost it any real capability? Or does it still get the logic right? So I’m just going to go back and I’m going to go to my Hermes

02:40 and I will give the prompt in front of you. So hopefully it is going to work. This is the whole prompt which I already showed you. Meanwhile, if you want to help out the channel, please go to the homepage of channel or in the first print comment and become a member. the model is thinking and this is actual test here that how long does it think. If you want to see how long the original thought just go to my channel and search for that video and you’ll be surprised

03:11 how long uh does it think. So let’s wait for it to come back and then we will analyze in real time if the claim is right or not. Or better yet, after this one is finished, I will uh save the result and then we will also install the original Quen in the same config and then we will run the same prompt and do sideby-side comparison eventually model has produced the file

03:42 and after verifying it a lot and you know what it has also thought a lot but we can’t really make comparison unless I run the other original one. So before that I’m just going to capture these statistics and then we will compare them later on. So let me just exit from here. This is my session. I’ll just grab some statistics and then I will launch the other one. And if you’re wondering how exactly I’m

04:12 sure about this statistics, I’m actually also running the direct command to that SQL DB as you can see here. And it has given me these input output tokens. Okay, let me now serve that original coin. Original coin is now being served with same parameters. And I forgot to show you the HTML file which that swift generated. This is the one. Let me open it in the browser. There you go. So this is a simulation. You see there are 10 steps. Let me also

04:43 make it bit bigger. There you go. I think this is better. So it auto plays the full sixst step sequence. Press R or hit reset to start over. Anyway, so this is step 1, two, three. Going good. And this is a step four. How good is that? Look at that. Goodness me. This is the beauty of co only 27 billion parameter. It is now frothing to silky microform.

05:14 This is a HTML file. Nothing else. And uh it has it is stuck at step four. Not moving forward, I guess. Or maybe still frozen. What about this step? Poor latte and serve. Okay. So, I’ll just see if R works or not. I’m going to press capital R. Oops. Nothing happening. Maybe it because I’m in the VM. I’ll just go from

05:44 here. This is also not working. Reset and run again. But even this whole stuff is quite interesting. I’ll do control F5 to reset everything. Let’s try it out again. This is a temping happening. Pull shot. You see even this blinker just switches on on the machine and the cup is getting filled. This is quite cool.

06:16 and off. Now look at the smoke rising and frothing. Frothing is done now. Silky microphone. So I’ll just wait a bit and see how it goes. Okay. So this is uh where it is. So it just gets stuck here. I have waited for long. Nothing happens even I paused it a bit. Okay. Okay, so let’s go back and now let’s run this with the original

06:46 coin. So this was our original coin. Let me show you the VM consumption. So this is how much it consumes. And let’s go to Hermes agent where I already have set it up. Same prompt. I’m giving it to base I mean like the 3.8 27 billion original one. So let’s see how it does. We will then compare both of these. So I’m just going to go make some coffee. While Gwen thinks long and hard, let me

07:19 show you something interesting. They have shared some of the benchmarks across general reasoning, GPQA, MMLQ and lot of other swift stays within a point of base model sometimes even edges ahead while cutting means tokens by 40 to 50%. That is something they have claimed and we will test it out shortly as our tests are running. But look at the mathematics. Amy 2026 computition math

07:49 multi-step problems. This is something where we cannot really shortcut our way through. Basecoin 3.8 hits 98.667%. Swift comes in at 94%. A 4.6 point drop. And out of everything on this sheet, I think this is the biggest one. Hmmt tells the same story. 99.33 down to 96%. So the pattern holds everywhere except the one category that

08:20 actually needs sustained step-by-step reasoning. I think that is where we are doing this test. So not whether Swift is faster because it clearly is. It’s whether that speed is costing something on this sort of task that needs the model to actually think it through and we will test out how long does it take and how many tokens it requires. So let’s wait for it to finish and then we will go from there. I think it has

08:50 already finished I guess. There you go. It’s already done and this is the statistics. Let me also grab this stat from the database. And here is another honest picture. I just checked the output and the reasoning trace and it seemed what this original model did. It copied the previous file, changed it and then regenerated it. So I don’t didn’t think that was a fair comparison. So what I have done, I have relaunched this by

09:22 removing that original file to another folder. because it is not in the current working directory. So everything stays the same. This is the new directory which I have created. So I just moved it to downloads directory. I’m just giving you the honest picture so that we are all on the same page. This is my current working directory. So now this co model should generate this new file here. And I will again wait for however it takes. I think it will take around an hour or so. And then we will test it out. So

09:54 let’s see how it goes. And this is what involves in making these videos that it takes hours and hours and you know because these servers are rented so just have to pay for all of these hours and stuff. So a lot of effort, time and money goes into making these videos. Hopefully someday someone will appreciate. So I will wait for this to finish and then we’ll go from there. And eventually this has come back after 45 minutes. And this is what it has

10:24 generated. So let me copy this path and show it to you live. And I promise I really haven’t checked it out myself. I’m opening it in front of you. There you go. So I will make it bit bigger and then we will test it out. So let’s start. So first step grinding coffee beans. Looks good. Then temping the grounds even better. Latte Pro. By the way,

10:56 you see red lights on. Pulling espresso shot. Third step. There’s a market difference between the other one and this one. The output and the graphics. Anyway, so it is still pulling it. It is dripping in the cup. As you can see, these are the non things. While the machine is running, the light is on. Same was the story with the other one. It was green. This one is red. I will let it run. That stopped at step four I guess. Now the step four it is streaming and frothing the milk. Look

11:28 we can just ignore these sort of things but this is good. This is HTML not an image thing and our latte is ready. All the steps are done and reset to go again. So the original one is end to end. It didn’t really break. Uh after step four it is complete. So that is one thing we can tell the difference about for the rest of it. I will just go in and get out of this session and then get the data from database

12:00 and this is the result from database in all fairness. So this is a table which I have just created comparing both of these which I already have shown you. If you look at this table, this is actually what happened and it’s not quite what you would expect. Swift generated more 60,572 output token tokens against base coins or original coins 11,744 and made more tool calls 21 versus 4.

12:30 But it finished faster 35 minutes 52 seconds versus 47 minutes 7 seconds for original coin. So this isn’t simply Swift thinks less on this task. Swift did more work in less time. Original Quen on the other hand spend real time secondg guessing itself. You saw it in the transcript debating whether to copy an existing file or rewrite from scratch before settling down and doing the work properly in my second attempt. Uh and I had restarted VLM cleaned everything so

13:02 that it won’t cach or do anything. So that is one thing you need to uh be aware of. It is a clean clear test. Um and you can see that the claim really doesn’t hold. So but I think um where the claim holds and I agree with that that the real advantage is not fewer thoughts. The real advantage is that it wasted fewer tokens which I agree with. But then uh if you look here even in

13:32 terms of number of tokens and I’m talking about reasoning um as how it actually got to the result. But overall I would say original Quinn is way more better than this swift or you know what any fine-tune any variation I have seen so far on the um and we have tested on the channel and this question I get a lot that which coin is better. You know what? Just go with the original coin. That is way way better. Rest of it is

14:03 still research. There are some promising result like in GSQRCO from Austria. But other than that, I think uh original coin would still hold including its quad. That’s it. Let me know what do you think. Thank you for all the