GLM-5.3 fact check: What Z.ai actually changed

Verified: August 21, 2026.

GLM-5.3 is Z.ai’s current flagship model for complex software engineering and long-horizon agent work. It is available through Z.ai’s API and Coding Plan and is now live on OpenRouter as z-ai/glm-5.3. The promised public model weights, however, are still not available as of August 21.

The key technical detail is counterintuitive: GLM-5.3 uses the same base model as GLM-5.2. Z.ai says every reported gain comes from additional post-training rather than a new pretraining run. The company scaled the number and diversity of executable environments and spent more compute on reinforcement learning.

That makes GLM-5.3 more interesting than a routine version bump. It is a case study in how much coding and agent capability can be extracted from an existing foundation model through environment design, verification and RL.

GLM-5.3 targets coding agents, repository-scale work and long tool-using workflows. It offers a 1M-token context window, up to 128K output, mandatory reasoning, and OpenRouter list pricing of $1.40/M input tokens, $0.26/M cache read and $4.40/M output; Z.ai’s public pricing table still has no separate GLM-5.3 row as of August 21. Public weights are still pending.

GLM-5.3 key specifications

Specification	GLM-5.3
Provider	Z.ai
Release date	August 14, 2026
Z.ai model ID	glm-5.3
OpenRouter ID	z-ai/glm-5.3
Input	Text
Output	Text
Context	1M; OpenRouter: 1,048,576 tokens
Maximum output	128K; OpenRouter: 131,072 tokens
Reasoning	Mandatory
Reasoning levels	low, high, max
Default	max
OpenRouter input price	$1.40 / 1M tokens
OpenRouter cache read	$0.26 / 1M tokens
OpenRouter output price	$4.40 / 1M tokens
Public weights	Not released as of Aug. 21
Local inference	Not yet possible without public weights

Sources: Z.ai GLM-5.3 docs, OpenRouter GLM-5.3, Z.ai pricing as a GLM-5.2 reference.

GLM-5.3 is a post-training release, not a new base model

Z.ai’s launch report is unusually explicit: GLM-5.3 uses the same base model as GLM-5.2. The company attributes the improvements to one more month of scaling its post-training stack across more environments, more diverse tasks and more RL compute.

The training stack carries forward techniques introduced with GLM-5.2, including long-horizon RL strategies and the open-source slime framework. Slime connects Megatron-based training with SGLang rollouts and supports agent environments, verifiers, tool use and long trajectories in the same training pipeline.

This matters because it narrows the explanation for the 5.2-to-5.3 gains. They are not being attributed to a larger architecture or another huge pretraining corpus. Z.ai is arguing that better post-training alone moved the model substantially.

Where GLM-5.3 improved most

Z.ai reports large gains over GLM-5.2 on several coding and agent benchmarks.

Benchmark	GLM-5.2	GLM-5.3	Change
Terminal-Bench 2.1	81.0	88.2	+7.2 pp
Terminal-Bench 3.0	4.6	28.3	+23.7 pp
DeepSWE v1.1	46.2	66.9	+20.7 pp
NL2Repo	48.9	58.0	+9.1 pp
ProgramBench Almost Solved	9.5	19.0	+9.5 pp
FrontierSWE	67.5	78.1	+10.6 pp
SWE-Marathon v1.1	19.4	42.5	+23.1 pp
PostTrainBench	31.7	39.8	+8.1 pp
CyberGym	77.2	84.5	+7.3 pp
ExploitBench	24.4	54.4	+30.0 pp
Toolathlon Verified	59.9	73.0	+13.1 pp
AutomationBench	26.2	48.2	+22.0 pp
Agents’ Last Exam CLI	23.8	28.5	+4.7 pp
HLE with Tools	54.7	62.5	+7.8 pp

Source: Z.ai’s August 14 launch report. Deltas are calculated from the vendor-published scores.

The pattern is consistent with the training story: the biggest improvements occur on tasks involving long trajectories, terminal work, multi-step software engineering, automation and cybersecurity rather than simple short-form coding.

Do not read the launch table as an independent leaderboard

Most headline numbers above come from the model developer.

Reuters noted on launch day that the cybersecurity results had not been independently verified. That does not make the results useless—Z.ai discloses a substantial amount of methodology—but it means the correct wording is “Z.ai reports”, not “GLM-5.3 definitively beats X.”

The methodology also shows why agent benchmarks are system benchmarks. Z.ai specifies different combinations of Claude Code harness versions, reasoning effort, context limits, output budgets, rollouts and timeouts. A strong result can reflect both the base model and the surrounding scaffold.

Independent evidence is starting to appear

The independent picture is still developing because public weights are not out.

OpenRouter’s live model index currently includes Artificial Analysis metrics for z-ai/glm-5.3:

• 59.5 Intelligence Index
• 74.8 Coding Index
• 59.1 Agentic Index

Those numbers are more useful than a launch-day claim because they come from a third-party evaluation source, but they remain a moving snapshot.

A community SlopCodeBench run published August 20 reported 8/17 strict checkpoints on a small three-problem subset and said GLM-5.3 tied Fable/Sol on the same subset. It is a useful early signal, not a general ranking: the sample is small and the benchmark setup differs from vendor evaluations.

The current evidence therefore supports a more restrained conclusion: GLM-5.3 looks genuinely strong for coding and agents, but its broad independent evaluation record is still younger than its launch table suggests.

What the “50% coding improvement” actually means

Z.ai’s 50% headline comes from Z.ai Code Bench, an internal coding-agent benchmark.

At maximum effort, Z.ai reports:

• GLM-5.2: 23.4% at roughly 96K output tokens per task
• GLM-5.3: 34.5% at roughly 75K output tokens

At high effort, GLM-5.3 reaches 31.4% at around 50K output tokens, according to the company.

The token figures are arguably as interesting as the score. If GLM-5.3 really completes more tasks while generating less output, that can materially improve long-running agent economics.

But Z.ai Code Bench is private. The 50% figure should not be presented as an independently reproducible universal uplift.

GLM-5.3 on OpenRouter

OpenRouter’s current model index exposes GLM-5.3 as:

z-ai/glm-5.3

It reports:

• 1,048,576-token context
• 131,072 maximum completion tokens
• text input and text output
• mandatory reasoning
• low, high, max effort levels
• max as the default effort

OpenRouter also exposes:

~z-ai/glm-latest

The alias currently targets GLM-5.3. A pinned model ID is still preferable for reproducible production workflows because a latest alias can move to a future GLM version without a code change.

GLM-5.3 API pricing

OpenRouter currently lists the following prices for the Z.ai-served GLM-5.3:

Z.ai’s public pricing table still shows GLM-5.2 rather than a separate GLM-5.3 row on August 21. The figures below are therefore presented as OpenRouter list prices; re-check direct Z.ai billing after its table is updated.

Token type	Price per 1M tokens
Input	$1.40
Cached input	$0.26
Cached-input storage	Limited-time free
Output	$4.40

These OpenRouter list prices match the current GLM-5.2 rates shown in Z.ai’s public pricing table; that does not by itself prove that direct Z.ai billing is identical.

Example: light use

1M input + 0.2M output:

1 × $1.40 + 0.2 × $4.40 = $2.28

Total: $2.28

Example: medium agent workload

10M input + 2M output:

10 × $1.40 + 2 × $4.40 = $22.80

Total: $22.80

Example: cache-heavy workflow

Assume:

• 100M total input tokens
• 80M cached
• 20M fresh
• 20M output

Cost:

• fresh input: 20 × $1.40 = $28.00
• cached input: 80 × $0.26 = $20.80
• output: 20 × $4.40 = $88.00

Total: $136.80

Without caching, the same 100M input and 20M output would cost $228. In this constructed scenario, caching cuts the total by $91.20, or 40%.

For repository agents, that can matter more than a small difference in headline input price.

Reasoning is always on

GLM-5.3 no longer supports disabled reasoning.

Available effort levels:

low
high
max

max is the default and Z.ai recommends it for complex coding tasks.

A request can explicitly set:

{
  "model": "glm-5.3",
  "thinking": {
    "type": "enabled"
  },
  "reasoning_effort": "max"
}

Z.ai’s migration guide warns users who previously set thinking.type: "disabled" to change that configuration before switching the model ID. Otherwise the request can fail.

Calling the Z.ai API

Z.ai documents compatibility with:

• OpenAI Chat Completions
• OpenAI Responses
• Anthropic Messages

A minimal cURL example:

curl -X POST "https://api.z.ai/api/paas/v4/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ZAI_API_KEY" \
  -d '{
    "model": "glm-5.3",
    "messages": [
      {
        "role": "user",
        "content": "Inspect this repository and propose a verified bug-fix plan."
      }
    ],
    "thinking": {
      "type": "enabled"
    },
    "reasoning_effort": "max",
    "max_tokens": 4096
  }'

The endpoint and parameters are taken from the current GLM-5.3 documentation.

Why the weights are delayed

Z.ai says its cybersecurity capabilities improved faster than expected as post-training scaled.

Its reported scores include:

• CyberGym: 77.2 → 84.5
• ExploitBench: 24.4 → 54.4
• ExploitGym: 29/39 → 105/130 completed tasks at the stated 2h/6h normalized budgets

Because these capabilities can be useful for both defense and offense, Z.ai chose not to publish the weights immediately. The company said on August 14 that weights would follow in roughly two weeks after additional safety evaluation and hardening.

Reuters, WIRED and Axios all covered the delayed open-weight release and the dual-use concern.

Two weeks from August 14 points to roughly August 28, 2026, but that is an inference from Z.ai’s wording rather than a guaranteed release date.

As of August 21, Z.ai’s official Hugging Face organization lists GLM-5.2, GLM-5.1 and GLM-5, but no public GLM-5.3 weight repository.

Can GLM-5.3 run locally on a Mac?

Not yet, because there are no public weights.

Even after release, the full model is unlikely to be practical on a normal Apple Silicon Mac.

Z.ai’s Hugging Face organization lists GLM-5.2 at roughly 753 billion parameters; the official README model spec instead says 744B-A40B — both figures circulate depending on counting method and source. Because Z.ai says GLM-5.3 uses the same base model, that gives a useful order-of-magnitude estimate for raw weight storage. This is not an official GLM-5.3 file-size claim.

Theoretical format	Raw parameter storage at 753B
FP16/BF16	about 1.51 TB
FP8	about 753 GB
4-bit	about 376.5 GB

Runtime overhead, KV cache, metadata and temporary buffers add more memory.

A Mixture-of-Experts model can activate only a fraction of its parameters per token while still requiring the full set of weights to be accessible. Active-parameter count therefore should not be confused with model storage.

For 32 GB or 64 GB Macs, the full GLM-5.3-class model is not a realistic in-memory local target. See the unified-memory guide for Macs for the broader memory constraints. More plausible options would be:

• future distilled variants,
• aggressively compressed derivatives,
• remote inference with a local agent harness,
• server offloading.

A precise local recommendation should wait for the actual model card, weight shards, supported runtimes and quantizations.

GLM-5.3 vs GLM-5.2: Should you switch?

The case for testing 5.3 is straightforward if you already use GLM-5.2: the list price is unchanged and Z.ai reports its largest gains exactly where long-horizon coding users care.

A switch makes sense if you:

• run long coding agents,
• make repository-wide changes,
• rely heavily on terminal tools,
• use large reusable context,
• can benefit from caching,
• already have a GLM-5.2 integration.

It is less attractive if you:

• need reasoning disabled,
• require image or video input,
• only run short cheap text tasks,
• need local weights today,
• require a mature body of independent benchmarks first.

Is GLM-5.3 better than GPT-5.6 Sol, Fable 5 or Kimi K3?

There is no defensible universal answer yet.

Z.ai’s own launch table is mixed:

Benchmark	GLM-5.3	Kimi K3	Fable 5	GPT-5.6 Sol
Terminal-Bench 3.0	28.3	17.4	33.7	34.6
DeepSWE v1.1	66.9	67.5	69.7	72.7
CyberGym	84.5	80.0	83.8	83.6
ExploitBench	54.4	32.2	78.0	76.5
AutomationBench	48.2	46.7	46.2	45.8
Agents’ Last Exam	28.5	27.6	23.8	28.6

GLM-5.3 wins some agent and automation tasks in that table, while other models remain ahead on several coding and exploitation evaluations.

The practical decision should include:

• model quality on your own repositories,
• token use per solved task,
• throughput,
• cache behavior,
• provider reliability,
• agent scaffold.

Who should care about GLM-5.3?

Coding-agent users

This is the primary audience. Long-running engineering tasks are directly aligned with Z.ai’s training strategy.

Teams with large reusable prompts

A 1M context window plus discounted cached input can be useful when a system repeatedly sends repository state, policies and histories.

Security teams

The cyber results are notable, but they need careful governance. Z.ai itself treats the capability as dual use and is staging access.

Existing GLM-5.2 users

The unchanged price and familiar API make 5.3 an obvious A/B-test candidate, provided the reasoning configuration is updated.

What GLM-5.3 is not—yet

As of August 21, 2026, GLM-5.3 is:

• not a public downloadable weight release,
• not a vision model,
• not a model with optional non-reasoning mode,
• not an independently proven universal benchmark winner,
• not a realistic full-model local download for an ordinary Mac.

Those constraints matter more than launch labels because they determine whether the model fits an actual workflow.

Conclusion: A post-training upgrade, not a new architecture

GLM-5.3 is best understood as a post-training upgrade with unusually large reported gains on long-horizon work.

Z.ai did not replace the underlying base model. Instead, it kept scaling executable environments, verifiers and RL. The result looks especially strong on coding agents, terminal tasks, automation and cybersecurity.

The caveat is evidence maturity. The most dramatic scores are still vendor-published, and the model weights remain unavailable. API users can test GLM-5.3 today; local-model users should wait for the actual weight release before drawing conclusions about licensing, quantization, runtime support and memory requirements.