glm-5.3: the GLM 5.3 flagship model on IronStratum

glm-5.3 is this platform's alias for GLM 5.3, the flagship of Z.ai's GLM 5.3 family. It is a text-only reasoning model tuned for complex coding and long-horizon agent work. It carries a 1M-token context window and a thinking pass on every call that cannot be switched off. Z.ai launched it on August 14, 2026, and posted the weights about two weeks later. On this platform the glm-5.3 model id answers directly: a September 24, 2026 request returned a 200 response with a full usage block. It is listed in the models index and on the pricing page as of September 25, 2026. This page maps the family's three public names so a search result or a price list cannot mislead you. It gives the model's identity facts with their owners and the exact call shape that works on the route. It also carries the benchmark record with every number labeled by who ran it, and the honest local option for readers with the hardware for it. Access runs through the console's invite flow while the platform is in beta.

Last verified: 2026-09-25

What it is

The release story explains the model. Z.ai's launch post puts the thesis in one line. GLM-5.3 uses the same base model as GLM-5.2, and every gain comes from post-training. Z.ai kept the GLM-5.2 architecture and scaled the training environments toward tasks it describes as real units of expert work, some worth days of an experienced engineer's time. It then let the post-training run longer on that harder curriculum. The official documentation sums up the result. It reports gains across complex software engineering and agent work, with the largest jumps on long-horizon and terminal tasks.

The facts that matter for planning, each with its owner:

The three names, mapped

The GLM 5.3 name family is the single biggest source of confusion around this model. Three different things carry the family name, and search results mix them freely.

The decision rule in plain words. If a page or listing shows image or video input, it is describing Flash, not this model. If it quotes 320B parameters, that is Flash. If it names a separate flashx code, that is a serving tier of the Flash weights. It exists only on Z.ai's own platform. And a newer tier-style listing of the flagship has begun appearing on third-party catalogs with a throughput claim attached. Z.ai's own documentation index carries no such model at this page's verification date. So treat tier-style codes as serving configurations rather than models. The GLM 5.3 Flash page documents the Flash and FlashX side of the family in full. That includes the trap of quoting a Flash price as if it were the flagship's.

One more family fact settles most price confusion. On Z.ai's coding plan, the Flash model carries three times the flagship's quota. That tells you which one the publisher positions for volume work.

Size, context, and output

The geometry, in plain language. The base is a mixture-of-experts design. Hundreds of expert networks sit on disk, and each token consults only a slice of them, about 40B of a 744B-class total per Unsloth's guide. That is why a model this large serves at all. Z.ai's own release pages do not state a parameter count. Unsloth's figure matches the documented same-base-as-GLM-5.2 relationship. Distribution pages vary slightly in how they count the total, so treat the size as 744B-class rather than an exact figure.

The window has one units wrinkle. The docs describe a 1M-token context and the card's configuration sets 1,048,576. Some host catalogs list a larger 1.25M-class figure, and at least one host caps its cloud listing at 500K. Treat the 1M class as the rated ceiling and check the served window on whatever host you use. Output room is 128K tokens per call. That matters here because thinking tokens count against it.

Thinking is the contract

Thinking is not a feature you toggle; it is the model's operating mode. Z.ai's documentation states GLM-5.3 always operates with reasoning enabled and that disabling reasoning is no longer supported. The thinking-mode guide repeats the law for both GLM-5.3 and GLM-5.3-Flash. Two consequences follow. First, a migration trap. An application that sends the older thinking type disabled will have its request fail against glm-5.3. Z.ai's documented fix is to switch the type to enabled and set reasoning effort to low. Second, a budgeting fact. The controllable knob is effort, low, high, or max, and it defaults to max. Every call carries a full reasoning pass unless you ask for less. Z.ai recommends max for coding work; lower effort is the speed lever when a task does not need it.

The model answers to glm-5.3 on this platform's chat endpoint: the id serves, confirmed by the September 24, 2026 request, and the row is listed in the public catalog. The flash sibling serves alongside it as a listed model, the chat category covers the family's hosted catalog, and the models index reflects the catalog as it stands.

Use cases

The publisher's positioning translates into concrete jobs:

• Hard agentic coding. Multi-step coding inside agent harnesses is the center of gravity: the model was tuned on environments Z.ai describes as real units of engineering work, and the biggest applications routing traffic to it on public catalogs are agentic coding tools.
• Long-horizon agent runs. Tasks measured in many tool calls and long sessions are the flagship's stated strength over its predecessor, with reinforcement learning strategies carried over from GLM-5.2 to hold performance on long tasks rather than only short ones.
• Defensive security and vulnerability analysis. Z.ai reports the model as the best performer to date on the CyberGym vulnerability-discovery benchmark, with gains that grow along the exploitation chain. This is the publisher measuring on benchmarks it names, with rivals ahead of it on the harder exploitation rows; read the benchmark section before staffing security work on it.
• Long-context analysis. The 1M-class window holds project-scale codebases and long document sets in one context, and the attention design inherited from GLM-5.2 exists to keep that window affordable.
• Effort-tuned workloads. The low, high, max effort knob lets one model serve both quick passes at low effort and deep reasoning at max, trading time per task against quality per answer.

What it is not for, first, is any image, video, or audio input. The model is text-only, and the family's multimodal member is Flash. It is also not for high-volume work where per-token cost dominates; independent comparisons read in September 2026 put the Flash sibling at roughly one-ninth of the flagship's list price. And it is not for instant factual lookups, since the forced thinking pass adds latency to every call.

Local or hosted: the honest split

The weights are downloadable under Z.ai's own GLM-5.3 license, which reads as MIT-style permission with one condition. Operators of model-as-a-service businesses above a stated revenue threshold must pass Z.ai's security review first. Read the license before you build a business on the weights.

Run it locally when the machine is in the 223GB class or above. Unsloth's local guide puts the floor at its dynamic 1-bit build, about 223GB of combined memory, keeping roughly 76 percent top-1 accuracy by their measurement. A 2-bit build lands at 245GB-class machines keeping about 81 percent, and an 8-bit build wants around 810GB. Recipes exist for vLLM, SGLang, Transformers, KTransformers, TokenSpeed, and llama.cpp-class stacks. Ollama distributes the model. For scale, this is roughly double the local floor of the Flash sibling and far above small open models. It is a serious-hardware project, not a laptop exercise.

Call the hosted route when there is no quarter-terabyte machine to dedicate or traffic comes in bursts. It also wins when you want metering, revocation, and a billing ledger wrapped around the model instead of a serving stack to own. On this platform the glm-5.3 id serves today, the call shape is the one shown below, and the wallet, keys, and billing side are the same surfaces every other model on the platform uses. The rate renders on the pricing page. During the beta, the console's invite flow is how access runs.

Use the publisher's own service when Z.ai's bundle fits better than per-token metering. Z.ai serves the model on its API and its GLM Coding Plan. The plan is a points-based quota where off-peak hours, including weekends, consume half points. Those are Z.ai's terms and Z.ai's metering, priced on their pages, not here.

API usage

The route is POST /v1/chat/completions at https://api.ironstratum.com/v1, OpenAI-compatible in shape, your console Bearer key in the header, and the model id is glm-5.3, the same string Z.ai's own API uses. The id serves on this platform, confirmed by the September 24, 2026 request, and the API reference carries the full route contract.

Four laws of this route that save planning time:

1. The examples carry no thinking knob, on purpose. Z.ai documents the controls on its own API: a thinking type that only accepts enabled because reasoning is forced, and reasoning effort at low, high, or max, defaulting to max. This platform's route accepts the standard OpenAI-compatible parameter surface; the tabs stay minimal so they show only what is guaranteed.
2. Thinking tokens are real output. Forced thinking at the default max effort means every call generates a reasoning pass before its answer, and that pass draws down the same 128K output room. Budget output headroom and client timeouts accordingly, and lower the effort for work that does not need deep reasoning.
3. Metering is the wallet law. Calls meter per token against a prepaid wallet, and the refusal lands at the door: past an empty balance, any new request is turned away with a named error before work begins, and refused requests bill nothing. Every response carries a usage object with a cost field, keys are revocable the moment one leaks, and per-key spend caps are on the roadmap rather than shipped. This model's rate renders on the pricing page as of September 25, 2026, and pages like this one never type rates by hand.
4. Long context is a long request. A 1M-class window invites whole-project prompts, and a deep fresh context plus a max-effort reasoning pass is a request measured in minutes. Stream the response and set client timeouts with headroom.

curl

curl -X POST "https://api.ironstratum.com/v1/chat/completions" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3",
    "messages": [
      {"role": "user", "content": "Trace this crash across the service boundaries and propose a fix with a test plan."}
    ],
    "max_tokens": 16384
  }'

python

import os
import requests

resp = requests.post(
    "https://api.ironstratum.com/v1/chat/completions",
    headers={"Authorization": "Bearer " + os.environ["KEY"]},
    json={
        "model": "glm-5.3",
        "messages": [
            {"role": "user", "content": "Find the race condition in this worker pool design."},
        ],
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "read_log",
                    "description": "Read a service log file",
                    "parameters": {
                        "type": "object",
                        "properties": {"path": {"type": "string"}},
                        "required": ["path"],
                    },
                },
            }
        ],
        "tool_choice": "auto",
        "max_tokens": 16384,
    },
    timeout=1800,
)
resp.raise_for_status()

message = resp.json()["choices"][0]["message"]
if message.get("tool_calls"):
    call = message["tool_calls"][0]
    print(call["function"]["name"], call["function"]["arguments"])
else:
    print(message["content"])
print("cost:", resp.json()["usage"]["cost"])

openai-sdk

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.ironstratum.com/v1",
    api_key=os.environ["KEY"],
)

response = client.chat.completions.create(
    model="glm-5.3",
    messages=[
        {"role": "user", "content": "Review this migration plan and list what it breaks."},
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=16384,
)

print(response.choices[0].message.content)
print("cost:", response.usage.cost)

An OpenAI-SDK integration you already run ports with two edits. Change the base URL and the model id.

Benchmarks

This model has no measurements from this platform yet. This section carries only sourced and dated numbers, each labeled by who ran it. All publisher rows below are Z.ai's own runs from the launch materials. The harness configurations are documented on the model card, read at this page's verification.

Two publisher claims need their labels kept on. The coding claim: a 50 percent gain over GLM-5.2 on Z.ai Code Bench, its in-house benchmark. There the model reaches 34.5 percent at max effort using roughly 75K output tokens per task, against GLM-5.2's 23.4 percent at 96K. At high effort it scores 31.4 percent, ahead of Claude Opus 4.8's 29.5, while Claude Fable 5 stays ahead at 39.5. Z.ai also calls its scores the best among open-source models on Terminal Bench 3.0 and Agents' Last Exam. Those are the publisher's runs against the publisher's chosen baselines.

Independently labeled rows. The model's page on a third-party catalog carries benchmark metrics sourced from Artificial Analysis, dated to this page's verification. The set includes an intelligence index of 44.8, a coding index of 74.8, an agentic index of 53.1, GPQA Diamond at 91.7 percent, HLE at 42.3 percent, and SciCode at 59.0. The same independent index characterizes the model as among the leaders in intelligence. It also calls it expensive next to open-weight rivals of similar size, slower than average, and very verbose. That profile is consistent with forced thinking at the default max effort.

Read both sets with their labels on. The publisher rows ran on harnesses Z.ai configured with methodology on the card. The independent rows come from one index whose characterization is qualitative. And rivals stay ahead on the exploitation benchmarks, where Z.ai's own table shows other models above it. None of this settles a workload question; it defines the evidence. Run the model on your own tasks, on any host, before committing.

Getting started

1. Request access through the console's invite flow. While the platform is in beta that flow is the only way in; start on the signup page, and the console is what holds your wallet, your keys, and the served model catalog.
2. Create an API key when your account is in. The working pattern is a key per project, each revocable on its own so a leaked one costs nothing but itself; the wallet balance is the only spend ceiling shipping today, per-key caps being roadmap.
3. Check the rate. The model's rate is on the pricing page as of September 25, 2026, and the usage object on every response keeps score from your first call.
4. Make the first call. Grab the curl tab, put KEY in your environment, and send one small request at low effort settings first if you are watching latency.

The chat category page rounds out the chat catalog, and the models index tracks the served lanes. If your work is volume-shaped, the GLM 5.3 Flash page describes the cheaper sibling this platform lists today.