GLM-5.3-Flash is the cheapest model on DigitalOcean. It's also the most verbose.

GLM-5.3-Flash is the first natively multimodal model in Z.ai’s GLM-5 series, released under an MIT license. It is not a post-training refresh of GLM-5.2. It starts from a newly trained base model, with the architecture and training recipe rebuilt around efficiency.

The headline architectural number is the one that matters for cost: 320B total parameters with just 18B active per token. Z.ai reports it outperforming GLM-5.2 across benchmarks at one tenth the price, while approaching Claude Opus 4.8 on coding and agentic work — 84.3 on Terminal-Bench 2.1 and 63.4 on DeepSWE.

Two architectural changes drive that. The first is a hybrid attention design combining sparse and linear attention, a first for the GLM series, aimed specifically at cutting long-context serving costs while keeping long-context capability intact. The second is Manifold-Constrained Hyper-Connections, which Z.ai uses to improve scaling efficiency. Both sit on top of a 30T-token multimodal pre-training corpus.

What makes this interesting next to the other recent open-weights arrivals on DigitalOcean Serverless Inference is the compute profile. Qwen3.8-Max is a 2.4T parameter model with 95B active per token. Kimi K3 is larger still. Flash activates 18B — roughly a fifth of Qwen’s active parameters and a far smaller fraction of Kimi’s — and lands at effectively the same score on Artificial Analysis’s Intelligence Index as Kimi K3 Max.

That is the pitch: frontier-adjacent capability at a fraction of the per-token compute, which is why DigitalOcean can serve it at $0.15 per million input tokens against Kimi’s $3.00.

It is a real pitch, and the benchmark numbers behind it are Z.ai’s own. What nobody publishes is how many tokens a model uses to reach an answer, and that turns out to be where a meaningful share of the advantage goes.

Three open-weights models available on DigitalOcean Serverless Inference: glm-5.3-flash, qwen3.8-max, and kimi-k3. Their DigitalOcean rates, per million tokens:

Two prompt sets. The first is 24 open-ended questions across three difficulty tiers: trivial lookups like the SSH one, moderate analytical questions like why batching raises throughput without lowering per-request latency, and hard multi-constraint problems like choosing a deployment topology under a fixed budget. No formatting instructions, no system prompt, no sampling parameters. The second is 20 tasks with deterministic answers, used to check whether cheaper output comes at the cost of correctness.

Every prompt ran five times against every model, in randomized order.

One framing note before the numbers. Artificial Analysis scores both Kimi K3 and GLM-5.3-Flash at 57 on its Intelligence Index. Two models, identical on the same independent composite, 20x apart on input price and 30x apart on output. That is someone else’s measurement and we did not verify it. But it means the interesting question is not which model is smarter. It is what each one costs to answer.

Flash wins. It is not close. But if you sized your infrastructure budget by dividing Qwen’s per-token price by twelve, you would be off by more than a factor of five in the direction that hurts.

Kimi’s premium erodes less: 30x on paper becomes 17x in practice. Qwen’s erodes much more: 12x becomes 2.3x. The asymmetry is the clue, and it points at output length.

Median output tokens on identical prompts, no formatting instructions given to any model:

Flash emits 4.0x more tokens than Qwen on trivial questions and 5.7x more on hard ones. That is most of the answer. A model that is 12x cheaper per token and uses 5x more tokens is not 12x cheaper.

Where do the tokens go? Both Flash and Kimi expose their deliberation in a separate reasoning_content field, so we can count it directly. Median share of billed output tokens spent on reasoning:

Between two thirds and five sixths of the output bill is text the user never sees. Flash has the highest share of the three at tiers 1 and 2, and the share climbs with difficulty rather than staying flat.

The tail is worse than the median suggests. Flash’s mean output is 3,111 tokens against a median of 1,409 — a coefficient of variation above 1.0. The longest single response we recorded ran 15,006 tokens at a 94.7% thinking share, answering one deployment-architecture question. That single response cost $0.00753: 4.8x the average Flash request in this study, 24x the median trivial one, and 30x what the average request costs at reasoning_effort: low.

This is why we report medians throughout. Means would flatter nothing and mislead everyone.

DigitalOcean’s endpoint is OpenAI-compatible and forwards chat_template_kwargs, so you can pass enable_thinking: false and ask a model to skip deliberation. That is the switch most write-ups reach for. We reached for it too.

We ran the full prompt set three times against each model: once sending no thinking parameter at all, once with enable_thinking on, once with it off. The same flag produced three different behaviors.

On GLM-5.3-Flash, it is cosmetic. Setting it false empties the reasoning_content field, so your logs go quiet. Output tokens went up 20.9% and cost went up 11.1%.

The deliberation did not stop. It moved into the visible answer. Here is the beginning of a response to the deployment-topology question, with thinking supposedly disabled:

Let me analyze this problem carefully. The setup: - 70B model - Peak traffic: 40 requests/second…

And here is one for the trivial question about what TTFT stands for:

The user is asking about “TTFT” in the context of LLM inference… Let me think about what I know about TTFT:

We detected chain-of-thought left in the visible answer on at least 103 of 120 responses. The detection is a keyword heuristic, so treat that as a floor rather than a count. It fired on 38 of 40 trivial prompts and 31 of 40 hard ones.

On Kimi K3, the same flag works properly. Output fell 67.9% and cost fell 75.5%. Per-call input overhead dropped from 99 tokens to 32, because the reasoning scaffold in the chat template goes away too.

On Qwen3.8-Max, thinking is already off. DigitalOcean ships it that way. Turning it on raised output 429% and cost 508%.

So enable_thinking is not a portable parameter. On one model it is a 75% saving, on another a 5x cost increase, and on a third it changes nothing except your visibility.

But for GLM-5.3-Flash it is also simply the wrong parameter. The model card documents a different control, and we had not read it closely enough.

GLM-5.3-Flash exposes a thinking budget through reasoning_effort, which takes low, high, or max. The model card says it defaults to max when not passed. We tested all three levels against the same 24 prompts.

Two results here.

The default really is max. Paired on identical prompt and repetition, default and explicit max come out at a median ratio of 0.984. Every unconfigured request you send to GLM-5.3-Flash runs at the most expensive setting available.

Reducing it is a 4x to 6.3x saving. low cut cost 84% against the default. That is far larger than anything else we measured, including switching models.

The effect is adaptive rather than uniform, which is what you would want. Median thinking share by difficulty:

At low, deliberation on trivial questions essentially stops — 3% of output tokens against 72% on defaults. On hard questions it keeps thinking, at around 40%. The model is not being lobotomized; it is being told not to deliberate over questions that do not need it.

We also tested clear_thinking: true, which the model card recommends for chat scenarios. It changed nothing measurable: a paired ratio of 0.99 and a slightly higher cost. Worth knowing so you do not reach for it expecting savings.

Nine configurations — three models, three thinking modes — span 18.5x on cost per request.

Read rows 6 and 7 together. Kimi K3 configured well costs less than Qwen3.8-Max configured badly, despite listing at 2.5x Qwen’s output price. One boolean moves Kimi from 17.01x to 4.17x — further than switching to a different model would have moved you.

Flash’s three enable_thinking configurations sit within 11% of each other. That is not because Flash has no lever, but because we were pulling the wrong one. With reasoning_effort added, the same ladder looks different:

The spread is no longer 18.5x. It is 106x, and the single largest contributor is one parameter on one model.

There is a second-order consequence worth stating. Default configuration is not uniform across models — Qwen ships with thinking off, Flash ships at maximum effort — so any comparison that runs several models “out of the box” is comparing configurations, not models. Most published comparisons do exactly that, including this one until we ran these arms.

An obvious objection to everything above: maybe the expensive models are expensive because they are better, and you are measuring the price of quality.

So we built a second set: 20 tasks with deterministic answers — cost arithmetic, expected value under a retry policy, a combinatorics problem, a latency-budget derivation — each requiring a final line in a fixed ANSWER: format so responses could be graded by string extraction rather than judgment. Five reps across three models, three thinking modes, and two reduced effort levels. 1,099 graded responses.

At their default settings, all three models scored 100%.

Across the nine enable_thinking configurations, accuracy was at or near 100% everywhere while cost per correct answer differentiated by 33x. Within that boundary, the cheap model is not cheap because it is worse. It is not worse.

But reasoning effort is not free. Flash scored 100% at default, 98% at high, and 92% at low. The saving has a price, and we can say exactly where it lands: every single failure was on a tier-3 task. Tiers 1 and 2 were perfect at every effort level.

At low, the model got a multi-step cost-modeling question wrong three times out of five — twice by returning 0.6122 where the answer was 61.22, a unit error rather than a reasoning error. Reduced effort does not make the model worse at recall or arithmetic. It makes it worse at holding a multi-step chain together and checking its own work.

Cost per correct answer still favors low, because an 8% failure rate does not outweigh an 84% discount on a task set this easy. We would not draw that conclusion for harder work. Which brings us to the caveat that matters most: our task set saturated at 100% for six of the eleven configurations. A set that easy can detect that degradation exists but cannot tell you how bad it gets. On genuinely hard reasoning, expect the gap to widen.

The two prompt sets differed in one important way: the verifiable tasks demanded a fixed answer format, and the open-ended prompts demanded nothing. That accidental contrast turned out to be the most useful result in the study.

Structure suppresses Flash more than it suppresses anything else, and Flash’s verbosity is exactly what was eroding its price advantage. So the advantage moves with the workload:

Under structured output, Flash realizes almost exactly the advantage its list price implies. Unconstrained, it realizes about a fifth of it against Qwen.

There is a caveat that keeps this from being a free lunch. We also ran the eight trivial prompts with “Answer in one sentence.” appended. Output dropped 70–91% across all three models — a larger effect than the thinking parameter had on two of them. But thinking share did not move: Flash went from 0.72 to 0.77, Kimi from 0.65 to 0.65.

The instruction compresses the answer, not the deliberation. You still pay the same proportion of your bill for reasoning you cannot see. You just pay it on a smaller bill.

Set reasoning_effort explicitly on GLM-5.3-Flash. Not setting it means max, which is the most expensive setting available. This is the single largest lever in the study.

For classification, extraction, routing, formatting and lookups, use reasoning_effort: low. It was 6.3x cheaper than the default with no accuracy cost on anything below hard multi-step reasoning.

For mixed workloads, high is the better default than the default. 4x cheaper than max at 98% versus 100% on our task set. If you are going to pick one setting and leave it, pick this one.

For genuinely hard multi-step reasoning, leave it at max. Every failure we saw at reduced effort was a tier-3 task, and our task set was too easy to tell you how much worse it gets on harder work.

If your output is open-ended and unbounded, budget from measured tokens rather than list price. Run a hundred representative requests and divide.

If you are already on Kimi K3, test whether your workload tolerates enable_thinking: false. It was a 75% saving, at a 2-point accuracy cost on our set.

If you are on Qwen3.8-Max and considering thinking mode, it costs 5x. Verify it buys you something before enabling it.

Do not use enable_thinking: false on GLM-5.3-Flash expecting savings. It raised our costs by 11%. And do not expect clear_thinking: true to change anything; it did not.

All three models are available on DigitalOcean Serverless Inference today. The endpoint is OpenAI-compatible at https://inference.do-ai.run/v1, so testing any of this on your own workload is a base URL change and a model ID — glm-5.3-flash, qwen3.8-max, or kimi-k3. Everything in this post was measured through that endpoint with the standard openai Python client.

An honest note, since the prices in this post are not a DigitalOcean-exclusive number. GLM-5.3-Flash is MIT-licensed and Z.ai publishes the same list rates we used, so the per-token cost of the model is not itself a reason to choose one host over another. Anyone quoting you a dramatically lower per-token price on identical weights is either discounting or measuring something else.

What differs is everything around the token. Three things mattered while running this study, and they are the same three that matter in production.

The rest of the stack is in the same place. The token price is only part of an inference bill. If your vector database, object storage and application servers sit in one provider’s network and your model sits in another’s, you pay egress on the data and you wait for the round trip on every retrieval. For a RAG pipeline doing several retrievals per request, that cross-provider hop can add more latency than the model’s own time to first token — and none of it appears in a per-token comparison. Running inference next to Managed Postgres, Spaces and App Platform removes that hop.

One account, one bill. Serverless Inference usage appears on the same DigitalOcean account and the same invoice as the rest of your infrastructure. That sounds administrative until you try to audit an inference bill split across three vendors with three billing models and three token-accounting conventions. It also means no separate procurement cycle to test a new model.

There is a path off per-token pricing. The measurements here are all serverless. If your workload outgrows that — sustained throughput, predictable volume, or a need for isolation — Dedicated Inference offers the same OpenAI-compatible API surface with reserved capacity, so moving is a configuration change rather than a rewrite. Below that again, GPU Droplets let you run your own serving stack on your own hardware; that one is a genuine re-architecture, but it is available on the same account without changing providers.

None of that shows up in a per-token comparison, which is the point. Per-token price is the number that is easy to compare and the one least likely to determine your bill, as the rest of this post has hopefully demonstrated.

Everything ran against DigitalOcean Serverless Inference at https://inference.do-ai.run/v1, which is OpenAI-compatible.

No sampling parameters. Temperature, top_p and penalties were never sent. Kimi K3 uses fixed sampling values, so setting them on the others would have introduced an asymmetry we would then have to defend. Every model ran at platform defaults.

Non-streaming, max_tokens=32000. An earlier pass at 8,000 right-censored 20% of Flash’s tier-3 responses — the model was still deliberating when the budget ran out, having produced no answer at all. The reported run has zero truncated records and every finish_reason is stop.

Randomized execution order. The full model × prompt × repetition matrix was shuffled with a fixed seed, so platform drift spreads across models rather than landing on whichever ran last.

Token accounting. DigitalOcean’s usage object does not break out reasoning tokens — completion_tokens_details comes back null — but the models expose deliberation in a reasoning_content field on the message. We tokenized that locally with each model’s own tokenizer and reconciled the split against billed completion_tokens. The residual is a constant per-model chat-template offset: +2 for Flash, +1 for Qwen, +13 for Kimi. A constant offset is what a correct tokenizer looks like; an erratic one would have meant we were counting wrong. All shares are reported against billed tokens with the offset left in.

Deliberation controls were sent three ways, because they are not interchangeable. enable_thinking and clear_thinking go inside chat_template_kwargs; reasoning_effort goes at the body root. Each request logs the exact extra_body it sent. We verified the parameters took effect behaviorally rather than trusting a 200 response: arms were paired on prompt and repetition, and an ignored parameter would have produced indistinguishable token distributions.

Medians, not means, for the reasons given above. Five repetitions support a median and a range, not a tight confidence interval.

This measures cost per request and cost per correct answer, not cost per completed task. No sandboxes, no multi-turn agent loops, no code execution. Agentic workloads are the obvious next measurement and we have not done it.

Capability is held constant by citation, not by testing. Artificial Analysis scores both Kimi K3 and GLM-5.3-Flash at 57 on its Intelligence Index. Those are their measurements, not ours, and we did not attempt to replicate them.

The verifiable task set is too easy. Six of eleven configurations scored 100%. It was sensitive enough to detect that reduced reasoning effort degrades accuracy — 92% at low — but not to tell you how far that degrades on genuinely hard work. The accuracy comparison establishes equivalence at this difficulty on this task class and nothing broader.

We tested the wrong parameter first. Our initial arms used enable_thinking, which is not the control GLM-5.3-Flash documents. We found reasoning_effort only after re-reading the model card, and it changed the conclusion substantially. The enable_thinking results are reported as measured, but read them as a finding about that parameter, not about the model’s capacity to deliberate less.

We got one answer key wrong. On the latency-budget task, all 45 responses answered 43 and our key said 42. The models were right: the first token arrives at TTFT, and only subsequent tokens add to the total. We corrected the key and are disclosing it because a frozen answer key that never turns out to be wrong is usually a key nobody checked.

Twelve Kimi K3 responses had unaccounted billed tokens, where completion_tokens exceeded returned reasoning plus answer by between 85 and 391 tokens. That is 12 of roughly 1,000 Kimi records. We could not account for the difference. Flash and Qwen show no such tail.

One call out of 2,700 failed with an HTTP 429 after five retries.

Prompt caching fired on 297 records, always at exactly 128 tokens, because repeated identical prompts hit the cache on later repetitions. This affects input cost only, which is a small fraction of these bills. We left it in rather than suppressing it.

Token counts are not comparable across the two prompt sets. The verifiable tasks carry a format instruction and the open-ended prompts do not. Compare ratios between models within a set, not absolute counts across sets.

These are point-in-time numbers. Prices, serving defaults and model versions change. The pricing snapshot date is in the repository.

The repository has the frozen prompt sets with their SHA256, the measurement harness, every raw response log, the grader, and the analysis script that regenerates each number and chart in this post. Model IDs are glm-5.3-flash, qwen3.8-max and kimi-k3.

The whole study costs about $14 and an afternoon.

If you re-run it and get different numbers, open an issue. We would like to know.

Further reading: the GLM-5.3-Flash model card, DigitalOcean Serverless Inference documentation, and our earlier work on LLM inference benchmarking.

Is GLM-5.3-Flash the cheapest model on DigitalOcean Serverless Inference? In our measurements, yes, in every configuration we tested. At default settings it cost $0.00156 per request against $0.00361 for Qwen3.8-Max and $0.02661 for Kimi K3. With reasoning_effort: low it cost $0.00025 — 14.5x cheaper than Qwen and 106x cheaper than Kimi.

Does turning off thinking mode reduce cost? It depends on the model and on which parameter you use. On Kimi K3, enable_thinking: false cut cost 75.5%. On Qwen3.8-Max thinking is already off by default. On GLM-5.3-Flash, enable_thinking: false raised cost 11.1% because the model kept deliberating inside the visible answer; the parameter that works there is reasoning_effort, which cut cost up to 84%.

What is the default reasoning_effort for GLM-5.3-Flash? Maximum. If you do not send reasoning_effort, the model runs at max. We confirmed this by comparing unset requests against explicit max on identical prompts: a median ratio of 0.984. Every unconfigured request runs at the most expensive setting.

Does lowering reasoning effort hurt accuracy? Yes, on hard problems. On 20 verifiable tasks, GLM-5.3-Flash scored 100% at default, 98% at high, and 92% at low. Every failure was on a multi-step reasoning task; simpler tasks were unaffected at every level.

Why is my LLM bill higher than the pricing page suggests? Most likely output volume. Reasoning models emit large numbers of tokens that are billed but never displayed — between 65% and 84% of the output bill in our measurements. Per-token price tells you the rate, not the quantity.

What proportion of an LLM bill is reasoning tokens? For GLM-5.3-Flash at its default settings, a median of 72% on trivial questions rising to 84% on hard ones. Setting reasoning_effort: low drops that to 3% on trivial questions and 40% on hard ones. For Kimi K3, 65% rising to 82%. Qwen3.8-Max ships with thinking disabled and pays none of this by default.

Does the cheaper model give worse answers? Not at default settings. Across the 899 graded responses covering the three models at their three enable_thinking modes, all three scored at or near 100% on deterministic problems — the lowest was Kimi K3 at 98% with thinking disabled — while cost per correct answer varied by 33x. Reducing GLM-5.3-Flash’s reasoning effort does cost accuracy, at 98% for high and 92% for low, which is why the full graded set runs to 1,099 responses across eleven configurations.

Where can I run GLM-5.3-Flash? The weights are MIT-licensed and available on Hugging Face, so it can be self-hosted or run through any host that serves it. We measured it on DigitalOcean Serverless Inference, where it is available today alongside Qwen3.8-Max and Kimi K3 through an OpenAI-compatible endpoint at https://inference.do-ai.run/v1 with the model ID glm-5.3-flash.

Is GLM-5.3-Flash cheaper on DigitalOcean than elsewhere? The per-token rate is not a differentiator: the model is open-weights and DigitalOcean’s rates match Z.ai’s published list prices. What changes the total is proximity to the rest of your stack, since egress and round trips on every retrieval are not part of a per-token comparison, and whether you can move to dedicated capacity without re-platforming.

How do I reduce output token costs? Three levers, in order of size. Set reasoning_effort explicitly on GLM-5.3-Flash: low was 6.3x cheaper than the default and high was 4x cheaper. Constrain the output format: requiring a fixed answer structure cut Flash’s median output 80.4%. Add a brevity instruction: “Answer in one sentence” cut trivial-question output 70–91% across all three models. Only the first reduces the proportion of the bill spent on reasoning; the other two reduce the bill while leaving that proportion intact.