GLM-5.3-Flash vs Qwen3.8-Flash-Next vs Qwen3.8-27B

Three open-weight models landed inside three weeks, all aimed at the same job: frontier-adjacent capability at a price you can leave running behind an agent. GLM-5.3-Flash is 320B with 18B active, natively multimodal, a million tokens of context, and MIT licensed. Qwen3.8-Flash-Next is 125B with 6B active and carries what Qwen calls a preview of the Qwen4 architecture. Qwen3.8-27B is a dense 27B under Apache 2.0.

Total parameter counts put them in that order, and the order tells you almost nothing about what they cost. On Featherless the 320B and the 125B are priced identically, at $0.15 per million input tokens and $0.50 per million output. The dense 27B, a twelfth the size of the largest, is the most expensive of the three. Price here follows architecture class, not parameter count.

What actually shipped

GLM-5.3-Flash is a 320B mixture of experts activating 18B per token, built on a hybrid of sparse and linear attention with Manifold-Constrained Hyper-Connections. Z.ai describes it as the first natively multimodal model in the GLM-5 series, with a 1M-token context window and an MIT licence, and notes that it was previewed as Ox Alpha and trained entirely on Chinese AI chips. Weights are 328 GB across 62 shards.

Qwen3.8-Flash-Next is 125B total with 6B activated, 48 layers at hidden dimension 2560, and 51B of its parameters sit in n-gram embeddings rather than transformer blocks. Attention pairs Gated DeltaNet with Qwen Sparse Attention at the micro-block level, across 512 experts of which ten routed and one shared fire per token. It takes text, images and video, its native context is 262,144 tokens extensible to about 1M with YaRN. Weights are 360 GB across 131 shards. The Featherless listing shows 180B rather than 125B; that is the same model counted with its n-gram embedding and MTP parameters folded in.

Qwen3.8-27B is the only dense model of the three: 27B parameters, 64 layers, hidden dimension 5120, all of them active on every token. Same 262,144-token native context, same multimodal input, and Apache 2.0. It exposes a reasoning_effort parameter with xhigh, medium and low settings, and thinking can be switched off with enable_thinking. Weights are 55.6 GB across 18 shards.

Active parameters rather than total parameters

The number that governs inference speed is how many parameters fire per token. A 320B mixture of experts activating 18B works roughly like an 18B model on each forward pass while holding all 320B in memory. A dense 27B activates all 27B. That is why the largest model here is not the most expensive one to run.

A few things jump out. GLM-5.3-Flash is the only one with a million-token context window natively rather than through YaRN scaling, and the only one under MIT, which is the most permissive licence in this comparison by a clear margin. The 27B activates half again more than GLM-5.3-Flash despite being a twelfth of its size, which is the whole case against reading total parameters as a proxy for cost.

Flash-Next activates a third of what GLM does, so on arithmetic alone it should be the cheaper of the two to serve. It isn’t cheaper on Featherless — it’s the same price, which is worth sitting with. Below roughly 20B active, the marginal cost of serving is set less by the forward pass than by memory footprint, batching and the engineering around them, and both models land in the same pricing tier as a result. Active parameters explain why the sparse models beat the dense one. They do not, past a point, separate the sparse models from each other.

Laid against what Featherless charges, the inversion is the whole story of this comparison:

How they score on the benchmarks they share

The three vendors do not publish a common benchmark suite, so this table carries only tests where at least two of the three report a figure, taken from each model card.

DeepSWE 1.1 is the only test all three report, and GLM-5.3-Flash takes it at 63.4 against 58.7 and 42.2. It also leads Toolathlon Verified at 78.4 against Flash-Next’s 73.5, and Terminal-Bench 2.1 at 84.3 against the 27B’s 73.0. On the agentic axis, which is the one these three models are pitched at, GLM-5.3-Flash wins every head-to-head it appears in.

Where the two Qwen models have figures and GLM does not, they look strong. Flash-Next posts 91.9 on LiveCodeBench v6 and 91.7 on GPQA Diamond, and the 27B is within about a point of it on both. Those are single-shot tests of code generation and reasoning rather than multi-step tool use, so they measure a different thing from the DeepSWE and Toolathlon rows. A model can be excellent at writing a function and mediocre at driving a twenty-step agent loop, and the 27B is close to exactly that: 61.7 on SWE-bench Pro against 42.2 on DeepSWE 1.1, a nineteen-point spread on two coding benchmarks that differ mainly in how much autonomy they require.

One comparison that looks available in the model cards is not. GLM-5.3-Flash reports 55.3 on HLE with tools and Flash-Next reports 35.9 on HLE, and the Qwen card does not state a matching tool configuration. Those two numbers should not be put side by side, and they are absent from the table above for that reason.

What it takes to serve them yourself

Weight size sorts these three differently from every other axis, and for anyone considering self-hosting it sorts them decisively.

The two mixture-of-experts models are within ten percent of each other on disk and both need a multi-GPU node, because a sparse model still holds every expert in memory even though it fires a fraction of them. Low active parameters buy you speed and cost per token; they do not buy you a smaller machine.

The 27B is the only one of the three that fits on a single accelerator at full precision, and the only one that runs on a desktop GPU at all: a Q4_K_M quantization drops it to roughly 17 GB and will run on a 24 GB card like a 4090, slowly, with the quality loss that four-bit implies. That is not a serving configuration, but it is the difference between a model you can put on a laptop-class budget and one you cannot, and it is why the 27B stays in this comparison despite losing most of the benchmark rows.

Our write-up on the hidden costs of local LLM inference covers what the multi-GPU option actually costs once utilisation and engineering time are counted.

What they cost to run

All three are in the Featherless catalogue. The prices below are per million tokens.

The two sparse models are priced identically despite a threefold difference in active parameters. The dense 27B is 77% more on input and 30% more on output than either of them, and it is the smallest model in the comparison. On Featherless, pricing follows architecture class rather than the number in the model’s name, which is also why a community fine-tune is priced the day it appears.

The cached input column is the one to read carefully if you are running agents. An agent resends its system prompt, its tool definitions and its accumulated history on every turn, so by the tenth step most of what you are paying for is text the server has already seen. At $0.03 per million, cached input on either sparse model costs a fifth of fresh input. Take a month of 200M input and 20M output tokens: at list rates on GLM-5.3-Flash that is $40, and with three quarters of the input served from cache it is $22. The same workload on the 27B is $48.75, because its cached rate of $0.15 is what the sparse models charge for input they have never seen before.

Context is what separates the two sparse models at equal price. Featherless serves GLM-5.3-Flash at 256K and Flash-Next at 32K. A long agent loop or a large-repository task will hit 32K well before it runs out of anything else, and a plan built on cached long context needs the context first. That, rather than price, is the reason to reach for GLM-5.3-Flash over Flash-Next today.

Switching to any of them is a base URL and a key:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.featherless.ai/v1",
    api_key="YOUR_API_KEY",
)

response = client.chat.completions.create(
    model="zai-org/GLM-5.3-Flash",   # or "Qwen/Qwen3.8-Flash-Next"
    messages=[{"role": "user", "content": "Trace this failure through the stack and propose a fix."}],
)

On the plans, the $25 a month Chat plan gives unlimited tokens at up to 32K context across four concurrent units. Developer at $50 in monthly credits raises context to 256K and includes one agent environment. Neither logs prompts or completions. Our tokenomics guide covers the three levers that actually move cost per task.

If it is many models, or large enough that per-token pricing stops making sense at any rate, the third option is neither API. That was the argument when a dedicated GLM 5.2 deployment on four MI325X GPUs replaced a roughly $150K monthly Opus bill.

How to decide for yourself

Benchmarks measure the model; latency measures whoever is serving it. Three questions get you further than the tables above.

How many steps does the task run unattended? Long agent loops are what the DeepSWE and Toolathlon margins measure, and GLM-5.3-Flash leads both. Single-turn generation is what LiveCodeBench and GPQA measure, and there the three are close enough that cost should decide.

How much context does one call need? GLM-5.3-Flash is served at 256K on Featherless against 32K for both Qwen models, and it is the only one of the three with a million-token window natively rather than through YaRN scaling. If long-document or whole-repository work is the job, that difference decides it before any benchmark does.

Are you serving it yourself or buying tokens? Self-hosting collapses the decision to the weights table: the 27B, or a multi-GPU node. Buying tokens makes weight size irrelevant and moves the whole question to served context, cached input rate and benchmark fit.

Then run your own evaluation. Collect fifty to a hundred representative examples from your actual workload and score the shortlist against those. A model four points behind on DeepSWE that costs 40% less per task is usually the better buy, and no public benchmark will tell you that.

GLM-5.3-Flash, Flash-Next or the 27B?

Pick GLM-5.3-Flash for agentic work. It wins every benchmark all three report, at 63.4 on DeepSWE 1.1, 84.3 on Terminal-Bench 2.1 and 78.4 on Toolathlon Verified. It is served at 256K where the other two are served at 32K, it carries an MIT licence, and it is joint-cheapest at $0.15 and $0.50 per million with cached input at $0.03. For most readers this is the answer.

Pick Qwen3.8-Flash-Next when the work fits inside 32K and single-shot code generation and reasoning are what you are buying, at 91.9 on LiveCodeBench v6 and 91.7 on GPQA Diamond from 6B active parameters. It costs the same as GLM-5.3-Flash and runs a smaller active slice, so if your prompts are short and your throughput needs are high it is worth measuring against GLM on your own traffic rather than assuming the benchmark leader wins. Its licence is the least permissive of the three; check it before you commit.

Pick Qwen3.8-27B when you are running the weights yourself. At 55.6 GB it is the only one of the three that fits on a single accelerator, and quantized it will run on one consumer card. It is Apache 2.0, and its 61.7 on SWE-bench Pro means well-specified single-issue work is close to the larger models. Keep it away from long unsupervised agent loops, where its 42.2 on DeepSWE 1.1 is the number that describes it.

FAQ

Can I run these locally? The 27B, yes: 55.6 GB at full precision on a single accelerator, or around 17 GB as a Q4_K_M quantization on a 24 GB desktop card. GLM-5.3-Flash at 328 GB and Flash-Next at 360 GB both need a multi-GPU node, because a sparse model holds all its experts in memory even though it activates few of them.

What context window do they have? GLM-5.3-Flash is 1M natively. Both Qwen models are 262,144 natively and reach about 1M with YaRN. Featherless serves GLM-5.3-Flash at 256K, and Flash-Next and the 27B at 32K.

Does Featherless cache prompts? Yes, and the cached input rate is listed on each model page: $0.03 per million for GLM-5.3-Flash and Flash-Next, $0.15 per million for the 27B. On agent workloads that resend a long system prompt and a growing history every turn, that is the line item that decides the bill.

Which is cheapest? GLM-5.3-Flash and Qwen3.8-Flash-Next, jointly, at $0.15 input and $0.50 output. The dense 27B is the most expensive of the three despite being the smallest.

Are they multimodal? All three take images. The two Qwen models also take video. GLM-5.3-Flash is the first natively multimodal model in the GLM-5 series.

How do these compare with the larger models? Qwen3.8-Max and Kimi K3 sit a tier above on capability and well above on price. We covered that matchup in Qwen 3.8 vs. Kimi K3, and the GLM-5.3-Flash launch post has the full benchmark card for the GLM side.

Which should I use for a coding agent? GLM-5.3-Flash, on the DeepSWE and Terminal-Bench margins and on the 256K served context. All three vendors measured on their own harnesses, so run your own repository through the shortlist before committing.

Three models pitched at the same tier, and the two that cost the least are the two with the most parameters between them. Sparse architectures broke the link between model size and serving cost, and once you are inside that tier the deciding numbers are served context and the cached input rate rather than anything on the model card. Point your client at zai-org/GLM-5.3-Flash on the Developer plan, and when your agents outgrow serverless, talk to us about dedicated.

Last updated: September 1, 2026. Prices, licences and benchmark figures move; re-verify with each provider before committing.