GLM-5.3 Hits the API, and Thinking Is Now Mandatory

GLM-5.3’s direct token-metered API went live on August 18, 2026 at $1.40 input / $4.40 output per million tokens — the same rates GLM-5.2 charged. The model itself launched four days earlier, on August 14, gated behind GLM Coding Plan subscriptions and the ZCode CLI. Nothing about the model changed in between; what changed is who can meter it, and what every integration must now accept: thinking can no longer be turned off.

That last clause is the part most coverage skipped. VentureBeat framed August 18 as a pricing story — the model “has now hit the application programming interface (API),” distinct from its debut the week before. TechNode and others led with a “50% coding gain” headline that, as we’ll show, refers to Z.ai’s own in-house benchmark. Neither walked through what actually breaks when a GLM-5.2 integration points at the new model ID.

This guide is that migration walkthrough: the exact parameter change that hard-fails unmigrated requests, the correct fallback mapping for workloads that used to disable thinking, what the unchanged price sheet does and doesn’t tell you about cost, and how to read benchmark claims where no independent audit exists yet. If you want the model capabilities themselves, start with our August 14 launch coverage of GLM-5.3 — this post picks up where that one left off.

Get the timeline right first, because a surprising amount of secondary coverage gets it wrong. GLM-5.3 launched on August 14, 2026 — Z.ai’s own launch post internally dates its benchmark footnotes to that day. At launch, access ran exclusively through GLM Coding Plan subscriptions and coding agents wired into them — Z.ai’s own ZCode agentic environment, plus third-party harnesses like Claude Code and OpenCode routed through the same plans. Direct pay-per-token API access was not available.

On August 18, that changed: token-metered API pricing went live, and OpenRouter listed z-ai/glm-5.3 the same day (its listing record was created August 18 at 20:57 UTC). VentureBeat covered it that evening as exactly what it was — an access milestone for a model that had already debuted. Nothing about the model’s weights, capabilities, or behavior changed between the two dates, and any write-up implying an August 18 “new model” is simply misreading a listing date as a launch date.

Under the hood, GLM-5.3 uses the same base model as GLM-5.2 — Z.ai states plainly that all improvements come from post-training, not a new pretraining run. The spec sheet on both Z.ai’s docs and OpenRouter’s live record agrees: text-only input, a 1,048,576-token (1M) context window, and a 131,072-token maximum output. OpenRouter’s model description calls it “a large-scale reasoning model from Z.ai, built for complex software engineering and long-horizon agent tasks” — and, notably, independently restates that its built-in reasoning cannot be disabled. Which brings us to the actual story.

Buried under the benchmark charts in Z.ai’s launch post is an “API Changes in GLM-5.3” section that matters more to working teams than any headline score. On GLM-5.2, the thinking.type parameter accepted enabled or disabled — so an integration on a latency-sensitive or cost-sensitive path could opt out of reasoning entirely. On GLM-5.3, that option is gone. The docs list enabled as both the only valid value and the default; disabled is explicitly no longer supported.

The word to take literally is fail. Z.ai’s migration note spells out both the consequence and the fix: “If your application currently uses thinking.type: ‘disabled’, change it to ‘enabled’ and set reasoning_effort to ‘low’ before updating the model ID to glm-5.3. Otherwise, the request will fail.” This is not a soft deprecation where the parameter gets ignored, and not a silent downgrade to some default behavior — the call errors out. Any retry logic wrapping those calls will burn attempts against a request that can never succeed until the payload changes.

In place of the on/off switch, GLM-5.3 exposes a three-rung effort ladder: low (lightweight reasoning), high (enhanced reasoning), and max (deep reasoning). Two details deserve attention. First, there is no medium rung — teams porting effort mappings from vendors whose ladders center on a medium setting have no direct equivalent, a wrinkle we cover across providers in our cross-vendor guide to effort ladders. Second, the default is max — the most expensive, most verbose rung. An integration that omits reasoning_effort entirely inherits the heaviest setting Z.ai offers, which is also the setting Z.ai explicitly recommends for coding tasks. That may be the right call for an agentic coding harness; it is almost certainly not the right default for a high-volume extraction pipeline that used to run with thinking disabled.

No launch coverage we reviewed reproduced the actual before/after parameter behavior, so here it is as a working reference. The GLM-5.3 column and the migration actions come from Z.ai’s API Changes section and the GLM-5.3 developer docs — the vendor’s own guidance in both cases; the GLM-5.2 column is our summary of the behavior those docs replace. If you run GLM through a Claude Code-style harness rather than raw API calls, the same parameter semantics apply — see our guide to running GLM models inside Claude Code for where these settings surface in that setup.

The pattern worth internalizing: this is the reasoning-model direction of travel, not a Z.ai quirk. Vendors are increasingly treating chain-of-thought as a load-bearing part of model quality rather than an optional garnish, and “turn it off for cheap calls” is quietly disappearing as an architectural escape hatch. Teams that structured their routing around a binary thinking switch should expect to redo that work as an effort-ladder mapping — per vendor, because the ladders don’t align.

The price sheet is the least dramatic part of the announcement — deliberately so. GLM-5.3 lands at $1.40 input / $4.40 output / $0.26 cached-read per million tokens, the identical row GLM-5.2 and GLM-5.1 occupy on Z.ai’s live pricing table. (The base GLM-5 line is cheaper, at $1.00 / $3.20 / $0.20 — a different tier, not a discount on 5.3.) VentureBeat’s shorthand: a request consuming a million tokens in and a million out costs $5.80 at list. For how those GLM-5.2 rates originally compared across providers, see our GLM-5.2 API pricing and provider comparison.

Two verification points strengthen the sheet’s credibility. First, there is no OpenRouter markup: the router’s live API record prices the model at exact per-token equivalents of $1.40 / $4.40 / $0.26 per million — matching Z.ai’s list to the cent. Routing through OpenRouter costs the same as going direct. Second, the pricing, context window, and mandatory-reasoning behavior are all independently confirmable from that same machine-readable record rather than only from the vendor’s announcement — worth more than another outlet paraphrasing the press release.

Now the caveat that makes “unchanged pricing” a half-truth: flat per-token rates do not mean flat cost per completed task. Artificial Analysis found GLM-5.3 more verbose than its predecessor — and on a model where thinking can no longer be switched off and the default effort is max, longer completions are structural, not incidental. The same workload that cost X on GLM-5.2 with thinking disabled will consume more output tokens on GLM-5.3 even at identical rates. Budget owners should treat the migration as a rate-stable, volume-inflating event and re-baseline per-task cost after cutover, not before.

One adjacent system to keep separate: alongside the rollout, the GLM Coding Plan subscription moved to a points-based quota with off-peak calls consuming 50% of standard points, and ZCode is running a limited-time 1.5× quota boost through August 31. Those are subscription mechanics — they have nothing to do with the flat per-token API rates above, and conflating the two systems is a recurring error in the secondary coverage.

The launch headline that traveled furthest — a “50% coding gain” — deserves precise handling. Z.ai’s own sentence reads: “GLM-5.3 is the most capable open-weights model for coding, with a 50% improvement over GLM-5.2 on our in-house Z.ai Code Bench.” That one sentence stacks three claims worth separating: the 50% figure comes from Z.ai’s own in-house benchmark, not a public one; the “open-weights” framing describes the model’s announced future release form, not its current status (more on that in the next section); and public-benchmark deltas tell a far less uniform story.

On the public Terminal-Bench suites, Z.ai’s own footnoted table self-reports 88.2 vs 81.0 for GLM-5.3 vs GLM-5.2 on Terminal-Bench 2.1 — a +7.2-point gain — and 28.3 vs 4.6 on the newer, harder Terminal-Bench 3.0, a +23.7-point jump. Gains vary enormously by benchmark version, which is exactly why a single in-house headline number is the wrong summary. And a critical asterisk applies to both rows: neither has an independent cross-check yet.

That leaderboard column is the genuinely underreported data point. The official Terminal-Bench 2.1 leaderboard’s only GLM entry is GLM-5.1, audited at 58.7% — roughly thirty points below the 88%-range scores the 5.x line posts under Z.ai’s own harness configuration (Claude Code 2.1.207, max reasoning effort, 6-hour timeout, all disclosed in the footnotes). That gap doesn’t prove the self-reports are wrong — harness, effort setting, and timeout legitimately move terminal-agent scores — but it does mean every GLM-5.3 Terminal-Bench number in circulation is a vendor self-report until an audited entry lands.

To Z.ai’s credit, its benchmark footnotes are unusually rigorous for a vendor blog — harness version, temperature, output budget, timeout, and judge model disclosed per benchmark, with two evaluations explicitly run by third parties (GDPval-AA v2 by Artificial Analysis; FrontierSWE by Proximal). Everything else is vendor-run. For a third-party signal published outside Z.ai’s own benchmark table, the numbers to reach for are the Artificial Analysis indices carried in OpenRouter’s own model record:

The coding index leading the trio is consistent with what Z.ai optimized for — but note these are Artificial Analysis’s scores surfaced by OpenRouter, not Z.ai figures, and AA is also the source of the verbosity finding from the pricing section. The honest read for a team lead: GLM-5.3 is plausibly a meaningful coding upgrade over GLM-5.2, the magnitude is unverified outside the vendor’s own harness, and the only audited public leaderboard entry for the family remains a much older model. Run your own evals before repricing any routing decision on these numbers.

A correction several model aggregators already need: as of its API launch, GLM-5.3 is not an open-weight model. The weights have not shipped. Z.ai’s own commitment is explicit and future-dated: “We will release the weights in two weeks after launch, once safety evaluation and hardening are complete” — putting the target around August 28, announced but not delivered. Listings that already file GLM-5.3 under open models are premature.

The reason for the delay is more interesting than a routine legal review. The same launch post documents at length what Z.ai calls the model’s emergent cyber capability — including that security teams running it against real-world codebases surfaced 2,436 candidate vulnerabilities across 269 open-source projects after expert screening, over a thousand of them rated medium-to-high severity. Weights you can download are weights whose safety mitigations you can remove; holding the release until a safety evaluation of exactly that capability completes is the connective tissue between those two sections of the announcement.

Pulling the threads together: the API opening makes GLM-5.3 meterable for the first time, the mandatory-thinking change decides how much migration work that takes, and the verbosity finding decides what it costs. Here’s how the decision falls for the four situations we see most often.

The projection we’d make: mandatory reasoning will look less like an outlier and more like a template. Post-training investment is now where model quality comes from — GLM-5.3 itself is the same base model as 5.2, improved entirely in post-training — and vendors protecting that investment have every incentive to stop letting callers switch the reasoning layer off. Migration playbooks like this one stop being release-notes trivia and become recurring engineering work. If your team wants help building the eval harnesses and routing architecture that make model swaps like this a one-day exercise instead of a quarter-long scramble, that’s exactly what our AI transformation engagements are built around.