GLM-5.3-Flash Locally: 93GB Floor, Not 18B

Z.ai released GLM-5.3-Flash on 26 August 2026 under an MIT license, and most of the coverage repeated the same two numbers: 320B total parameters, 18B active. That sounds like a model you could run at home, since an 18B active model is roughly Qwen3-14B territory.

It isn't. All 320B parameters have to sit in memory even though only 18B do arithmetic per token. The smallest usable quant on Hugging Face is 93 GB, and the full BF16 GGUF set is 642 GB. The config file and the real file sizes tell a different story from the launch posts, and the API pricing is the fallback if the local route is too heavy.

Table of contents

• Why 18B active does not mean 18B of memory
• Real quant sizes, measured from Hugging Face
• What the config.json actually reveals
• The hybrid attention change is the real news
• API pricing, and the discount that ends on 9 September
• Local or API, run the numbers on your own workload
• FAQ
• Sources

Why 18B active does not mean 18B of memory

A Mixture-of-Experts model routes each token through a small subset of its experts. GLM-5.3-Flash has 288 routed experts plus 1 shared expert, and picks 8 routed experts per token. So 18B parameters do work at any instant, out of 320B sitting in memory.

The compute saving is real. The memory saving isn't. The router can pick any of the 288 experts for the next token, so every expert has to be loadable. Offload experts to disk and you pay a disk read on nearly every token, which wrecks throughput.

The Hugging Face safetensors index for zai-org/GLM-5.3-Flash reports 321,323,031,390 parameters. The routed expert weights ship as FP8 (314.4B params in F8_E4M3) and 6.9B are in BF16. Z.ai published the weights already quantized to FP8 with 128x128 weight blocks, so the "native" download is about 321 GB rather than the 642 GB a BF16 release would be.

Real quant sizes, measured from Hugging Face

I took the file sizes from the Hugging Face tree API for unsloth/GLM-5.3-Flash-GGUF instead of trusting round numbers in blog posts. These are sums of all shards per quant directory:

The vision tower ships separately as mmproj-BF16.gguf (1.16 GB) or mmproj-F16.gguf (1.13 GB), so add roughly 1.2 GB if you want the multimodal input the model is built around. These are weight sizes only, before KV cache and runtime overhead.

A 128 GB unified-memory machine can hold UD-IQ1_S or UD-IQ2_XXS with room for a modest context. Q4_K_XL at 200 GB needs something like a 256 GB box, and anything above that is server territory. At the time of writing, running these quants needs the llama.cpp pull request Unsloth links from the model card, not a released llama.cpp build, or their desktop app.

What the config.json actually reveals

These numbers come from text_config in the model's own config.json, not from secondhand summaries:

Three details stand out. The first three layers are dense (first_k_dense_replace: 3), so MoE routing only starts at layer 3. There is one Multi-Token Prediction layer at index 45, which speculative decoding can use. And mhc: true with hc_mult: 4 confirms the Manifold-Constrained Hyper-Connections that Z.ai credits for the scaling efficiency gain.

The attention design isn't standard multi-head. A kv_lora_rank of 512 with a q_lora_rank of 1536 is a compressed latent KV setup from the DeepSeek MLA family, and mla_use_nope is true, so those layers run without rotary position embeddings. That compression is why a 1M context can be served at all.

Our AI VRAM calculator now carries GLM-5.3-Flash as a preset with these exact values. You can put your own context length and quantisation against it.

The hybrid attention change is the real news

GLM-5.3-Flash is the first GLM model to mix linear and sparse attention in one stack. The linear_attn_config block spells out the split: 34 of the 45 layers use Kimi Delta Attention style linear attention, and 11 layers (indices 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43) keep full attention with a sparse indexer.

The pattern is a strict stride of 4: three linear layers, then one full-attention layer, repeating. Linear attention carries local dependencies through recurrent state, which costs constant memory per token instead of growing with sequence length. The 11 full-attention layers handle long-range retrieval, and each uses a learned indexer that selects only 2,048 keys (index_topk) instead of attending to the whole million-token window.

Z.ai's own figure for what this buys is attention compute down 3.01x and KV cache down 4.44x versus GLM-5.3. The KV cache number is the one that shows up on an inference bill, because the cache is what makes long agentic sessions expensive.

For local runners this cuts both ways. The KV cache at long context is far smaller than a 320B dense-attention model would need. But the architecture is new enough that engine support is still landing, which is why the GGUF quants currently want a llama.cpp PR build.

API pricing, and the discount that ends on 9 September

If 93 GB is out of reach, the API is cheap. From Z.ai's official pricing table:

The promotional rate is a flat 50% discount, and Z.ai states it ends at 24:00 on 9 September 2026 (UTC+8). After that you pay $0.15 and $0.50. If you're benchmarking this week and budgeting for next month, your test bill doubles on the same workload.

Even at list price the gap to GLM-5.3 is roughly 9x on both input and output, for a model Z.ai says beats GLM-5.2 across its benchmark set. That is the strongest argument for this release, stronger than the license.

OpenRouter lists the same model at $0.075 input and $0.25 output with a 1,310,720-token context, slightly above the 1,048,576 in the config. Their batch endpoint sits at the $0.15/$0.50 list rate. Run your own token mix through our API cost calculator instead of comparing headline rates, because the cached-input rate is where a long agentic session lands.

Local or API, run the numbers on your own workload

Based on the numbers above, the split looks like this.

Use the API if you're evaluating, prototyping or running anything bursty. At $0.075/$0.25 you would need a very large volume before a 256 GB machine pays for itself, and you get the 1M context and multimodal input without fighting a PR branch of llama.cpp.

Run it locally if your data can't leave your network or you already own the hardware. 128 GB of unified memory gets you the 1-bit and 2-bit dynamic quants. Below that, this model is not for you, and GLM-4.5-Air or a Qwen3-32B class model will serve you better than a 1-bit 320B.

Skip both if you wanted a cheap multimodal coding model on a single 24 GB GPU. This release isn't that, whatever "18B active" suggests.

The FP8 native release deserves a note too. Z.ai shipped the weights pre-quantized instead of publishing BF16 and leaving the community to compress them, which looks like a lab budgeting for deployment cost from the start, the same thinking as the hybrid attention.

FAQ

Can I run GLM-5.3-Flash on a 24 GB GPU? No. The smallest GGUF quant on Hugging Face, UD-IQ1_S, is 93 GB across three shards, and every parameter has to be resident because the MoE router can select any expert for the next token.

How much memory does GLM-5.3-Flash need? For weights alone, about 93 GB at 1-bit, 109 GB at Q2_K_XL, 200 GB at Q4_K_XL, 341 GB at Q8_0 and 642 GB at BF16. Add roughly 1.2 GB for the vision tower, plus KV cache on top.

Is GLM-5.3-Flash open source? The weights are on Hugging Face under an MIT license, which is more permissive than most open-weight licenses. The training data and code are not published.

What does the GLM-5.3-Flash API cost, and what is the context window? $0.075 per million input tokens and $0.25 output during the launch promotion, rising to the $0.15 and $0.50 list price after 24:00 on 9 September 2026 (UTC+8). Cached input is $0.015 promotional, $0.03 list. The model code is glm-5.3-flash on Z.ai or z-ai/glm-5.3-flash through OpenRouter. The config lists 1,048,576 tokens of context and Z.ai's docs say 1M with 128K maximum output, while OpenRouter advertises 1,310,720 for the standard endpoint.

Sources

• zai-org/GLM-5.3-Flash config.json, architecture values, read 6 September 2026
• zai-org/GLM-5.3-Flash model info API, parameter count and dtype split, read 6 September 2026
• unsloth/GLM-5.3-Flash-GGUF, quant file sizes summed from the tree API, read 6 September 2026
• Z.ai pricing, official pricing table and promotion end date, read 6 September 2026
• GLM-5.3-Flash model guide, Z.ai's architecture and efficiency claims, read 6 September 2026
• OpenRouter models API, third-party pricing and context length, read 6 September 2026