GLM-5.3 Prime vs GLM-5.3: 16% Faster Tokens, the Same Wait, 2x the Bill

GLM-5.3 Prime is GLM-5.3 served in Alibaba Cloud's faster "Prime mode", sold at about twice the price on the promise of 1.5–2× output speed. We sent the same coding prompt to both models through AIHubMix, alternating between them, and timed every streamed token. The short version:

• Decoding: Prime averaged 98.2 tokens/s against 84.7 for GLM-5.3. That's 1.16×, not 1.5–2×.
• Wall-clock: 102.1 s per answer on Prime, 99.9 s on GLM-5.3. Prime wrote more reasoning tokens (9,404 output tokens per answer vs 8,147), which ate the speed gain.
• First token: median 3.2 s on Prime, 3.0 s on GLM-5.3.
• Price on AIHubMix: $2.35 / $8.23 per million input / output tokens for Prime, against $1.1268 / $3.9438 for GLM-5.3.
• Effort: reasoning_effort: "low" cut Prime's output by 38% and its answer time to about 71 s, the only setup that beat GLM-5.3.
• Breaking change: thinking: {"type": "disabled"} gets HTTP 400 on Prime.

Three runs per model is a small sample. The point of this post is the method, so you can rerun it on your own prompts before paying double.

What Prime is

Alibaba Cloud's Prime mode docs describe it as higher TPS for latency-sensitive work, with "no additional parameters": you change the model ID and nothing else, and the capabilities and limits are those of the original model. Z.ai's own GLM-5.3 docs list no Prime model, and Alibaba Cloud is its only upstream. Same weights means the same benchmark results. Don't confuse it with GLM-5.3-FlashX, which speeds up the smaller Flash model, or with Zhipu's GLM-5.3 HighSpeed, which so far exists only as a staged test inside ZCode, Zhipu's coding app.

Prerequisites

• An AIHubMix API key in AIHUBMIX_API_KEY (see the quick start).
• Python 3.9+ with only the standard library, or curl for the error checks.
• Both models are on the Chat Completions endpoint: https://aihubmix.com/v1/chat/completions.

The timing script

It streams one request and records three things: time to the first streamed token (reasoning or answer), total time, and output tokens from the final usage chunk. Tokens per second is output tokens divided by the time from the first token to the last.

import json, os, sys, time, urllib.request

def run(model, effort, prompt):
    body = {"model": model, "messages": [{"role": "user", "content": prompt}],
            "reasoning_effort": effort, "max_tokens": 16000, "stream": True,
            "stream_options": {"include_usage": True}}
    req = urllib.request.Request("https://aihubmix.com/v1/chat/completions",
        data=json.dumps(body).encode(), method="POST",
        headers={"Authorization": f"Bearer {os.environ['AIHUBMIX_API_KEY']}",
                 "Content-Type": "application/json"})
    t0, t_first, usage = time.monotonic(), None, None
    with urllib.request.urlopen(req, timeout=900) as r:
        for raw in r:
            line = raw.decode().strip()
            if not line.startswith("data:") or line == "data: [DONE]":
                continue
            chunk = json.loads(line[5:])
            usage = chunk.get("usage") or usage
            for ch in chunk.get("choices") or []:
                d = ch.get("delta") or {}
                if t_first is None and (d.get("reasoning_content") or d.get("content")):
                    t_first = time.monotonic()
    t_end = time.monotonic()
    out = usage["completion_tokens"]
    return {"model": model, "ttft": round(t_first - t0, 2), "total": round(t_end - t0, 1),
            "tokens": out, "tok_s": round(out / (t_end - t_first), 1)}

prompt = sys.argv[1]
for _ in range(3):  # alternate so both models see the same time window
    for m in ("glm-5.3", "glm-5.3-prime"):
        print(run(m, "high", prompt))

python3 time_glm.py "Implement a thread-safe token-bucket rate limiter in Python ..."

Our prompt asked for a TokenBucket class with try_acquire(), using time.monotonic(), plus five pytest tests with an injected fake clock.

Results

Run	Model	First token	Total	Output tokens	tok/s
1	GLM-5.3	4.9 s	116.5 s	9,556	85.6
2	Prime	2.9 s	108.3 s	9,900	93.9
3	GLM-5.3	3.0 s	72.4 s	6,079	87.5
4	Prime	3.2 s	87.3 s	8,564	101.8
5	GLM-5.3	2.0 s	110.8 s	8,806	80.9
6	Prime	12.0 s	110.6 s	9,748	98.8

Run on October 21, 2026 (UTC+8), reasoning_effort: "high", streaming. Every run finished with stop.

Prime's decode speed was higher in every pair, but the totals barely moved, because the number of tokens varied more between runs than the speed did. The same pattern shows up in DataLLM Lab's test through OpenRouter: 14.2 s mean per answer for both models, with Prime using 1,215 reasoning tokens per call against 631.

For context, AIHubMix's model pages currently show 33.4 tok/s for GLM-5.3 and 48.6 tok/s for Prime (1.46×). Third-party monitors put GLM-5.3 at 61–72 tok/s and Prime at 60–80 tok/s. The numbers vary a lot by time and route, so measure on your own traffic.

Failure modes when you swap the model ID

Disabling thinking

Code written for GLM-5.2 often switches reasoning off. GLM-5.3 can't run without it, and Prime rejects the request outright:

curl -s https://aihubmix.com/v1/chat/completions \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "glm-5.3-prime", "max_tokens": 2000,
       "thinking": {"type": "disabled"},
       "messages": [{"role": "user", "content": "Reply with the single word: ok"}]}'

Prime returns HTTP 400:

{"error": {"message": "<400> InternalError.Algo.InvalidParameter: The value of the enable_thinking parameter is restricted to True. (tid: ...)",
  "type": "invalid_request_error", "param": "", "code": "invalid_parameter_error"}}

Zhipu's docs say the same flag makes the request fail on Z.ai's own API. Fix: remove thinking / enable_thinking: false from the request, and use reasoning_effort: "low" if you want short reasoning.

Effort levels

GLM-5.3 accepts reasoning_effort values low, high, and max, and the default is max. glm-5.2-fast-preview, the previous Prime-mode GLM, also took none, minimal, medium, and xhigh. Alibaba Cloud returns invalid_parameter_error for unsupported values, so strip those before switching.

With the same prompt, low made a clear difference on Prime:

Model	Effort	Runs	Output tokens	Total
GLM-5.3	high	3	8,147	99.9 s
Prime	high	3	9,404	102.1 s
Prime	low	2	5,832	70.7 s

On Prime, low cut output by 38%. AIHubMix serves GLM-5.3 through several providers, and on some routes the effort setting and the disabled-thinking flag may not behave as documented. Log usage.completion_tokens_details.reasoning_tokens on every call, and check that content holds only the answer.

Context limit

Prime lists 1,000,000 tokens of context. GLM-5.3 on AIHubMix lists 1,048,576. A prompt that just fits GLM-5.3 can overflow Prime. Max output is 131,072 on both.

Parallel tool calls

OpenRouter's Prime endpoint doesn't list parallel_tool_calls among its supported parameters, and Cursor users have reported GLM-5.3 tool calls losing their arguments when several fire in one step. This test didn't cover tools. If your agent calls tools in parallel, test that path on Prime first.

One upstream, one protocol

Alibaba Cloud is Prime's only provider, so keep glm-5.3 as the fallback. AIHubMix serves Prime on Chat Completions only, which rules out Claude Code (Anthropic Messages) and Codex (Responses API). OpenAI-compatible agents such as OpenCode work with the model ID alone.

Cost math

One long agentic coding task, assuming 75K output tokens (Zhipu's Code Bench figure at max effort) and 1.2M input tokens with 90% cache hits: $0.735 on GLM-5.3 and $1.536 on Prime. At the decode speeds above, Prime saves about 2 minutes of decoding on that task (14.8 vs 12.7 min). At the model-page speeds, it saves about 12 minutes (37.4 vs 25.7 min). That's $0.80 for 2 to 12 minutes, worth it only while someone is waiting.

Effort is the bigger lever wherever it takes effect. In Zhipu's Code Bench, high used about a third fewer output tokens than max (≈50K vs ≈75K per task) for a 3-point lower score (31.4% vs 34.5%). In this test, Prime at low was the fastest setup at about $0.048 per answer, against $0.032 for GLM-5.3 at high: 1.5× the cost, not 2×.

What we couldn't verify

• Whether the speed gap is stable across hours and days. Three runs per model is a snapshot.
• Which provider served each GLM-5.3 request. The test didn't pin one.
• Tool calling and long-context behaviour on Prime.
• Quality. Prime runs the same weights, and this test didn't score the code.

Compare both models' specs and prices on the AIHubMix comparison page; one key covers both.

Sources

• Prime mode — Alibaba Cloud Model Studio (Alibaba Cloud)
• GLM-5.3 overview (Z.ai)
• GLM 5.3 Prime model page (AIHubMix)
• GLM-5.3 Prime Review: 7/9 at $11.52 per 1,000 Tasks (DataLLM Lab)
• GLM-5.3 Prime and FlashX: Speed Tiers, Not New Models (Codersera)