GLM-5.3 open weights, day one: 16 providers, five prices, four quantizations — and BF16 is the cheapest

Eight days ago we argued that a model name is a menu label, and the product is the tuple — weights, quantization, context window, version — using seven endpoints for Qwen3.8-27B as the exhibit. This week the market ran the experiment again, faster and at larger scale. Z.ai pushed the last commit of GLM-5.3’s weights to Hugging Face on 2026-08-28 at 15:22 UTC. When I pulled OpenRouter’s endpoints API at 05:24 UTC the next morning, fourteen hours later, the single string z-ai/glm-5.3 resolved to sixteen endpoints with five different input prices ($1.20 to $1.40 per million tokens), three output prices ($3.96 to $4.40), four self-declared precisions (bf16, fp8, fp4 and unknown), three context windows (262,144, 1,048,576 and 1,310,720 tokens) and four output caps (131,072 to 1,179,648). The cheapest row runs BF16. The two FP4 rows charge list price. Nothing in the model name encodes any of that, and this post reads the day-one table column by column to show what a router should be keyed on instead.

Fourteen hours from the last commit to sixteen hosts

The timeline matters because it shows how little of a modern open-weights launch happens at the vendor.

Z.ai’s launch post on 2026-08-14 shipped GLM-5.3 as an API and made a dated promise: “We will release the weights in two weeks after launch, once safety evaluation and hardening are complete” (GLM-5.3: Frontier Coding with Emergent Cyber Capabilities). OpenRouter’s listing for the model was created on 2026-08-18 (the API’s created timestamp; the page shows it as August 19), with Z.ai’s own endpoint behind it. Two Hugging Face repositories were created on 2026-08-25. On 2026-08-28 the BF16 repository zai-org/GLM-5.3-BF16 received its last modification at 13:46 UTC, and the main repository zai-org/GLM-5.3 at 15:22 UTC — fourteen days after the launch post, to the day. The Hacker News thread went up at 15:20 UTC. Thirty minutes later a commenter was already crediting DeepInfra as “the first 3rd party provider for it on OpenRouter” (fra, HN).

By 05:05 UTC on the 29th the endpoints API listed sixteen hosts. I pulled it again at 05:24 UTC while writing; the two snapshots agree on every price, precision, context and output-cap field, and differ only in the rolling uptime numbers. So the table below was stable for at least twenty minutes. I would not promise more than that, which is rather the point.

The day-one table: sixteen rows behind one model string

Here is the 05:24 UTC snapshot, prices converted from the API’s per-token strings to per million. Quant is the value each host declares to OpenRouter; nobody, including me, has verified it against the bytes being served.

Source: OpenRouter endpoints API for z-ai/glm-5.3, 2026-08-29 05:24 UTC. The model page shows the same rows with latency, throughput and uptime alongside; treat those three as weather, not specification.

An excerpt of the raw record, for readers who prefer the source to my table:

{
  "data": {
    "id": "z-ai/glm-5.3",
    "endpoints": [
      { "provider_name": "DeepInfra", "quantization": "bf16",
        "context_length": 1048576, "max_completion_tokens": 943718,
        "pricing": { "prompt": "0.0000012", "completion": "0.000004", "input_cache_read": "0.00000024" } },
      { "provider_name": "Io Net", "quantization": "fp8",
        "context_length": 262144, "max_completion_tokens": 131072,
        "pricing": { "prompt": "0.00000125", "completion": "0.0000044", "input_cache_read": "0.00000026" } },
      { "provider_name": "BaseTen", "quantization": "fp4",
        "context_length": 1048576, "max_completion_tokens": 262144,
        "pricing": { "prompt": "0.0000014", "completion": "0.0000044", "input_cache_read": "0.00000014" } },
      { "provider_name": "Cloudflare", "quantization": "unknown",
        "context_length": 1310720, "max_completion_tokens": 1179648,
        "pricing": { "prompt": "0.0000014", "completion": "0.0000044", "input_cache_read": "0.00000026" } }
    ]
  }
}

Five input prices, and the cheapest row is BF16

Start with the column most people read first. Twelve of the sixteen hosts charge $1.40 in and $4.40 out. That is not a coincidence of the market; it is Z.ai’s own list price. The vendor’s price list puts GLM-5.3 at $1.4 input and $4.4 output, the same line it charges for GLM-5.2. So on day one, three quarters of the third-party market simply copied the vendor’s sheet.

Four hosts did not. DeepInfra is 14% under list on input and 9% under on output. io.net and AkashML shave the input price and leave output at list. AtlasCloud goes the other way: input close to list, output 10% under at $3.96. If your workload is prompt-heavy — long documents, short answers — AtlasCloud’s row is not the bargain it looks like; if it is generation-heavy, it is the second-best line on the board. One model name, and already the cheapest host depends on the shape of your traffic.

Now put the price column next to the precision column, because that is where the day-one table becomes an argument. The cheapest row, DeepInfra at $1.20, is the only one declaring BF16 — the full-precision reference. The two rows declaring FP4, Baseten and Morph, charge list price. In the earlier Qwen3.8-27B table, BF16 and FP8 hosts sat at the same price; here the ordering has inverted, and the highest declared precision is the discount line. I do not think that says anything about the hosts’ costs — a bf16 serving of a 753-billion-parameter model is not cheaper to run than an fp4 one. It says that the price column is a business decision and the precision column is an engineering one, and that on OpenRouter’s default routing they are only connected by accident.

The cache column has its own outlier. Baseten prices cached input at $0.14 per million, roughly half of everyone else’s $0.24–0.26. For an agent loop that re-sends a large system prompt every turn, that halves the biggest line on the bill. It is also an FP4 host. A router that optimises for cache-heavy workloads without a precision floor would pick it.

For completeness, the “one weight, many prices” pattern does not stop at OpenRouter. An aggregator’s own comparison from before the weights shipped lists the same GLM-5.3 at $1.40/$4.40 through the official API and at $0.06/$0.22 through a “coding” preview route marked as “intended for testing and evaluation” with “service stability … not guaranteed” (AIHubMix, GLM-5.3 pricing compared). Twenty-three-fold on the same name. I cite it as a second sample of the pattern, not as a recommendation for either route.

Four quantizations, all self-declared — and what the repository actually ships

The precision column has four values. Before reading them, look at what Z.ai uploaded.

The main repository is not a BF16 checkpoint. Hugging Face’s metadata for zai-org/GLM-5.3 counts 753,329,940,480 parameters, of which 751,226,191,872 are stored as F8_E4M3 and 2,103,729,152 as BF16; the model’s config.json carries quantization_config.quant_method: "fp8" with a 128×128 block size. The 141 safetensors shards total 755.6 GB. Z.ai made FP8 the default artefact this time and published BF16 as a sibling repository — which, per commenters on the thread, reverses its previous practice; one put it as “This time they just made FP8 ‘default’, accompanied by ‘-BF16’ model/page (previously ‘-FP8’ was released alongside)” (petu, HN); another noticed the download is “half the size of glm-5.2 756 GB vs 1.51 TB” and got the one-line answer “FP8 experts not BF16” (rew0rk and dannyw, HN).

So read the column again with that in mind:

• fp8, seven hosts, including Z.AI itself. This is the vendor’s default artefact. Seven hosts declaring fp8 most plausibly means seven hosts serving the main repository as uploaded. That is the least surprising value on the board.
• bf16, one host. DeepInfra declares the sibling repository’s precision. It is also the cheapest row. The declaration is DeepInfra’s; OpenRouter passes it through.
• fp4, two hosts. Baseten and Morph declare a further quantization from either checkpoint. OpenRouter’s own documentation lists fp4 as a family covering mxfp4 and nvfp4 (Provider Routing — Quantization Levels), so the column does not tell you which. Our earlier measurement week found NVFP4 flipping about half of top-1 tokens against BF16 at long context, and FP8 about a fifth — on a different model, with the damage concentrating in tool calls (FP8 flips 20% of top-1 tokens). I am not claiming that number transfers to GLM-5.3; I am claiming that a buyer paying list price has no way to know whether it does.
• unknown, six hosts. Cloudflare, Friendli, Fireworks, Modal, DigitalOcean and Together declare nothing. OpenRouter’s docs make unknown an explicit value in the quantizations filter, which is the right design: it lets a caller exclude it. Six of sixteen is a large share of the day-one market to have no stated precision at all, and every one of those six charges list price.

There is a reason to care that goes beyond principle. During GLM-5.2’s run, a user of a subscription product that resold open-weight models through several hosts described the experience of mixed precision behind one name: “Most ran FP8 but one was doing FP4, so you had this issue where one moment you had the better FP8 and another session you had the FP4 provider” (benjiro29, HN). That is the failure mode, stated by someone who lived it. The day-one GLM-5.3 table contains the same mix, at the same price.

262k, 1.05M, 1.31M: three context windows for a 1,048,576-token model

The context column should be the boring one. The model’s config.json sets max_position_embeddings to 1,048,576 with no rope scaling; that is the native window, and thirteen hosts serve it (Together reports 1,048,575, one token short — a fencepost, not a product difference, but an integer comparison in a router would treat it as one).

Two hosts, io.net and AtlasCloud, serve 262,144 — a quarter of the window — and cap output at 131,072. They are also two of the four discount rows. A long-context request that succeeds on fourteen hosts fails on these two with the same model string, and a router sorting on price alone will find them second and third in line.

One host, Cloudflare, declares 1,310,720 — 25% above the model’s configured maximum — with an output cap of 1,179,648. I do not know what sits behind that number; it may be a deployment that extends the window, or a listing artefact. What I know is that a router keyed on the name cannot tell a host serving a quarter of the native window from one claiming more than all of it.

The output-cap column splits four ways: 131,072 (four hosts, including Z.AI’s own endpoint), 262,144 (Baseten), 943,717–943,718 (ten hosts) and 1,179,648 (Cloudflare). Note the first group. The vendor’s own endpoint caps a single completion at 131,072 tokens while ten third parties allow seven times more. If your agent’s long turns have been truncating on the official API, the fix on day one is a different host, not a different model.

There is a fifth axis this table does not show, and GLM-5.3 makes it expensive to ignore. The model card says the reasoning_effort parameter “accepts three levels: low, high, and max. It defaults to max if not passed”. All sixteen endpoints expose the parameter. Z.ai’s own curve — self-reported, on its in-house Z.ai Code Bench — puts the model at 34.5% task completion using roughly 75K output tokens per task at Max effort and 31.4% at around 50K at High (GLM-5.3 launch post). Take those two points at face value and the default setting buys three points of accuracy for 50% more output tokens, which at $4.40 per million is the difference between about $0.22 and $0.33 per task — my arithmetic on Z.ai’s numbers, not a measurement. Same host, same price per token, same model name, and the bill per task moves by half depending on a parameter most routing configs never set.

What the benchmark table says, and what it cannot say about any of these sixteen rows

The model card’s table is the reason most people opened the repository. It reports GLM-5.3 at 28.3 on Terminal Bench 3.0 against GLM-5.2’s 4.6, 66.9 on DeepSWE v1.1 against 46.2, 28.5 on Agents’ Last Exam against 23.8, and describes the model as “the most capable open-weights model for coding” (model card). Every number is Z.ai’s own run, with the harness settings in footnotes, and the scores for other vendors’ models were produced by Z.ai as well. Read it as a vendor’s honest account of its own evaluation, which is what it is.

What it cannot be is a statement about any row in the table above. Z.ai evaluated the checkpoint it trained. Sixteen hosts are serving four declared precisions, three context windows and an effort knob defaulting to its most expensive setting, and not one of those combinations has a published score. When OpenRouter ran its own harness across seven Qwen3.8-27B hosts two weeks ago, the same benchmark came back between 76.8% and 83.3% depending on who answered (Qwen3.8-27B: seven endpoints). I would expect a spread here too, and I would expect it to be widest on tool-call-heavy tasks, because that is where the earlier logit study found the quantization damage landing. I have not run it, so I will not guess the size. The point is narrower: a benchmark score attaches to a checkpoint; a price attaches to an endpoint; and the model name is the only thing they have in common.

What a router owes you, day-one edition

The earlier post ended with four fields a router should key on. GLM-5.3’s first fourteen hours add specifics.

OpenRouter’s default is to load-balance across hosts “ordered by price” (Provider Routing). On this table, today, that sends most of your traffic to DeepInfra’s BF16 row — the best outcome on the board, arrived at by luck. The moment an FP4 or unknown host undercuts $1.20, the same default sends you there instead, with no change to your config and no notice. Price-sorting is not a precision policy; it just happened to agree with one this morning.

The fix is available now and costs two fields. OpenRouter’s request body takes a provider object with a quantizations filter and an ordered host list; setting allow_fallbacks to false makes a miss fail loudly rather than degrade silently:

{
  "model": "z-ai/glm-5.3",
  "provider": {
    "quantizations": ["bf16", "fp8"],
    "order": ["deepinfra", "z-ai", "parasail"],
    "allow_fallbacks": false
  },
  "reasoning_effort": "high"
}

That request excludes the two FP4 rows and the six unknown rows, prefers the cheapest declared-BF16 host, falls back to the vendor’s own FP8 endpoint, and sets the effort knob explicitly instead of inheriting the most expensive default. What it still cannot express is a context or output floor — order is doing that work by hand, and if DeepInfra changes its row you will find out from a failed request. Nor does pinning protect you from the cost of switching: a commenter on the same thread, using a different model through the same router, describes the default routing switching hosts “too eagerly which resets the cache” (DefineOutside, HN), and the reply is the same advice — pick your provider (eikenberry, HN). A prompt cache lives on one host. Every silent host change is a cold cache, billed at full input price.

One more field belongs in the tuple this week, and it is not technical. GLM-5.3’s weights are not under MIT, unlike GLM-5.3-Flash and GLM-5.2. The repository carries a custom GLM-5.3 License whose second clause defines “Model as a Service” and adds: “If the Licensee or any of its affiliates operates a Model as a Service business, and the aggregate revenue of the Licensee and its affiliates exceeds 10 billion US dollars … in total over any consecutive 12 months, the Licensee must pass Z.AI’s security review before using the Software or its derivative works for any commercial purpose.” That clause is why an HN reply to “will this be on Bedrock?” reads “many of them (kimi k3, glm-5.3) have license requirements to sell them with model-as-a-service” (hhh, HN). For the sixteen hosts above it is a question about their revenue, not yours; for a team deciding whether to self-host and resell, it is a clause to read. Our Chinese-language edition goes through it line by line against Flash’s MIT.

This is the gap PiRouter’s catalog is designed around: quantization, context window, output cap and version as first-class filterable fields on every endpoint, unknown surfaced as a value rather than guessed away, and the effort default pinned per route rather than inherited. That describes the design, not a promise about any host’s declaration on any given day.

Back to the name

Fourteen hours after the last commit, z-ai/glm-5.3 was sixteen products. One of them was the reference precision at the lowest price; two were four-bit at list; six declined to say; two served a quarter of the window; one claimed more than the model has; the vendor’s own row capped output lower than most of its resellers; and every one of them defaulted to the effort setting that costs the most. None of that is hidden — OpenRouter publishes it in an API call you can make in a terminal. It is just not in the name, and the name is still the key most routing configs turn. Key on the tuple. Today it points at BF16 for $1.20. Tomorrow it may not, and that is exactly when you want to have been asking.