GLM-5.3 Keeps the Same Base Model, but Its Coding Capabilities Have Improved

On August 14, Zhipu AI officially released GLM-5.3. Unlike typical upgrades centered on “more parameters and a new architecture,” this model does not replace the base model. Instead, it scales up post-training on the same foundation as GLM-5.2, with most of the gains coming from reinforcement learning, long-horizon task environments, and training infrastructure.

Zhipu AI says GLM-5.3 delivers a 50% improvement over GLM-5.2 in its internal evaluation of real-world coding experience, while ranking first among open-source models on public benchmarks such as Terminal-Bench 3.0 and Agents' Last Exam (CLI). The model weights were not released today and are scheduled to become available after two weeks of safety evaluation and hardening.

The most noteworthy aspect of this release is not merely that “another open-source coding model has topped the leaderboards,” but that Zhipu AI has validated an increasingly clear path: once base-model training is complete, the model’s capabilities are far from fixed. As long as task environments, reinforcement learning algorithms, and training duration continue to scale, the same set of parameters may still yield a substantially higher ceiling for agentic intelligence.

Same Base Model, but Terminal-Bench Jumps From 4.6 to 28.3

The most visible changes in GLM-5.3 come from coding and agent benchmarks.

On Terminal-Bench 3.0, which measures whether a model can complete complex operations in a real terminal, GLM-5.3’s score rose from GLM-5.2’s 4.6 to 28.3—an absolute increase of 23.7 points and roughly 6.15 times the previous generation’s score. This is not about completing a function or answering an algorithm question. The model must enter a terminal, understand the environment, invoke tools, execute commands, handle errors, and deliver verifiable results after multiple rounds of operations.

Several other scores also improved to varying degrees:

| Benchmark | GLM-5.2 | GLM-5.3 | Change | | --- | ---: | ---: | ---: | | Terminal-Bench 3.0 | 4.6 | 28.3 | +23.7 | | DeepSWE v1.1 | 46.2 | 66.9 | +20.7 | | Agents' Last Exam | 23.8 | 28.5 | +4.7 | | GDPval-AA v2 | Not disclosed | 1,769 | — |

DeepSWE v1.1 focuses more on long-horizon software engineering tasks, including sustained code reading, cross-file modifications, running tests, and fixing regressions. GLM-5.3 improved from 46.2 to 66.9, a relative increase of approximately 44.8%. Compared with the leap from a low baseline on Terminal-Bench, this result is more informative for developers: it means the gains are not limited to command-line operations but extend to repository-level code changes.

Agents' Last Exam covers multiple professional scenarios and requires models to coordinate across tools while maintaining long task chains. GLM-5.3’s score increased from 23.8 to 28.5, a relative gain of about 19.7%. GDPval-AA v2 covers high-value knowledge work across 44 occupations, where GLM-5.3 scored 1,769. Zhipu AI’s view is that some general professional task capabilities are beginning to “grow out of” coding and tool-use capabilities.

However, the claim of a “50% improvement over the previous generation” should not be interpreted as a 50% average increase across all public benchmarks. That figure comes from Zhipu AI’s proprietary Z.ai Code Bench experiential evaluation, while gains vary considerably across public tests. Terminal-Bench increased more than fivefold, DeepSWE improved by nearly 45%, and Agents' Last Exam rose by less than 20%. Presenting an internal composite metric as the improvement across all model capabilities would overstate how broadly the conclusion applies.

A more accurate statement is that GLM-5.3 delivers an approximately 50% overall improvement in experience on the distribution of real-world coding tasks defined by Zhipu AI.

It Is Not Better at Writing Code—it Is Better at Getting Things Done

Earlier coding models primarily competed on single-turn generation quality: provide a requirement and receive a function, or paste an error message and get a suggested fix. Coding Agents are evaluated by a different standard.

A real-world task may involve the following process:

1. Scanning directories and understanding the project structure;
2. Locating implementation and test files;
3. Modifying multiple interdependent modules;
4. Installing dependencies and running builds or tests;
5. Replanning based on error logs;
6. Checking for side effects and completing the final delivery.

An error at any step can render all the correct reasoning that came before it meaningless. Even if a model can write elegant local code, its ultimate task success rate will remain low if it cannot interpret terminal feedback or maintain state across dozens of turns.

GLM-5.3’s main improvements are concentrated precisely in these long-horizon closed loops. Zhipu AI introduced long-horizon task environments at dozens of times the previous scale during post-training, while also expanding the variety of environments and the duration of training. One way to understand this is that the base model had already learned a vast amount of code and knowledge, but had previously completed only a small number of “internship projects.” Zhipu AI has now had it repeatedly take on tasks in many more real-world sandboxes, run programs, encounter errors, receive rewards, and adjust its strategy.

This is not the same as simply adding more code to the pretraining corpus. Pretraining teaches the model how Python, Rust, or a particular framework is typically written. Reinforcement learning in task environments teaches it how to make progress within a system that produces errors, times out, and contains dependency conflicts.

The latter is clearly closer to the experience developers expect when using a Coding Agent.

Post-Training Scaling Is Beginning to Take the Baton From Pretraining

GLM-5.3 uses exactly the same base model as GLM-5.2, with all incremental gains coming from post-training. Zhipu AI disclosed that this process used IndexShare, SAO, and the continuously evolving next-generation Slime framework to conduct reinforcement learning.

There are two practical reasons behind this.

First, training ever-larger base models is becoming increasingly expensive. Scaling parameters, data, and compute remains effective, but every upgrade requires paying the high cost of pretraining all over again. By contrast, building verifiable environments on top of an existing base model and using reinforcement learning to teach it task strategies allows for more targeted investment and faster iteration.

Second, code is naturally well suited to reinforcement learning. The quality of natural-language answers often requires subjective judgment, but code can be compiled, run, and tested. Whether a command executes successfully, whether tests pass, and whether a vulnerability is triggered can all be converted into relatively clear reward signals. As long as the environments are sufficiently diverse, the model can conduct trial and error at scale without requiring humans to label every answer as good or bad.

But post-training scaling is not simply a matter of extending training time. Long-horizon agent training can easily encounter several problems:

• Sparse rewards: A task may run for dozens of steps before success or failure is known;
• Expensive environments: Each trajectory may require launching containers, installing dependencies, and running tests;
• Policy drift: The model changes continuously during training, so old trajectories may quickly become invalid;
• Reward hacking: The model may bypass tests or modify validation scripts to obtain formally high rewards;
• Context growth: Terminal logs and code files continuously accumulate, increasing inference costs as tasks grow longer.

As a result, “dozens of times more long-horizon environments” is fundamentally a test of training infrastructure, not merely GPU count. Environment scheduling, trajectory sampling, reward verification, fault recovery, and training throughput all directly determine whether reinforcement learning can scale reliably.

From this perspective, GLM-5.3 is more of a training-system upgrade than a new base-model release in the traditional sense. The model name has changed from 5.2 to 5.3, but the main underlying changes are in the post-training recipe and environment engineering.

Token Efficiency Matters More Than Simply Extending Reasoning

Zhipu AI also emphasized GLM-5.3’s balance between performance and Token efficiency. In its proprietary Z.ai Code Bench, the model enters complex local development environments and performs end-to-end tasks using different reasoning levels. GLM-5.3 achieved 31.4% accuracy at the High setting.

For Coding Agents, this dimension is highly practical.

A model can improve its success rate by generating longer chains of thought, reading more files, and repeatedly running commands, but every step consumes Tokens and sandbox time. If one model uses three times as many Tokens to outperform another by only two percentage points, commercial deployment may not be worthwhile. This is especially true when multiple Agents run concurrently, as longer inference also occupies more context-cache capacity and compute resources.

Coding models should therefore not be judged on accuracy alone. At minimum, the following should also be considered:

• Average Token consumption per successful task;
• Average completion time and latency to the first effective action;
• Number of tool calls and the proportion of ineffective calls;
• Cumulative cost after multiple retries;
• Task success rate under a fixed budget.

Zhipu AI’s decision to highlight Token efficiency separately suggests that GLM-5.3 does not achieve its results simply by “thinking longer.” However, the currently disclosed information is insufficient for cross-model cost comparisons: complete Token statistics, inference speed, API pricing, and detailed success rates at different settings are all missing. Developers will still need to wait for more comprehensive evaluation data before choosing a model.

Cybersecurity Capabilities Have Been Added, but the Boundaries Must Be Clear

In addition to coding, GLM-5.3 has strengthened its white-box code review and vulnerability detection capabilities. Zhipu AI says its performance on related security tasks is on par with Mythos 5 and believes the model has potential for defensive cybersecurity applications.

These capabilities are closely related to code Agents. Traditional static analysis tools excel at identifying deterministic issues based on rules, but often struggle to understand cross-file data flows, business permissions, and context. Large models can first understand the system’s intent and then examine call chains for potential flaws, such as:

• Whether user input is fully validated;
• Whether authentication and resource authorization are being confused;
• Whether sensitive parameters are entering logs;
• Whether combining multiple seemingly safe functions creates a vulnerability;
• Whether a fix introduces new compatibility issues.

However, a model identifying a “suspected vulnerability” does not mean the vulnerability has been confirmed. Integration into a real security workflow still requires reproducible examples, rule-based scans, human review, and isolated sandboxes. Large models are better suited here as high-recall first-pass screeners than as final arbiters.

At the same time, cybersecurity capabilities are clearly dual-use. Stronger vulnerability discovery and terminal-operation capabilities can aid defenders, but they may also lower the barrier to attack. This is an important reason why Zhipu AI did not immediately release the weights and instead reserved two weeks for safety evaluation and model hardening.

“Best Open-Source Model” Still Needs a Time Qualification

Zhipu AI describes GLM-5.3 as the open-source model with the strongest coding capabilities currently available. It also says the model’s coding and agent capabilities approach those of Claude Fable 5, while its subjective coding experience surpasses that of other Chinese models.

Based on the disclosed results, GLM-5.3 is indeed competitive on public benchmarks, particularly Terminal-Bench 3.0 and DeepSWE v1.1. But the label “best” still depends on the benchmark suite, Agent scaffolding, inference budget, and runtime environment.

The same model can produce very different results in different Agent frameworks. System prompts, context compression, tool definitions, timeout limits, and parallelization strategies all affect the final score. Without a standardized inference budget and fully reproducible experiments, leaderboards alone make it difficult to determine whether the differences come from the model itself or from the surrounding engineering.

Moreover, GLM-5.3’s weights will not be released until two weeks after the announcement. Strictly speaking, what developers can see today is the release announcement and official evaluation results; they cannot yet download the weights to deploy, quantize, or reproduce the results themselves. It can be regarded as a model with an announced open-weight release plan, but the open-source loop will not be complete until the files, license, inference code, and model card are all available.

At that point, at least four pieces of information will be worth checking:

1. Whether the weights are fully available and under what license;
2. Whether reproducible inference parameters and Agent configurations are provided;
3. How much VRAM local deployment requires and how much performance is lost after quantization;
4. Whether the benchmarks specify environment versions, Token budgets, and failure-handling rules.

If these points are clearly documented, GLM-5.3’s results can move from “the top open-source model in an official report” to an engineering reality that the community can verify.

No Vision Upgrade Shows That This Release Has a Highly Focused Goal

Before GLM-5.3’s release, there was considerable outside interest in its potential vision capabilities. GLM-5.2 is a text-only model, while converting designs into code, debugging interfaces, and operating as a GUI Agent all require visual input. However, based on the core capabilities announced today, Zhipu AI has focused on coding, terminal Agents, post-training scaling, and cybersecurity, rather than making vision a central part of this release.

That is not necessarily a bad thing.

Native multimodality increases the complexity of pretraining, alignment, and deployment, and it is difficult to add directly while keeping the base model “exactly the same.” The decision to retain the GLM-5.2 base model inherently means that this update is not intended to redesign the input modalities, but to test how much further the same base can be improved through post-training.

Vision is not essential for backend development, repository maintenance, test repair, or command-line automation. For frontend recreation, desktop operation, and screenshot-based debugging, developers will still need to combine GLM-5.3 with a vision model or wait for a future multimodal version from Zhipu AI.

What It Means for Developers: Do Not Rush to Migrate—Wait for the Weights and Cost Data

GLM-5.3 is moving in a promising direction. It pushes competition among open-source coding models beyond “can it write code?” toward “can it complete tasks in a real environment?” The improvements on Terminal-Bench and DeepSWE are also more convincing than simply setting new records on short-code benchmarks such as HumanEval.

However, it is still too early to migrate production Agents directly. The weights are not yet available, and the currently published materials do not provide complete deployment requirements, throughput, pricing, or long-horizon task costs. Teams already using GLM-5.2 or other coding models would be better served by first organizing their own task sets, waiting for the weights and interface details in two weeks, and then conducting controlled comparisons.

Internal evaluations do not need to be complicated. Teams can extract dozens or hundreds of tasks from real failure cases, apply consistent limits on time, Tokens, and tool permissions, and observe:

• Whether the first-pass success rate improves;
• Whether cross-file changes are complete;
• Whether the model repeatedly reads the same file;
• Whether it can adjust based on logs after a failure;
• Whether it modifies tests without authorization or bypasses constraints;
• Whether the actual cost per successful task decreases.

If multiple models are accessed through an OpenAI-compatible API or an aggregation platform, teams should also keep tool definitions and Agent scaffolding consistent to avoid mistaking framework differences for model differences. If unified API platforms such as OpenAI Hub add support for GLM-5.3, they will be suitable for horizontal A/B testing under fixed parameters. However, teams concerned with local deployment, fine-tuning, and security audits should ultimately rely on the open-weight version.

Verdict: The Post-Training Dividend Is Real, but 50% Is Not a Universal Conclusion

GLM-5.3 is a valuable and relatively restrained upgrade.

Rather than generating publicity through a larger parameter count, it demonstrates that the same GLM-5.2 base model still has substantial untapped capability. In particular, the jump on Terminal-Bench from 4.6 to 28.3 shows that reinforcement learning in long-horizon environments can materially change a model’s tool-use performance, rather than merely making its responses sound more like those of a programmer.

On the other hand, the 50% figure comes from an internal experiential evaluation and cannot replace third-party testing across models and frameworks under fixed budgets. The two-week delay before the weights are released also means the claim of “the strongest open-source model” temporarily lacks the crucial step of community reproduction.

If Zhipu AI fully releases the weights, license, inference configuration, and evaluation environments in two weeks, GLM-5.3 will represent a significant update in the open-source Coding Agent space. It also sends a clear signal: the next stage of model upgrades may not always require retraining a larger base model. Whoever can build more realistic, stable, and verifiable task environments may be able to push existing models substantially further.

And this competition is no longer just about model parameters. It also depends on less glamorous infrastructure—containers, tests, reward systems, and training schedulers—that ultimately determines whether an Agent can actually get work done.

References

• ITHome: Zhipu AI Officially Releases GLM-5.3, With Coding Capabilities Improving 50% Over GLM-5.2 — Release details, public benchmark scores, post-training approach, and weight-release timeline.