GLM-5.3-Flash is a natively multimodal mixture-of-experts model from Z.ai (Zhipu AI), released on August 26, 2026 with open weights under the MIT licence. It has 320 billion total parameters with 18 billion active per token, a long-context design; the current OpenRouter top-provider route exposes 1,048,576 tokens, and it accepts text, images and video. It is also the model that spent the previous six days running anonymously on OpenRouter as the stealth listing Ox Alpha, where it became the platform’s most-used model before anyone knew whose it was.
This page is the full reference: specifications, what the architecture actually buys you, benchmarks with independent measurement set against vendor claims, real pricing including the live provider spread, every route to running it, and an honest account of the workloads it suits badly.
Specifications
| Model ID | z-ai/glm-5.3-flash (OpenRouter) · glm-5.3-flash (Z.ai API) |
| Former ID | stealth/ox-alpha — retired Aug 26, 2026, no redirect |
| Developer | Z.ai (Zhipu AI) |
| Released | August 26, 2026 |
| Total parameters | 320B |
| Active per token | 18B (8 of 288 routed experts, plus 1 shared expert) |
| Layers | 45 — 34 linear attention, 11 sparse attention |
| Current OpenRouter top-provider context | 1,048,576 tokens; platform-level model metadata may report 1,310,720 depending on provider |
| Max output | 131,072 tokens |
| Input modalities | Text, image, video |
| Output modalities | Text only |
| Audio | Rejected |
| Languages | English, Chinese |
| Published weights | FP8 (E4M3) with dynamic activation scaling — ~328 GB. Attention, embeddings and lm_head are held at higher precision. |
| Vocabulary | 154,880 tokens |
| Reasoning | Mandatory. reasoning_effort accepts low, high, max; defaults to max |
| Tool use | tools, tool_choice, response_format, structured outputs |
| Also supported | temperature, top_p, top_k, min_p, seed, logprobs, logit_bias, stop, penalties |
| Weights | zai-org/GLM-5.3-Flash on Hugging Face — MIT licence |
| Technical report | arXiv 2602.15763, “GLM-5: from Vibe Coding to Agentic Engineering” |
One default worth knowing before your first call: in the chat template, clear_thinking is false unless you pass it. Z.ai’s own guidance is to pass clear_thinking=true for chat use cases. If your first integration returns reasoning traces you did not expect, that is why.
Architecture: what 320B / 18B actually buys
The headline numbers are easy to misread. 320 billion parameters sounds like a frontier-scale model and 18 billion sounds like a small one. Both are true, and the gap between them is the entire design.
Sparsity: capacity you store, compute you skip
GLM-5.3-Flash is a mixture of experts. Its feed-forward layers are split into 288 routed experts plus one shared expert, and for any given token a router selects just eight of them. The other 280 sit idle for that token.
The practical consequence is a split between two costs that people usually conflate. Memory scales with total parameters, because every expert must be resident and ready in case the router picks it. Compute scales with active parameters, because only the chosen eight actually run. So you pay 320B-scale storage for 18B-scale arithmetic — which is why the model is cheap to serve and fast to respond despite its size, and equally why self-hosting it needs a great deal of memory even though the per-token work is modest.
This is what “Flash” means here, and it is worth being precise about, because in most model families that word signals a distilled or quality-reduced variant. It does not here. GLM-5.3-Flash is not a shrunk-down version of something bigger; it is a full model whose efficiency comes from sparsity. That is how a Flash-class release spent six days topping OpenRouter’s usage charts while everyone assumed they were using a frontier model.
Hybrid attention: why the million tokens are usable
Long context is easy to advertise and hard to deliver, because standard attention costs scale with the square of sequence length. Double the input and you roughly quadruple the attention work. This is why plenty of models with large advertised windows degrade badly in the upper half of them, or price long requests punitively, or both.
Z.ai’s answer is a hybrid. Of the model’s 45 layers, 34 use linear attention and 11 use sparse attention, arranged in a repeating pattern of three linear layers followed by one sparse layer. Linear attention scales proportionally with sequence length rather than quadratically, which is what makes a million tokens tractable at all; the periodic sparse-attention layers preserve the precise long-range lookups that pure linear attention tends to blur. Roughly speaking, the linear layers carry the context cheaply and the sparse layers do the exact retrieval.
Z.ai describes this as sharply reducing long-context serving costs while preserving precise long-context capability, and it also reports a scaling technique it calls Manifold-Constrained Hyper-Connections, with pre-training on a 30-trillion-token multimodal corpus. Those last two are vendor descriptions we cannot independently verify; the layer composition above is read directly from the published configuration.
What this means when you use it: long-context requests are not a premium feature to be rationed. Filling a large fraction of the window is a normal thing to do with this model rather than an expensive edge case, which is the opposite of the instinct most people have developed working with other long-context models.
Native multimodality
Image and video understanding are built into the base model rather than bolted on through a separate encoder pipeline — Z.ai calls this the first natively multimodal model in the GLM-5 series, and the published configuration does carry a vision component within the model itself. Practically, that means screenshots, diagrams, UI mockups and short clips are ordinary inputs rather than a special path. Audio is rejected.
Benchmarks
Two kinds of evidence, kept visibly separate — because a vendor’s own launch numbers and an outside evaluator’s measurements are not interchangeable, however much benchmark tables like to mix them.
Independent measurement
Artificial Analysis — third party, read live from the OpenRouter listing
- Intelligence Index
- 57.5
- Coding Index
- 71.5
- Agentic Index
- 58.2
Vendor claims
Z.ai — self-reported at launch, not independently reproduced
- DeepSWE v1.1
- 63.4
- AutomationBench
- 48.8
- Terminal Bench 2.1
- 84.3
The independent indices put GLM-5.3-Flash clearly ahead of the previous generation on all three measures, with the agentic index rising most — a pattern that matches Z.ai’s own claimed AutomationBench jump. Against its larger text-only sibling z-ai/glm-5.3, Flash trails on coding by a few points but comes within a point on agentic, at a fraction of the price.
The most useful corroboration is accidental. During the stealth preview, an independent tester ran the full 113-task DeepSWE set against a model whose owner nobody knew and measured roughly 63%. Z.ai’s published DeepSWE v1.1 figure is 63.4. A vendor number matching what a stranger measured blind is far better evidence than either number alone. Full methodology, caveats and the story of the viral “80%” that turned out to be a ten-task subset are on the benchmarks page.
Pricing
| Per 1M tokens | Promotional — until Sept 9, 2026 | List — from Sept 10 |
|---|---|---|
| Input | $0.075 | $0.15 |
| Cached input | $0.015 | $0.03 |
| Output | $0.25 | $0.50 |
The cached-input rate is the number that matters
Cached input costs one fifth of ordinary input. On a model with a million-token window that is not a detail, it is the difference between a workflow that makes economic sense and one that does not.
Caching works on a stable prefix, so the design rule is simple: put the unchanging material first and vary only the tail. Send the repository, the specification set or the document corpus once, then ask many questions against it. Rebuilding the prompt each turn, or putting the variable part at the top, throws the discount away.
A worked example
Take a coding assistant reviewing a 300,000-token codebase, answering 40 questions across a working day, producing about 3,000 tokens per answer. The first call pays full price on the context; the remaining 39 hit the cache.
- First call, 300K input at $0.075/M: $0.023
- 39 cached calls, 300K each at $0.015/M: $0.176
- 40 answers, 3K output each = 120K at $0.25/M: $0.030
- Total for the day: about $0.23
Roughly twenty-three cents, or about forty-six after the promotion ends. Without prefix caching the same day would cost about $0.93 — just over four times as much for identical work, which is why prompt ordering deserves more attention than it usually gets. More scenarios are on the pricing page.
What the providers actually charge
Because the weights are openly licensed, Z.ai is not the only place to buy inference. A dozen providers now serve this model on OpenRouter at prices they set themselves, and OpenRouter fails over between them when one errors.
| Provider | Input / 1M | Output / 1M | Cached input / 1M | Status |
|---|---|---|---|---|
| GMICloud | $0.075 | $0.25 | $0.015 | Degraded |
| Novita | $0.075 | $0.25 | $0.015 | Serving |
| Z.AI | $0.075 | $0.25 | $0.015 | Serving |
| Modal | $0.15 | $0.5 | $0.03 | Degraded |
| BaseTen | $0.15 | $0.5 | $0.03 | Serving |
| Cloudflare | $0.15 | $0.5 | $0.03 | Serving |
| DeepInfra | $0.15 | $0.5 | $0.03 | Degraded |
| Io Net | $0.15 | $0.5 | $0.03 | Degraded |
| Parasail | $0.15 | $0.5 | — | Serving |
| Reka | $0.15 | $0.5 | $0.03 | Serving |
| Together | $0.15 | $0.5 | $0.03 | Serving |
| Venice | $0.15 | $0.5 | $0.03 | Degraded |
How to access it
Three routes, each with a case for it.
- OpenRouter — model ID
z-ai/glm-5.3-flash, OpenAI-compatible endpoint athttps://openrouter.ai/api/v1. Best when you want competitive pricing across providers, automatic failover, and the ability to switch models without changing integration code. See the API guide. - The Z.ai API directly — model ID
glm-5.3-flash, documented at docs.z.ai. Best when you want first-party support, the vendor’s own rate limits and no intermediary in the path. - Self-hosted — the MIT-licensed weights, served through SGLang, vLLM, TokenSpeed, KTransformers, Transformers or Unsloth. Best when data cannot leave your infrastructure, or when your volume is high enough that fixed hardware beats per-token billing. See the self-hosting guide for hardware requirements and a breakeven analysis.
You can also use it in Cursor, Cline, Continue, Aider and similar tools, or try it in the browser chat on this site with your own OpenRouter key.
What to expect when you call it
Three behaviours surprise people on first contact, and none of them is a fault.
There is a pause before the first token. Reasoning is mandatory on this model and enabled at max effort by default, so it thinks before it answers — every time, including on trivial prompts. If your integration looks frozen for a few seconds, it is almost certainly working. Dropping reasoning_effort to low shortens the pause substantially and is the right default for simple edits, classification and extraction; keep max for debugging, refactors and multi-step agent work. This single parameter has more effect on perceived speed than anything else you can change.
Performance varies by provider. Because a dozen independent hosts serve the same weights, throughput and time-to-first-token depend on which one takes your request, and OpenRouter’s default routing optimises for price rather than speed. Providers also differ in the maximum output they will accept — the table above shows several serving far more than the 131,072 tokens Z.ai’s own endpoint offers, and one capped well below it. If you need a specific ceiling or consistent latency, pin the provider rather than accepting the default route. We deliberately do not publish fixed latency or throughput figures here, because they are a property of whichever provider served the request, not of the model.
Failover is automatic, and quiet. When a provider errors or goes degraded, OpenRouter routes the request to another healthy one. That is why an individual provider showing as degraded in the table above is not an outage for you. It also means the price you pay can shift slightly between requests, since you may be served by a host on a different tier — worth knowing if you are reconciling a bill against an expected per-token rate.
Who it is for — and who it is not
Most model pages stop at the strengths. The failure modes are more useful.
Good fits
- Long-horizon coding. Debugging with the surrounding repository in context, refactors spanning many files, reviewing a change against the whole codebase. This is the workload the architecture and the benchmarks both point at.
- Agentic loops. Tool calling, structured output and a very large window suit multi-step agents that accumulate long tool-result histories — the exact scenario where smaller windows force forgetting.
- Whole-corpus analysis. Long specification sets, contract stacks, transcript archives. Ask across all of it rather than building a retrieval pipeline first.
- High-volume batch work. Classification, extraction and summarisation at scale, where cost per token dominates the decision.
- Workloads with a hard data-residency constraint. The MIT licence makes self-hosting a real option rather than a theoretical one.
Poor fits
- Latency-sensitive short chat. This is the big one. Reasoning is mandatory and defaults to
maxeffort, so even a trivial prompt thinks before it answers. For a snappy support widget that is simply the wrong shape of model. Settingreasoning_efforttolowhelps considerably, but you cannot switch reasoning off. - The hardest frontier reasoning. On the most difficult problems, flagship models from the major commercial families remain ahead. Flash is efficient, not frontier, and Z.ai does not claim otherwise.
- Audio. Rejected outright. Transcribe first.
- Languages beyond English and Chinese. Those are the two the model card lists. Others may work; they are not what it was built and evaluated for.
- Anything needing an enterprise support contract with the model’s developer. That ecosystem does not exist here the way it does around the incumbent commercial families.
The Ox Alpha origin
From August 20 to August 26, 2026 this model ran on OpenRouter as stealth/ox-alpha, with no developer named and no pricing. It became the platform’s most-used model during that window. Independent testers identified the GLM family days before any announcement, working from tokenizer offsets, video token consumption and a characteristic error code rather than from anything the model could do.
That preview is why the launch benchmarks are more trustworthy than most: a large volume of real evaluation happened while nobody knew whose model was being evaluated. The full story is in Ox Alpha revealed as GLM-5.3-Flash, and the fingerprinting evidence ledger is on who made Ox Alpha.
Frequently asked
What is GLM-5.3-Flash?
A natively multimodal mixture-of-experts model from Z.ai with 320B total parameters, 18B active per token, a 1,048,576-token context window and openly licensed weights. It is built for efficient coding and long-horizon agent work.
Is GLM-5.3-Flash open source?
The weights are published on Hugging Face as zai-org/GLM-5.3-Flash under the MIT licence, which permits commercial use, modification and redistribution. That is an open-weights release under a permissive licence; the training data and pipeline are not published.
How much does GLM-5.3-Flash cost?
$0.075 per million input tokens, $0.015 cached, $0.25 output — promotional until September 9, 2026, then $0.15 / $0.03 / $0.50. Independent providers on OpenRouter set their own prices, listed live above.
Is GLM-5.3-Flash the same as GLM-5.3?
No. They are different models in the same family. Flash is multimodal, far cheaper and openly licensed; z-ai/glm-5.3 is a larger text-only reasoning model at a considerably higher price per token, scoring a few points higher on coding but barely ahead on agentic tasks.
Can I turn off reasoning?
No. Reasoning is mandatory and defaults to max effort. You can reduce it to high or low with reasoning_effort, which noticeably shortens the pause before the first token, but it cannot be disabled.
Was GLM-5.3-Flash the model called Ox Alpha?
Yes. Ox Alpha was its anonymous stealth codename on OpenRouter from August 20 to August 26, 2026. The specifications are identical; only the name and the price changed at the reveal.
Sources and verification
Last substantively reviewed: August 27, 2026. Reviewed by: OxAlpha.chat Editorial Team.
How we verified this page
Specifications were compared across Z.ai documentation, the released checkpoint configuration, the license file and the technical report. Benchmark figures on this page are identified as vendor-reported unless an independent source is named.
Primary sources
- Official model documentation: Z.ai GLM-5.3-Flash overview — supports the architecture, context, multimodal and API capability claims.
- Published checkpoint: Official GLM-5.3-Flash model card — provides the weight release and supported deployment paths.
- Checkpoint configuration: GLM-5.3-Flash config.json — documents model dimensions and the 1,048,576 position limit.
- License: Official MIT license file — sets the terms for using and modifying the released weights.
- Research report: GLM-5 technical report — contains the published technical methodology and evaluation context.
Found a factual error or a changed price? Send us the page URL and supporting source; corrections follow our editorial policy.