GLM-5.3 GPU Cloud: Setup, VRAM & Cost Guide (2026)

GLM-5.3's flagship weights are public. Z.ai shipped the model via API and its GLM Coding Plan on August 14, 2026, and the zai-org/GLM-5.3 repo on Hugging Face went from a release-date placeholder to a real checkpoint with downloadable safetensors that same window, timestamped 15:22 UTC on August 28, slightly ahead of the 16:00 UTC the placeholder had listed. So this GLM-5.3 GPU cloud guide is a live deployment walkthrough, not a "hold tight for the weights" placeholder: the hardware math, the deploy commands, and one license change worth knowing about before you provision anything.

If you're coming from the GLM-5.2 deployment guide, the good news is the hardware math barely changes: GLM-5.3 runs on essentially the same MoE footprint as GLM-5.2, right around 743-753B total parameters depending on whether you're reading vLLM's recipe or the Hugging Face repo header, with about 39B active per forward pass. Every capability gain came from post-training alone, not a bigger model. That means your VRAM plan for GLM-5.2 carries over almost unchanged to GLM-5.3, with one exception: check the license section below before you deploy commercially at scale.

GLM-5.3 Setup Guide: Architecture and What Changed From 5.2

Z.ai built GLM-5.3 on the identical base checkpoint as GLM-5.2 and pushed all of its capability gains through extended post-training, according to The Decoder's coverage of the release. No new parameters, no architecture change, just heavier reinforcement learning on top of the same weights shape.

On parameter count, take your pick of source: vLLM's official deployment recipe rounds to ~743B total and ~39B active, while the Hugging Face repo's own header lists 753B. The gap is small enough that it doesn't change hardware planning either way, so this guide uses vLLM's figures for VRAM math since that's the number tied to actual deploy commands.

The numbers back up how much post-training alone can move the needle. On Terminal-Bench 3.0, GLM-5.3 jumps from 4.6 to 28.3, a roughly 6.2x gain that Z.ai calls "the open-source high" on that benchmark, though it still trails GPT-5.6 Sol's 34.6 on the same test. DeepSWE v1.1 climbs from 46.2 to 66.9, a 44.8% improvement on long-horizon software engineering tasks, and Agents' Last Exam moves from 23.8 to 28.5, up 19.7%.

There's a token-efficiency angle worth flagging for anyone doing cost math later in this guide: on Z.ai's own private Code Bench (High tier), GLM-5.3 scored 31.4% using around 50,000 output tokens, against Claude Opus 4.8's 29.5% at roughly 120,000 tokens on the same task. That's a real gap, but it's a single comparison on a benchmark nobody outside Z.ai can rerun, so treat it as a directional signal on token efficiency, not proof the pattern holds against every frontier model. Fewer tokens per completed task still changes the real cost-per-task even when the per-token API rate stays flat, which matters for the cost math later in this guide.

The other big shift is security. Working with outside security teams, GLM-5.3 found 2,436 vulnerabilities across 269 projects, some in codebases up to 40 years old, and separately scored 84.5% on CyberGym, edging out both Claude Mythos 5 and GPT-5.6 Sol on that specific test (ExploitBench came in lower at 54.4%, still behind frontier closed models). That capability is exactly why Z.ai held the checkpoint back for a safety review before publishing it, covered next.

Open Weights: Live Today, Under a New License

GLM-5.3's flagship weights were held back for a reason that went beyond normal release logistics: the model developed exploit-chain reasoning during post-training that Z.ai says it didn't set out to train for, reasoning across multiple stages of an attack and forming coherent plans for complete exploitation chains. That admission is why Z.ai sat on the checkpoint for roughly two weeks after the August 14 API launch, running a safety evaluation and hardening pass rather than shipping weights alongside the API on day one. The wait ended today: the zai-org/GLM-5.3 repo carries a real, downloadable checkpoint as of this guide's publish date, with FP8 safetensors ready to pull.

One thing changed on the way out that's worth planning around: the license is no longer MIT. GLM-5.2 shipped MIT with no usage restrictions. GLM-5.3's flagship weights ship under a custom "glm-5.3" license instead, permitted for commercial use in most cases, but with a revenue-based trigger: any Model-as-a-Service business clearing $10 billion in revenue over a trailing 12-month period has to pass a Z.ai security review before continuing commercial use. That's a narrower version of the user-count clauses in licenses like Llama's, and it won't affect the overwhelming majority of teams self-hosting GLM-5.3, but read the actual license text on the Hugging Face repo before you build a product around it if you're anywhere near that revenue tier.

GLM-5.3-Flash remains a separate, smaller option if you don't need the flagship's full capability: a 320B-total, 18B-active multimodal MoE that shipped with MIT-licensed open weights on August 26, 2026, unaffected by the flagship's license change. We cover its exact deployment steps near the end of this guide.

VRAM and GPU Sizing for Full-Precision and Quantized Runs

Because GLM-5.3 shares GLM-5.2's near-identical parameter footprint (~743B per vLLM's recipe), the VRAM math is a straight carryover, and now it's confirmed against a live checkpoint rather than a projection:

• BF16: ~743B x 2 bytes = ~1,486 GB. Needs a multi-node setup.
• FP8 (default checkpoint): ~743B x 1 byte = ~743 GB. Fits on 8x H200 SXM5 or 8x B200 SXM6 with headroom.
• NVFP4 (Blackwell only): Z.ai's vLLM recipe lists a community-maintained Inferact/GLM-5.3-NVFP4 variant for 8x B200/B300 that trims the footprint further, useful if you're already committed to Blackwell hardware.
• AWQ INT4: ~743B x 0.5 bytes = ~372 GB, plus 5-10% for activations. Fits on 4x H200 or a single 8x H100 node, though this is a community quant, not an official Z.ai release.

For the 1M-token context window, budget an additional 80-160 GB of KV cache on top of weight memory, the same range GLM-5.2 needed since the attention architecture hasn't changed. FP8 KV cache is what makes 1M context viable on 8x H200 rather than forcing a bigger node. See the KV cache optimization guide for the full memory math if you're sizing a cluster for long-context workloads specifically.

vLLM's official recipe for GLM-5.3 recommends --tensor-parallel-size 8 on an 8x H200/H20 or 8x B200 node, --kv-cache-dtype fp8 (or fp8_e4m3 for full 1M-context serving on B200), and MTP speculative decoding via --speculative-config.method mtp --speculative-config.num_speculative_tokens 5. It requires vLLM 0.28.0 or newer and notes that DeepGEMM is required for full FP8 performance.

For the general MoE VRAM math this section leans on, the GPU requirements cheat sheet for 2026 covers the same lookup across other large models.

GLM-5.3 GPU Cloud Configurations and Live Pricing on Spheron

Pricing pulled from Spheron's live pricing page on 28 Aug 2026:

Pricing fluctuates based on GPU availability. The prices above are based on 28 Aug 2026 and may have changed. Check current GPU pricing → for live rates.

The 8x H200 SXM5 FP8 spot configuration at $20.56/hr is the cost-optimal entry point now that weights are live, provided the spot discount against on-demand ($38.32/hr) holds at reservation time. For 1M-context serving where KV headroom matters more than raw price, 8x B200 SXM6 at $31.20/hr spot gives 408 GB more total VRAM and better prefill throughput on long sequences.

Step-by-Step Deployment with vLLM

These steps deploy the live zai-org/GLM-5.3 checkpoint. The flags below come straight from vLLM's official GLM-5.3 recipe.

Step 1: Provision the GPU Node on Spheron

Log in to app.spheron.ai, select an 8x H200 SXM5 or 8x B200 SXM6 instance, and set storage to at least 800 GB NVMe for the FP8 checkpoint. SSH in once it provisions using the SSH connection guide.

Step 2: Install Dependencies

# CUDA 12.4+ required; DeepGEMM is required for full FP8 performance per vLLM's recipe
pip install "vllm>=0.28.0" huggingface_hub
export HF_TOKEN=<your_token>

Step 3: Download Model Weights

huggingface-cli download zai-org/GLM-5.3 \
  --local-dir ./glm-5-3 \
  --repo-type model

This pulls the default native-FP8 checkpoint, around 743 GB. Budget your NVMe storage accordingly, and expect the download itself to take a while at that size.

Step 4: Launch the vLLM Server

vllm serve zai-org/GLM-5.3 \
  --tensor-parallel-size 8 \
  --kv-cache-dtype fp8 \
  --max-model-len 131072 \
  --speculative-config.method mtp \
  --speculative-config.num_speculative_tokens 5 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --enable-auto-tool-choice \
  --port 8000

For 1M-context workloads on 8x B200, raise --max-model-len to 1048576, switch to --kv-cache-dtype fp8_e4m3, and add --max-num-seqs 32, per vLLM's recipe for the full-context configuration.

Step 5: Validate

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai-org/GLM-5.3",
    "messages": [{"role": "user", "content": "Write a Python function to reverse a linked list."}],
    "max_tokens": 512
  }'

Benchmark throughput with vLLM's benchmark_serving.py before routing production traffic.

Reasoning Effort Levels (Low/High/Max) and Why "Off" No Longer Exists

GLM-5.3 always runs with reasoning enabled, at one of three effort levels: low, high, or max. There's no way to disable reasoning entirely, which is a real change from GLM-5.2's toggleable High and Max modes.

This matters for sizing, not just prompting. Every request, even a trivial one, now carries a reasoning token floor. Low effort keeps that floor small and is the right default for latency-sensitive interactive coding agents. Max effort activates deeper reasoning chains for hard agentic tasks and should be reserved for batch pipelines where quality matters more than response time. Plan your token budget and per-request latency SLOs around whichever tier you pick, since you can no longer fall back to a no-reasoning path for simple completions.

Deploy GLM-5.3 with SGLang for Agentic Coding Workloads

SGLang's RadixAttention is a strong fit for GLM-5.3's agentic coding use case: when repeated agent steps send the same large codebase context, RadixAttention caches that shared prefix and computes only the incremental portion.

pip install 'sglang[all]>=0.5.10'

python -m sglang.launch_server \
  --model-path zai-org/GLM-5.3 \
  --tp 8 \
  --quantization fp8 \
  --enable-moe-ep \
  --context-length 131072 \
  --port 30000

For 1M-context workloads:

python -m sglang.launch_server \
  --model-path zai-org/GLM-5.3 \
  --tp 8 \
  --quantization fp8 \
  --enable-moe-ep \
  --context-length 1048576 \
  --mem-fraction-static 0.88 \
  --kv-cache-dtype fp8_e5m2 \
  --port 30000

--enable-moe-ep is SGLang's expert parallelism flag, equivalent to vLLM's expert-parallel setting. Without it, tensor parallelism copies every expert's weights to every GPU, wasting memory that would otherwise go to batch capacity. For a full production walkthrough of the flags and tuning knobs, see the SGLang production deployment guide.

GLM-5.3's MoE routing carries over GLM-5.2's fine-grained expert layout, so it also benefits from DeepGEMM's FP8 grouped GEMM kernels. The DeepEP and DeepGEMM setup guide covers installation, and the MoE inference optimization guide is the broader reference for expert parallelism across architectures like this one.

GLM-5.3 vs GLM-5.2 vs Kimi K2.7 Code: Performance and Cost

Same hardware cost, near-identical weight footprint, meaningfully different capability: GLM-5.3's post-training push is what earns the Terminal-Bench and DeepSWE gains covered earlier, without asking for a bigger cluster. Against Kimi K2.7 Code, GLM-5.3 wins when you want the 1M-token context and the option to run low-effort reasoning for latency-sensitive agents; Kimi K2.7 Code is the stronger pick when raw parameter scale matters more and its Modified MIT license terms are acceptable. See the Kimi K2.7 Code deployment guide for its full hardware configuration.

The one asterisk on this table now that weights are live: GLM-5.3's custom license carries the $10 billion revenue trigger covered above, where GLM-5.2's MIT terms carry none. Factor that in if you're operating at that scale.

Cost-per-Token: Self-Hosted on Spheron vs Z.ai API

GLM-5.3's API pricing is unchanged from GLM-5.2: $1.40 per million input tokens and $4.40 per million output tokens, with cached input at $0.26/M. Now that flagship weights are live, here's how self-hosting stacks up.

At realistic FP8 throughput for a ~743B-total, ~39B-active MoE at moderate context, expect roughly 150-200 tokens/sec per 8-GPU node, the same range GLM-5.2 delivers on identical hardware. Using 175 tokens/sec as the midpoint:

cost_per_million = (hourly_rate / (tokens_per_second × 3600)) × 1_000_000

Break-even analysis: at $20.56/hr on spot, running 24/7 costs roughly $14,803/month for an 8x H200 cluster. Against Z.ai's API at $4.40/M output tokens, break-even sits at roughly 3.36 billion output tokens per month, a volume that requires sustained high-concurrency batch workloads. Below that, the API is cheaper than maintaining a dedicated cluster. Self-hosting still makes sense below the break-even point when data privacy or a dedicated SLA is a hard requirement, independent of volume.

Remember the token-efficiency point from earlier: on Z.ai's own benchmark, GLM-5.3 completed a coding task in ~50,000 output tokens where Claude Opus 4.8 needed ~120,000. If that directional signal holds for your workload, your real cost-per-task on either the API or a self-hosted cluster drops by roughly the same ratio, even though the $/M rate itself hasn't moved.

Pricing fluctuates based on GPU availability. The prices above are based on 28 Aug 2026 and may have changed. Check current GPU pricing → for live rates.

For a broader look at where self-hosting crosses over against a frontier API provider, the Claude Opus 5 API vs self-hosted cost breakdown walks through the same math against a different frontier baseline.

GLM-5.3-Flash: The Smaller, Cheaper Alternative

If the flagship's ~743 GB footprint is more than your workload needs, GLM-5.3-Flash is worth a look. Z.ai shipped it with MIT-licensed open weights on Hugging Face two days earlier, on August 26, 2026: a 320B-total, 18B-active natively multimodal MoE with the same 1M-token context window as the flagship, unaffected by the flagship's license change. It spent its first week running anonymously as "Ox Alpha" on OpenRouter before Z.ai confirmed authorship.

FP8 weight memory runs about 306 GiB; the BF16 variant needs roughly double that. On Spheron, 4x H200 SXM5 (564 GB total) fits the FP8 checkpoint with real headroom left for KV cache at long context, at $10.28/hr spot or $19.16/hr on-demand using the pricing pulled above, well under half of what an 8x H200 flagship cluster costs.

Deployment:

pip install "vllm>=0.28.0" "flashinfer-python>=0.6.18" huggingface_hub

huggingface-cli download zai-org/GLM-5.3-Flash \
  --local-dir ./glm-5-3-flash \
  --repo-type model

vllm serve zai-org/GLM-5.3-Flash \
  --tensor-parallel-size 4 \
  --kv-cache-dtype fp8 \
  --speculative-config '{"method":"mtp","num_speculative_tokens":5}' \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --enable-auto-tool-choice \
  --served-model-name zai-org/GLM-5.3-Flash

This is vLLM's own published recipe for the model, tuned for one 4-GPU tray. --speculative-config enables MTP speculative decoding using the model's built-in draft layer, which is where a meaningful chunk of the throughput gain comes from on this checkpoint.

On price, Z.ai's own API for GLM-5.3-Flash runs $0.15 per million input tokens, $0.03/M cached, and $0.50 per million output, a fraction of the flagship's $1.40/$4.40 rates. If your workload fits inside an 18B-active model's capability, Flash is the cheaper path on either the API or your own hardware, and it sidesteps the flagship's license clause entirely.

Pricing fluctuates based on GPU availability. The prices above are based on 28 Aug 2026 and may have changed. Check current GPU pricing → for live rates.

GLM-5.3's flagship weights are live, the hardware math carries over almost unchanged from GLM-5.2, and GLM-5.3-Flash covers you if you need something smaller. Provision an H200 or B200 cluster on Spheron and start serving today.

H200 SXM5 on Spheron → | Spheron B200 instances → | View all pricing →

Get started on Spheron →