Qwen3.8-27B Hits Cerebras at 1,500 Tokens a Second: The Full Picture

A Hacker News thread is circulating right now with a simple claim: Qwen3.8-27B, Alibaba's newest open-weight model, is live on Cerebras's inference cloud at roughly 1,500 tokens per second. It's fresh enough that the comment count and thread age are still moving — worth checking the live page rather than trusting any snapshot, including this one.

Before writing anything else, I checked the link the post actually points to. That's where this got interesting.

The link doesn't back the headline. The model does.

The submission points to Cerebras's general model catalog at inference-docs.cerebras.ai/models/overview. Fetch that page today and the "Available Models" table lists exactly two entries: OpenAI GPT-OSS (120B, ~3,000 tok/s) and Gemma 4 31B (31B, ~1,850 tok/s). No Qwen3.8-27B in sight.

That doesn't make the claim false — it makes the link stale. Cerebras maintains a separate, fully populated page at /models/qwen-3.8-27b, and it confirms everything the headline promises: model ID qwen-3.8-27b, a measured ~1,500 tokens/sec, live pricing, live rate limits.

The model is real and it's live. The catalog page the submitter linked simply hasn't caught up yet.

One community report from mid-August suggested Cerebras planned to swap Gemma-4-31B out of the free tier for Qwen3.8-27B during the first week of September — which is this week, and would explain the gap. Treat that as a plausible explanation, not a confirmed one; it traces back to a single forum post, not a Cerebras announcement, and I haven't found independent corroboration.

The lesson generalizes past this one thread: if you're verifying a vendor claim, don't stop at whatever link happens to be attached. Check the model's own page.

What's actually live

Pricing is $0.99 per million input tokens, $1.49 per million output. The model is multimodal — text and image in, text out — and supports tool calling, parallel tool calling, structured outputs, streaming, and prompt caching.

Cerebras first reacted to Qwen3.8-27B back in mid-August, congratulating the Qwen team on X and promising it would land "soon" on the Shared Tier. What's live now is that promise made good: real pricing, real limits, three weeks after the initial nod. Worth separating in your head — the August tweet and this week's launch are not the same event.

One detail for anyone porting workloads over: reasoning defaults to high on Cerebras's endpoint, one notch below Qwen's own upstream default of xhigh. Simon Willison has noted that xhigh burns through context fast enough to matter on smaller setups — so Cerebras's lower default may be a deliberate choice, not an oversight.

What Qwen3.8-27B actually is

Alibaba shipped it on August 14, 2026: a 27-billion-parameter dense model, not a mixture-of-experts, under Apache 2.0. Native context runs to 262,144 tokens, extensible to 1,000,000 via YaRN — Cerebras currently exposes a fraction of that ceiling.

The architecture is a hybrid, not a plain transformer stack. Sixty-four layers arrange into 16 repeating blocks, each pairing three linear-attention (Gated DeltaNet) layers with one full-attention (Gated Attention) layer. Only 16 of the 64 layers build a conventional KV cache — the same design lineage as Qwen's 2.4-trillion-parameter flagship, tracing back to Qwen3-Next.

Some coverage, Wikipedia included, calls the 27B a distilled model. Kingy.ai's independent analysis is more careful: Alibaba hasn't published enough about the training process to say how much of the gain is distillation versus separate training on the same architecture.

It replaces Qwen3.6-27B outright, and Qwen's own benchmark card shows a sizable jump on DeepSWE 1.1 — worth pulling the primary card yourself for the exact figures rather than trusting any single writeup, this one included.

1,500 tok/s isn't a record. It's not even close.

Here's what the headline number obscures: Cerebras hit exactly 1,500 tokens per second before, with Qwen3-235B, back in July 2025. Two earlier launches beat it outright — Llama 4 Scout ran north of 2,600 tokens per second in April 2025, and Qwen3-32B hit roughly 2,400 the following month. Both figures come straight from Cerebras's own press materials.

That's not a knock on the number. A typical GPU-backed inference API tops out around 150 tokens per second, so 1,500 is still a real 10x jump for anyone building on it. It's Cerebras's wafer-scale hardware doing what it always does — this just isn't a new milestone for the company.

The benchmarks, with the footnotes attached

Qwen's own launch table, independently reviewed by Kingy.ai, has Qwen3.8-27B beating Qwen3.7-Plus on most reported metrics, with GPQA Diamond and HLE (text) cited as the exceptions.

Against the frontier comparison point in that same table — labeled "Claude Opus 4.6 Max" — Qwen3.8-27B is reported to trail by several points across GPQA, HLE, Terminal-Bench, and NL2Repo. Treat the exact gaps as approximate until you've checked Qwen's published card directly; secondhand benchmark tables are where small transcription errors like to hide.

One correction worth making explicit: Anthropic doesn't sell a product called "Opus 4.6 Max." Claude Opus 4.6 ships with four effort levels — low, medium, high, and max — and "max" is a setting, not a SKU. Qwen's chart almost certainly means Opus 4.6 run at its highest effort tier, labeled informally by whoever built the table.

If the reported gaps hold up, that's still a strong showing for a 27B dense model against a much larger closed system. But read the fine print before the leaderboard position: NL2Repo blocks package installs so models can't shortcut the answer, DeepSWE runs at 256K context specifically because that favors Claude Code's setup, and HLE uses GPT-4o as the grading judge.

Vendor tables are built to make the vendor's model look good — that's not an accusation, it's the genre.

What the thread actually cared about

The speed number barely came up. The practical questions did:

• Prompt caching? Yes — Cerebras's own docs confirm it, which settles a real cost concern for agentic coding workloads.

• Why not host the 2.4-trillion-parameter flagship instead of the 27B? Two theories surfaced: a wafer interconnect limit at that scale, and the more cynical read that Cerebras's inference business exists to sell hardware — so the model that fits the shared tier economically wins over the model that wins headlines.

• Onboarding friction. Complaints about signup flow and support channels are a recurring feature of this kind of thread — worth noting, but treat any single complaint as one person's experience, not a pattern, unless it's corroborated elsewhere.

• Speed isn't everything. A sentiment that shows up in nearly every Cerebras thread, and shows up here too.

Specific usernames, comment counts, and verbatim quotes from a live thread age out fast — check the source directly rather than trusting a snapshot from this piece.

The caveat worth keeping in mind

Cerebras made a similar throughput promise last year for Qwen3-Coder-480B on its Code plan: 2,000 tokens per second, advertised. InfoWorld's review, "Down and out with Cerebras Code," found real-world runs rarely broke 500 tokens per second, and some stayed under 100.

That's a different model on a different product tier, so it isn't evidence against today's 1,500 figure — but it's a good reminder that headline throughput numbers and what your own prompts actually get are two different measurements.

Run your own benchmark against your own workload before you build a pipeline around anyone's advertised number, Cerebras included.

Bottom line

Qwen3.8-27B on Cerebras is real, and the 1,500 tokens-per-second figure checks out — on its own model page, not on the general catalog link the Hacker News post actually pointed to. It's not a new speed record for Cerebras.

And the benchmark story is a strong one with real vendor-table caveats attached, worth verifying against Qwen's primary source rather than taking on faith from any secondary writeup.

If you need fast, cheap multimodal reasoning inside a 128K context window: test it against your own workload, and check the model-specific docs page — not the one linked in whatever post sent you here — before you commit spend.