YT YouTube2Text

YouTube2Text → Transcripts → GLM 5.3 Flash vs GLM 5.3: When Cheaper Is the Right Call

GLM 5.3 Flash vs GLM 5.3: When Cheaper Is the Right Call — Transcript

by Sam Witteveen · 3,086 words · 428 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00Okay, in this video I want to talk about
0:02the latest GLM 5.3 flash, but rather
0:06than just show you some tests of it and
0:08things like that, I actually want to
0:09talk about how this came about and how
0:11it actually compares to their flagship
0:14GLM 5.3 model. Cuz really we've got two
0:17stories here. One is about how to
0:19squeeze the most amount of performance
0:21out of your old base model with RL, and
0:24then the second one is basically how do
0:26you build something completely new with
0:29a new pre-trained base that's going to
0:31be built around efficiency. I'm also
0:33going to talk about when you should use
0:35the flash model versus when you should
0:36use the full-size model, and also where
0:39this could all be going not only for
0:41ZAI, but for a lot of their competitors
0:44as well. So I made a video about GLM
0:465.2, and that model seriously impressed
0:49me. And I was actually in China when
0:51they launched 5.3, which is also a
0:54really impressive model. So the key
0:56thing with the 5.3 model over 5.2 was
1:00that ZAI really focused in and dialed in
1:03improving their RL for particular tasks,
1:08specifically for stronger coding, for
1:11agentic tasks, and also for
1:13cybersecurity uses. Don't forget it was
1:16GLM 5.2
1:18was the model that Hugging Face had to
1:20use to defend against the OpenAI agents
1:24that were attacking them. Basically
1:26because none of the other proprietary
1:27models would actually entertain the
1:30tasks that the Hugging Face team were
1:31trying to get the models to do to defend
1:34their own system. So in some ways you
1:36could say GLM 5.2 saved the day there,
1:39and it does seem that ZAI took away that
1:42they should even improve that. If we
1:43look at the 5.3 benchmarks, we see clear
1:46advances on things that they were
1:48focusing on basically improving their
1:50pipeline. Now, if we jump to 5.3 flash,
1:54we've got a whole different model here.
1:56This is not the same base model. It's
1:59not even a pure direct distillation to
2:01get a smaller version of that 5.3 model.
2:04For a start, the size of the models is
2:07quite a lot different. So, you've got
2:09GLM 5.3, that's a mixture of experts. In
2:12fact, both of them are mixture of
2:13experts. But, 5.3 is 744 billion
2:17parameters with 40 billion parameters
2:20active. And that 40 billion parameters
2:23active means that this is still quite a
2:25chunky model to run. Jump forward to 5.3
2:29flash, they've now got a model down to
2:32320 billion parameters with only 18
2:36billion parameters active. So, this is
2:38effectively sort of the half-size model
2:41of 5.3. But, ironically, it's actually
2:44pre-trained on more data. Now, one of
2:46the biggest differences between these
2:48two models is that 5.3 is a text-only
2:51model, and 5.3 flash can handle both
2:54text plus images and videos. Now, when
2:57we look at the pre-training, 5.3 flash
3:00actually was pre-trained on more tokens
3:02than 5.3. They're saying that that was
3:05over 30 trillion tokens there. Now, it
3:07is important to emphasize that those 30
3:09trillion tokens are multimodal. So, when
3:12compared to the 5.2 base that was used
3:15to make the 5.3 model, there was only
3:1728.5 trillion tokens, but they were all
3:21text. So, that size difference
3:23translates very much into the cost of
3:27using this thing as an API. Now, I'm not
3:29going to talk about running this model
3:31locally in this video. I'm going to
3:32actually save that for another video and
3:35do a whole video on how you can run this
3:37locally and what kind of speeds you will
3:39actually get for the 5.3 flash. By using
3:42this model as an API, you're looking at
3:44something that's almost 1/9 the cost for
3:47the output tokens. So, the 5.3 flash
3:51full price is 50 cents per million
3:54tokens out and 15 cents per million
3:56tokens in. Now, they're currently
3:58running some promos on open router to
4:00make it half that price, but let's focus
4:03on the full price because at 50 cents
4:05per million tokens out, that saving is
4:08huge compared to the $4.40
4:11per million tokens out for the full-size
4:13model. Now, while the size and how they
4:16were made are hugely different, these
4:18models also share a lot in common.
4:21Clearly, there's a lot of similar data
4:23that has been used in the pre-training
4:24of these, and they also share the same
4:26API behavior. So, the 5.3 flash supports
4:29controlling your thinking token budgets
4:31through the reasoning effort parameter,
4:34which means you've basically got low,
4:36high, and max. And that's identical to
4:39the full-size 5.3. And unfortunately, on
4:42both of these models, you don't have the
4:43ability to turn off thinking. So, that
4:46one's definitely a change from where GLM
4:495.2 was. Another thing that they have in
4:51common here is that despite them having
4:53different base models, they clearly are
4:55sharing a lot of the same post-training,
4:58probably using the same RL environment
5:01stack for both the 5.3 and the 5.3
5:04flash. Now, another interesting thing
5:06about the 5.3 flash is often companies
5:09use these smaller models to test out an
5:11architecture change at just a smaller
5:13size to see if it's going to work before
5:16they actually train the full one. And
5:17that could be precisely what's going on
5:19here. GLM 5.3 flash is really designed
5:24around this efficiency kind of
5:26architecture. They're using a hybrid
5:28combining both sparse attention plus
5:31linear attention here, and it's
5:32interleaving those two types of
5:34attention through the 45 layers of the
5:36model. And that's actually a little bit
5:38more than half the 80 layers that the
5:41full 5.3 is using. On top of this,
5:43they're routing through eight experts of
5:46the 288 experts that they have each
5:48time. And it's great to see that they've
5:50got a multi-token predicted draft layer
5:52in there as well. And if we come in here
5:54and look at the benchmarks, we can see
5:56that this model is outperforming GLM
5:595.2, which is kind of insane considering
6:02that this model is half the size. You
6:04can choose to run it locally with a lot
6:07less hardware than you needed for GLM
6:095.2. But mostly whether you just use
6:11this locally or whether you use it as an
6:13API, you're just getting better
6:15performance out of it overall. Now, one
6:18of the things that kind of annoyed me
6:19was that they don't really show a lot of
6:21benchmarks where they're benchmarking
6:23the 5.3 flash versus the 5.3. Now, when
6:27we look at the benchmarks that they've
6:28posted here versus sort of comparative
6:31models, we can see that this model is
6:34giving models like Opus 4.8, 5.6 Terra,
6:38remember that's the mid-level GPT
6:40nowadays, and Gemini flash, it's giving
6:42them a run for their money. always
6:45beating them, but for some of them, it
6:47clearly is beating them. On top of this,
6:49the ones that we have where we actually
6:51do have comparisons against GLM 5.3,
6:55we can see for example that it's
6:56actually beating the GDP valve for 5.3.
7:01But clearly for some things, size really
7:03does matter. So, we see for example on
7:05the humanities last exam, the 5.3 flash
7:07is getting 55.3,
7:10the full version of 5.3 is getting 62.5.
7:14And rightly the 5.3, they're comparing
7:16against Fable 5 and GPT 5.6 Soul in
7:19there. The simple fact though is for 1/9
7:22the price here, you're getting a model
7:25that is insanely good and has vision
7:27abilities compared to the full 5.3. And
7:31honestly, I kind of feel if I was using
7:33this with agents and this model was
7:35going to fail for the agents, I'm
7:37probably not going to fall back to the
7:385.3. I'm going to fall back to one of
7:41the frontier models from open AI or
7:43Anthropic. Okay, so when we come in and
7:45look at the artificial intelligence
7:47scores, we can see that this is scoring
7:49super high for one, a model that's open
7:52weights, and two, a model that's this
7:54size. Don't forget, sure, it's being
7:57beaten by the Qwen 3.8 model, but that
8:00model and the Kimiko 3 model, et cetera,
8:03those are well over 2 trillion
8:04parameters in here. So, ZAI is doing
8:07kind of amazing for the size. We've got
8:10the GLM 5.3 model at an intelligence
8:13score of 60, and the 5.3 flash model at
8:16an intelligence score of 57. And if we
8:19compare it to some of the other models
8:20that you can run locally, really the
8:22ones that are most interesting are
8:24probably the Qwen 3.8 flash next, which
8:27I'll talk about in another video, and
8:29the DeepSeek 4 flash. So, when we look
8:31at this, really it looks like this new
8:335.3 flash and the Qwen 3.8 flash are in
8:37many ways a whole new class of models
8:40that are small enough where a lot of
8:41people are going to be able to run them
8:42locally, obviously with some pretty
8:44beefy hardware, but also small enough
8:46that any endpoints are going to be very
8:48cheap for this. If we look at the
8:50agentic index in here, it's looking even
8:52better with this really just behind a
8:54few models, most of the Anthropic
8:56models, et cetera, but also well ahead
8:58of Kimiko 3, which is that 2.7 trillion
9:02parameter model. Now, where the
9:04performance actually slips a bit though
9:06is when we compare the intelligence
9:09index versus the output tokens here. So,
9:11really we would like to see this being
9:14able to get this level of intelligence
9:16without a huge amount of output tokens.
9:19And you can see that both for this model
9:21and the Qwen 3.8 flash, both of them are
9:23using a lot of tokens to get that level
9:26of intelligence.
9:27Okay, so first up, the thing that I was
9:30most interested in testing were the
9:32things like function calling and just
9:35seeing how well it does on the various
9:37agentic tasks. And so, when I tried this
9:40with max reasoning, it does fantastic,
9:42right? You can see it passes all the
9:44tasks really well. So, then I thought,
9:46"Okay, well, what about if we try it on
9:48low reasoning?" And on low reasoning,
9:51it's obviously it still can do the
9:53tasks, but for each of the tasks, it
9:56does exactly what I've asked it to do
9:58and it is able to basically get the job
10:00done without a lot of thinking. Now,
10:03it's interesting that they've trained
10:04this on sort of a Claude code harness,
10:07and it would be really interesting to
10:08see how well it does with other
10:10harnesses that are out there. But even
10:13here with the low thinking on
10:15long-running sort of jobs and stuff like
10:17that, it does very well. And it
10:20understands when prompted to not use
10:22tools and just use the model itself,
10:24it's able to resist the urge to use
10:26tools there. Next up is the agentic pro
10:28test in here. So, this is testing a lot
10:31more sort of long horizon sort of stuff.
10:34This time I started with the low
10:36thinking on. And it's amazing that the
10:38low thinking on is kind of often close
10:41to no thinking on, that it will
10:43literally just have one line of thinking
10:46and usually even less than 50 tokens of
10:48thinking. That said, all of these tests,
10:51it was able to do really well. One of
10:53the ones that I was interested in the
10:55most is this failure retry. So, this
10:58deliberately gives failures for the
11:01first couple of times that it does the
11:03thinking and to see does it actually
11:06give up, right? Does it keep persisting
11:08and going on, right? And you can see the
11:10thinking to itself was call tool if
11:14fails retry. Unbelievably small amount
11:17of thinking tokens, but it did do
11:19exactly that and it was actually able to
11:21deal with multiple errors coming here
11:24before it be able to execute in there.
11:26Then testing it with different
11:27distractors for sort of tool bait, it
11:30doesn't fall into the challenges that a
11:32lot of the models do here. So, overall,
11:34the agentic stuff is really good. So, if
11:37we come in and look at the SVG tests,
11:40you can see that even on low, this is
11:43doing a really nice sort of pelican one.
11:46On the max setting, it does a fantastic
11:49job here, right? I got to say this is
11:50definitely one of the nicest ones. It's
11:52got massive amount of thinking though
11:54going on here, right? Just really huge
11:56amounts of tokens. And then the whole
11:58thing about it overfitting is pretty
12:01clear. You can see if I do a red dragon
12:04with a very similar prompt, not the best
12:07looking red dragon here on low and then
12:10on high, perhaps not a great red dragon,
12:13a bit better and stuff like that. It's
12:14got tails, got the wings. We've got it
12:16flying at night. But you can see that
12:19this took a huge amount of tokens to
12:21actually generate out. And we can see
12:23that like it actually does have some
12:26nice chain of thought in there.
12:29Definitely going through the chains of
12:30thought for this. I'm noticing different
12:33patterns compared to where Qwen is
12:35going. Qwen is going much more into the
12:37abbreviated thinking ideas, sort of the
12:40caveman thinking in a similar direction
12:43that GPT has gone. This one doesn't seem
12:45to be at that level yet. And that may be
12:48one of the reasons why it uses so many
12:50tokens for a lot of the tasks. Testing
12:52it out with low mode on things like rag,
12:55it does a really nice job here, right?
12:57That it really is not using a huge
12:59amount of tokens for this output at all.
13:02It's very much to the point for those
13:04particular low tasks, etc. And then
13:06finally, looking at the design stuff, I
13:08find that for the low tokens, it is very
13:12sort of rudimentary designs. Not that
13:14they're really bad, but there's just
13:16nothing visually appealing in a lot of
13:19this. Now, that could be the prompt. If
13:22I gave it a much better prompt or
13:23something like that, it's probably going
13:24to do better in that sense. Giving it
13:27more tokens, whether it's sort of X high
13:29or something, it definitely goes on for
13:31a lot more thinking, and we get nicer
13:33quality kind of stuff out.
13:35Interestingly, the design and the color
13:37theme that it comes up with are very
13:40much things that we've sort of seen
13:41before. And also nice to see that it's
13:43using some SVGs and stuff in there as it
13:46sort of makes some custom graphics,
13:48rather than just use images. But we've
13:49got some weird things like alignment and
13:51stuff like that going on here, which
13:53seems a bit crazy to me. And things like
13:56when we change the quotes, we're
13:57actually dynamically changing the box,
13:59rather than keeping it the box the same
14:01size throughout. In regards to the prose
14:04test, it seems to be quite decent for
14:06that kind of thing. I'm really thinking
14:08now that all the models need to be sort
14:10of guided a lot more by certain skills
14:13that you use for those kind of tasks to
14:16actually be able to elicit out the kind
14:18of writing that you want for this. Now,
14:20I also tried it on running some MCPs and
14:23stuff like that, and it does seem very
14:25good at using that. And running it in
14:27some basic code harnesses like open
14:29code, etc., it also seems to be doing a
14:31good job there. The big thing I wonder
14:33with this, though, is if you want
14:35something totally private, do you go for
14:38this, or do you stick to the Qwen 27B
14:41model? Which still is an amazing model,
14:43and last weekend alone, I generated
14:45about 100 million tokens with that model
14:48locally, running 24/7. And I kind of
14:51feel with that, if somebody actually
14:52does fix the long thinking, then that's
14:54going to be a killer local model for a
14:56long time to come. Okay, so lastly, just
14:59before I finish up, one of the things
15:01with this model is that because if
15:02you're using this in max mode, it will
15:05think for a very long time, and overall,
15:08that can just make it slow. So, the
15:10issue there is you've got a decision to
15:12make if this fails on a particular task,
15:15and you've got a verification step or
15:17something that's actually checking, and
15:18it's failing, you've really got a
15:20decision to make of how many times do
15:22you want to try it again before you go
15:24to a better model. And the challenge
15:26there is that if you try it many times,
15:28there's a high chance that it will
15:29actually perform the task that you
15:31wanted. And the issue with that is not
15:33that it's going to be expensive, it's
15:35just that it's going to be slow. So, you
15:38really need to decide do you have
15:40something that's going to need a
15:41real-time response, which in that case
15:43you're probably going to go for a
15:44different model, or are you prepared to
15:46ride it out for a few times and try to
15:48get the model to fix itself before you
15:50go to a more expensive model. Because
15:52remember, even if you're going to go to
15:54the GLM 5.3 model, you're talking about
15:57something that's around nine times more
15:59expensive for the tokens that it's going
16:01to output. So, overall this is a really
16:04fantastic model. It'd be great to see
16:06this supported by someone like Cerebras
16:08where they could actually perhaps run it
16:10a lot quicker than other people have
16:12been running it. And like I said earlier
16:14on, I will make a video of actually
16:16running this locally so you can sort of
16:18see what speeds do I get compared to the
16:21APIs out there at the moment that are
16:23only getting around sort of 50, 60
16:25tokens max themselves. So, let me know
16:27in the comments if you've tried the
16:28model out. I'm curious to see other
16:30people also finding that perhaps this is
16:32not as good at design as some of the
16:34other models recently, but is very good
16:37at the agentic steps and the function
16:40calling and tool calling that go along
16:42with it. Anyway, as always, if you found
16:44the video useful, please click like and
16:46subscribe and I will talk to you in the
16:47next video. Bye for now.

About this transcript

This page contains the full transcript of GLM 5.3 Flash vs GLM 5.3: When Cheaper Is the Right Call by Sam Witteveen, generated from the public captions YouTube serves with the video. The transcript has 3,086 words across 428 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.