GPT-6 Astra vs GLM-5.3-Flash: 143x Cheaper, and the Weights Are Public

GLM-5.3-Flash costs seven cents per million input tokens. GPT-6 Astra costs ten dollars. That is a 143-fold difference on input and 200-fold on output, and the cheap one publishes its weights under MIT while the expensive one never will. A gap that size stops being a pricing question and becomes a question about what you are actually buying.

GLM-5.3-Flash is served at $0.07 and $0.25 per million tokens. Astra is $10 and $50. On the Intelligence Index the difference is 57.5 against 61 — three and a half points, for a price ratio of well over a hundred. Flash also carries the larger context window at roughly 1.31 million tokens against Astra's 1.05 million.

Work an example. An agent consuming 100 million input and 10 million output tokens a month costs $1,500 on Astra before any caching. The same traffic on GLM-5.3-Flash costs $7 and $2.50 — under $10. That is not a budget line you optimise; it is the difference between a decision and a rounding error.

GLM-5.3-Flash is a 321-billion-parameter model using a hybrid sparse and linear attention design, and it is natively multimodal rather than having vision bolted on. The sparse attention is a large part of how a 1.31M-token window can be served at seven cents: attention cost is what makes long context expensive, and that design attacks it directly.

It is also MIT-licensed with published weights, which is about as permissive as software licensing gets — commercial use, modification and redistribution with essentially no conditions beyond retaining the notice.

It is worth pausing on how unusual that index gap is relative to the price gap. Three and a half points on a composite that runs 0 to 100, against a price ratio above one hundred, is not the shape most people expect from a cheap model. It reflects how much of frontier capability has become reproducible: the expensive part is increasingly the last few points, not the bulk of the curve.

Open weights are not the same as runnable weights. At 321 billion parameters, GLM-5.3-Flash needs roughly 181 GB of VRAM for weights alone at Q4_K_M, before a single token of context. A single RTX 5090 has 32 GB. You would need six of them and change.

So the honest framing is that Flash's open weights buy you the ability to self-host on rented or owned server GPUs, to pin a version, and to fine-tune — none of which Astra offers at any budget — but they do not put it on your laptop. If running it on your own hardware is the actual goal, the models that do that are a tier down: a 32B-class model at Q4_K_M fits a 24 GB card, a 14B fits 16 GB, an 8B runs on 8 GB.

• ▸Astra: closed, hosted only, $10/$50, index 61.
• ▸GLM-5.3-Flash: MIT weights, hosted at $0.07/$0.25, index 57.5, but ~181 GB to self-host.
• ▸A 32B open-weight model: runs on a 24 GB card you own, at no cost per token.
• ▸Rule of thumb that survives all of this: a bigger model at Q4 beats a smaller one at Q8.

A hundredfold price gap invites the assumption that something is being cut. In this case the mechanism is public and specific: attention cost is what makes long context expensive, because standard attention scales quadratically with sequence length. Hybrid sparse and linear attention attacks exactly that term.

The trade is not free — sparse attention approximates, and approximations can miss the one token that mattered — but it is the reason a 1.31 million-token window can be served at seven cents per million while Astra charges ten dollars and still reprices everything above 272,000 input tokens at double. On long-context work specifically, that is the whole ballgame.

It is worth testing rather than trusting on either side. Long-context retrieval quality varies enormously between models that advertise identical window sizes, and the honest way to find out is to run your own needle-in-a-haystack test at the lengths you actually use.

Most teams that take this seriously end up with three tiers rather than one model, because the price ratios make anything else wasteful.

• ▸<strong>Local, for volume:</strong> a 14B or 32B open-weight model on your own card, for boilerplate, renaming, format conversion, first-draft tests and codebase questions. Zero cost per token and no rate limit.
• ▸<strong>GLM-5.3-Flash, for scale:</strong> anything too big or too parallel for local hardware but not hard enough to need a frontier model. At $0.07 per million this tier is effectively free relative to the others.
• ▸<strong>Astra, for the hard ten percent:</strong> long autonomous runs, gnarly debugging, anything where a failure is expensive. The 143x premium is defensible precisely because you are not paying it on everything.
• ▸<strong>Route by hand at first.</strong> Automatic routing sounds appealing and tends to send the wrong things to the expensive tier until you have data.

Three and a half index points, and something the index does not capture: Astra's long-horizon agentic results. 88.0% on SRE-Bench at one attempt, 57.7% on Terminal-Bench 4.0, and retrieval that holds at 96.3% in the 512K&ndash;1M band. On an autonomous run where a failure halfway through wastes everything before it, a higher completion rate can justify a large multiple.

What it does not buy is a reason to route bulk work through it. At 143 times the price, even a materially higher failure rate on Flash is absorbable for classification, extraction, summarisation and drafting. The arithmetic is not close.

GLM-5.3-Flash is natively multimodal: image understanding is trained into the model rather than bolted on through a separate vision encoder. For workloads that read screenshots, diagrams, scanned documents or charts, that removes an integration step and a whole class of failure at the seam between two systems.

Against a hosted model like Astra this is close to parity, since OpenAI handles images too and you never see the plumbing. It matters much more if you intend to self-host, because assembling your own vision pipeline around a text-only open-weight model is considerably more work than using one where it ships in the weights. That is a real point in Flash's favour that a price table will never show.

The caveat is the usual one for open weights at this scale: multimodal support in local runtimes lags text-only support, sometimes by months. Check that your intended runtime actually implements the vision path before planning around it.

A closing note on what MIT actually permits, because it is more permissive than most people assume: commercial use, modification, redistribution and sublicensing, with essentially no condition beyond retaining the copyright notice. There is no user threshold, no revenue cap and no field-of-use restriction. For a model of this capability that is genuinely unusual, and it is the part of this comparison that cannot be undone by a competitor's price cut.

Run both against your own evaluation set, because at this price ratio the only wrong answer is assuming. A gap this wide gives you an enormous budget for tolerating occasional retries on high-volume work, and almost none for tolerating them on a handful of hard requests a day where a failed run costs more than the tokens.

Our <a href="/models">Model Explorer</a> sizes any open-weight model against your actual hardware, and the <a href="/lab/zai-org.html">Z.ai lab page</a> tracks the rest of the GLM family. For the middle option, see <a href="/blog/gpt-6-astra-vs-glm-5-3">Astra against the full GLM-5.3</a>.

At 143 times the price difference, this is not a comparison that turns on three and a half index points. It turns on what fraction of your workload genuinely needs a frontier model. For most teams that fraction is small, and paying Astra rates on the rest is the single most common way these bills become surprising.

GLM-5.3-Flash also carries the thing Astra structurally cannot: MIT-licensed weights you can host, pin and fine-tune. That it needs around 181&nbsp;GB of VRAM to self-host is a real constraint, but it is a constraint about hardware rather than permission &mdash; and hardware constraints loosen over time in a way licensing terms do not.