glm-5.3-flash: the GLM 5.3 Flash model, served on IronStratum

glm-5.3-flash is this platform's alias for GLM 5.3 Flash, the open-weight multimodal model Z.ai released on August 26, 2026. It is a 320 billion parameter mixture-of-experts model that activates 18 billion parameters per token, reads text, images, and video in one window, and ships under an MIT license. It is served on this platform's chat endpoint: the registry row is live with its retail from day one, and the route answers the alias today. This page gives the model's identity facts with their owners, the exact call shape that works on the route, the benchmark record with every number labeled by who ran it, and the honest local alternative for readers with serious hardware. Access runs through the console's invite flow while the platform is in beta.

Last verified: 2026-09-11

What it is

The model arrived with an unusual story. Before release, Z.ai served it anonymously as ox-alpha on third-party inference platforms to gather user feedback. Z.ai says it became the most popular model of the week under that name, with all of that traffic served on Chinese AI chips, and then confirmed the identity: as the platform page puts it, "OX Alpha was the internal testing name for GLM-5.3-Flash." The reveal closed a weekend of public guessing over who owned the anonymous model, and the release pulled dedicated megathreads across the community forums that had hosted the guessing.

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

The geometry deserves one paragraph in plain language. A mixture-of-experts model keeps 320 billion parameters on disk but consults a small slice per token, 18 billion of them, which is why a model this large can serve at a running cost its total size would not suggest. The attention design is the second half of the trick: most layers use linear attention, which summarizes what has been read into a running state, and a minority use sparse attention, which looks up only the relevant earlier tokens instead of re-reading everything. Z.ai's documentation quantifies the result against the GLM-5.3 flagship: 3.01x less attention compute and 4.44x smaller key-value cache, the memory that holds prior tokens during generation. Compared with GLM-4.5, it nearly halves active parameters and layer count at similar total size, 45 layers against 92. Training used a 30-trillion-token multimodal corpus, and the weights ship with a multi-token prediction layer that serving engines use for speculative decoding.

One naming note saves confusion. In earlier GLM generations, full, Air, and Flash named progressively smaller models, so "Flash" meant small. GLM 5.3 Flash is far larger than any earlier Air or Flash. The word now marks the cost tier under the GLM-5.3 flagship: same family, redesigned for cheap serving. Community threads flagged the confusion in the release week, and the parameter counts above are the resolution.

The context window has a small units fog worth clearing. The card's configuration sets 1,048,576 tokens, the docs describe it as a 1M-token window, and some host catalogs list 1,310,720, a 1.25M-class figure that reflects serving variants rather than the card. Z.ai's own evaluations ran at 300,000 tokens for text tasks and 164,000 for vision, with context management. Treat the 1M class as the rated ceiling and check the served window on whatever host you use.

Thinking is the model's defining behavior. It is always on: Z.ai's thinking-mode documentation states GLM-5.3-Flash uses forced thinking and cannot have it disabled. The controllable part is effort. The model card documents a reasoning_effort parameter with three levels, low, high, and max, defaulting to max. The model also does interleaved thinking, reasoning between tool calls, and preserved thinking, keeping prior reasoning in context across coding turns, which raises cache hit rates. Z.ai's recommended settings are temperature 1.0, top_p 0.95, and max effort on its own API. The practical consequence: every call carries a reasoning pass, so the model is cheap per token but spends real time per task at the default setting.

The model answers to glm-5.3-flash on this platform's chat endpoint today, alongside the rest of the chat catalog. The models index reflects the catalog as it stands.

Use cases

The publisher's positioning translates into concrete jobs:

• Agentic coding. Sustained, multi-step coding inside agent harnesses is the center of gravity: the model was tuned for long tool chains, and the biggest applications routing traffic to it on public catalogs are coding agents and terminal-driven tools.
• GUI and computer-use work. The docs describe visual capabilities built into the coding loop: the model observes interfaces, rendered results, and interaction feedback, then iterates, coordinating work across code, browsers, and GUIs.
• Document and office workflows. Z.ai lists professional work beyond coding: research and analysis carried through to finished PPTX, PDF, DOCX, and XLSX deliverables, with the model breaking down goals, invoking tools, and reviewing its own output.
• Multimodal understanding. Images and video enter the same window as text, so screenshots, charts, and interface captures can be part of a coding or analysis conversation rather than a separate pipeline.
• Long-context projects. The 1M-class window holds project-scale codebases and long sessions, with the attention architecture keeping the cost of that window lower than a conventional design would.

What it is not for: instant factual lookups, since forced thinking adds a reasoning pass to every call; audio of any kind; and per-turn thinking on/off control, which is a capability Z.ai introduced on the GLM-4.7 generation, not this one.

Local or hosted: the honest split

The weights are open, so running it yourself is a real option with real constraints.

Run it locally when the machine has 100 GB or more of combined memory and the willingness to tune. The main weight release is FP8 at roughly 330 GB; a separate BF16 build runs about 640 GB. Unsloth's local guide brings the floor down with dynamic quantization: a 1-bit build at about 93 GB that fits 100 GB-class machines, keeping 71 percent of its accuracy on the hardest one percent of tasks by their measurement, and a 3-bit build for 128 GB setups that keeps 87 percent. Community reports from the first weeks agree on the shape: a 128 GB unified-memory workstation runs low quants at usable speeds, while older large-memory desktops wait minutes for the first token. Launch support exists for vLLM, SGLang, KTransformers, and llama.cpp-class stacks, with official recipes per framework.

Call the hosted route when there is no 100 GB machine to dedicate, traffic comes in bursts, or you want metering, revocation, and a billing ledger wrapped around the model instead of a serving stack to own. On this platform that route is open: the registry row is live with the model's retail, 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. Access runs through the console's invite flow while the platform is in beta.

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 subscription, and its documentation notes the plan carries the model with three times the quota of the GLM-5.3 flagship, under a points system 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; this platform's route is the plain per-token alternative.

API usage

The route is POST /v1/chat/completions, OpenAI-compatible in shape, your console Bearer key in the header, and the model id is glm-5.3-flash, the same string Z.ai's own API uses. The route is live; the examples below are the exact shape that works today.

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: reasoning_effort at low, high, or max, and a thinking type that only accepts enabled because thinking is forced. This platform's route accepts the standard OpenAI-compatible parameter surface, and the effort control is not part of it; the tabs stay minimal so they show only what is guaranteed.
2. Thinking tokens are real output. Forced thinking means every call carries a reasoning pass, and that pass is generated tokens. Budget output headroom and client timeouts accordingly, especially at the default max effort.
3. Metering is the wallet law. Calls are metered 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. 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. Rate numbers live on the pricing page, rendered from the catalog, never typed into pages like this one.
4. Long context is a long request. The 1M-class window invites whole-project prompts; a deep fresh context plus a max-effort reasoning pass is a request measured in minutes on some hosts. 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-flash",
    "messages": [
      {"role": "user", "content": "Review this Python module for race conditions and list each one with a fix."}
    ],
    "max_tokens": 2048
  }'

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-flash",
        "messages": [
            {"role": "user", "content": "Find the failing edge case in this test plan."},
        ],
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "read_file",
                    "description": "Read a file from the workspace",
                    "parameters": {
                        "type": "object",
                        "properties": {"path": {"type": "string"}},
                        "required": ["path"],
                    },
                },
            }
        ],
        "tool_choice": "auto",
        "max_tokens": 2048,
    },
    timeout=600,
)
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-flash",
    messages=[
        {"role": "user", "content": "Summarize the risks in this deployment checklist."},
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=2048,
)

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

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

Benchmarks

This model has no measurements from this platform yet, so this section carries only sourced and dated numbers, each labeled by who ran it.

Publisher-run results. From Z.ai's release materials, with the harnesses named on the model card.

Independently labeled rows. The model's page on a third-party inference marketplace carries benchmark metrics sourced from Artificial Analysis, dated to this page's verification: GPQA Diamond 91.2, Humanity's Last Exam 39.9, AA long-context reasoning 80.0, GDPval-AA 58.5, SciCode 51.6, and an AA-Omniscience non-hallucination rate of 72.4.

Read both tables with their labels on. The publisher rows are Z.ai's own runs against Z.ai's chosen baselines, with methodology documented on the card, and the independent rows come from a third-party index whose version has moved past the one Z.ai quoted, so the two sets are not interchangeable. Community discussion after release added the operational trade: the model is inexpensive per token but, at default max effort, spends enough thinking time that some testers report it running several times slower per task than rivals tuned for speed. The effort control is the lever. 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, 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 pricing page shows the rate, and the cost field on every response keeps score while you work.
4. Make the first call. Grab the curl tab, put KEY in your environment, and send one small request.

The chat category page rounds out the chat catalog, and the models index tracks every served lane.