Qwen 3.8 27B on Cerebras changes the build-vs-buy math

Open-model speed just stopped being a benchmark footnote. Cerebras added Qwen 3.8 27B to its public inference API on September 3, 2026. The catalog lists it at about 1,850 tokens per second (Cerebras model catalog). The listed price is $0.99 per million input tokens, and output runs $1.49 (Cerebras pricing). That is a real model doing real work at a speed most teams have never seen from an API. The headline number is the least interesting part, though. The pricing page and the rate-limit table matter more. Together they set up a three-way decision for automated workloads: frontier API, fast open-weights API, or self-hosted. As of September 12, 2026, the numbers below are checked against the vendor docs and the live listings.

What actually shipped on September 3

The listing is one model with published numbers, which is rarer than it should be. The model ID is qwen-3.8-27b: a 27-billion-parameter dense model from Alibaba. It takes text and images, and it supports configurable reasoning (model page). Context sits at 64k tokens on the free tier and 128k on paid tiers. The catalog pegs speed at about 1,850 tokens per second. OpenAI’s open-weight gpt-oss-120b runs at roughly 3,000 on the same page (catalog).

The adoption numbers say this is not a niche drop. The base weights landed on HuggingFace in early August. The repo now shows about 14,800 likes and 7.7 million downloads, which signals real adoption (HuggingFace). Community finetunes and quantizations have appeared daily since early September. That cadence is the usual signature of a model builders have standardized on. The launch threads were busy too. The Qwen 3.8 27B release pulled 1,438 points on Hacker News in August (HN). The Cerebras listing pulled 691 more this month (HN).

Free-tier access is thin: 5 requests per minute and 30K uncached tokens per minute. The Developer tier moves to 300 requests per minute and 150K uncached tokens per minute. Total allowance on that tier is 450K tokens per minute (rate limits). Those ceilings matter more than they look, because agents burn tokens in bursts rather than steady streams.

What it costs, and the cache catch

The sticker prices are simple. What complicates them is how caching is billed, because that is where agent workloads live or die.

That last detail is the part most launch coverage will skip. On most providers, an agent loop that re-reads its context gets a fat discount on the repeated input. Cached tokens typically run a fraction of the sticker rate there. On Cerebras, the repeated input bills at full price every time. The docs are explicit that the cache key “does not affect billing.” For chat workloads with short prompts, nobody notices. For long multi-turn agent runs, input is most of the bill. That is the same token math I covered when looking at how agent loops multiply token costs (agent token costs).

Run the comparison on that workload shape and the picture flips from the headline. OpenRouter lists the same weights at $0.15 per million input and $2.00 per million output (OpenRouter). That listing also carries a 1M-token context window. Commentary in the launch thread claimed cached input there runs roughly a quarter of sticker (HN). Cerebras charges about 6.6x more per input token with no cache discount, while OpenRouter’s premium lands on output. Input-heavy loops favor OpenRouter; output-heavy generation favors Cerebras. And the speed gap in Cerebras’s favor is enormous when generation volume dominates.

The same math explains the tier structure. Cerebras rate-limits on estimated total consumption (rate limits), counting your max_completion_tokens setting before the request even runs. At 150K uncached tokens per minute, a parallel agent fleet burns through that in seconds. Every tool call resends the whole context, which is why the burst dies fast. Speed you cannot sustain is just a demo.

The limits that decide fit

Context is the first wall. The paid tier’s 128k sounds roomy until you feed a whole codebase plus history into an agent loop. Near the ceiling, older material starts falling out of scope. Community sentiment in the launch thread converged on the same read (HN). Treat it as a specialized sub-agent model for bounded tasks, not a whole-repo brain. The free tier’s 64k is even tighter.

Throughput ceilings are the second wall, and they interact with the first. The Developer tier’s 300 requests per minute is generous for a single workflow. But parallel agents carrying 100k-token contexts hit the 150K uncached limit quickly, because every tool call re-sends the working context. One commenter ran that arithmetic and got a few seconds of flat-out run time per minute before throttling (HN). Context and throughput bind together, which is why the fit question comes before the price question.

There is a quality caveat worth carrying too. Simon Willison’s August review found the model excellent but prone to overthinking by default (Simon Willison). The thinking budget burns tokens unless you control reasoning effort deliberately. If the model thinks for 10,000 tokens before answering, speed matters less. Speed pays off when you control what the tokens are spent on.

Build, buy, or both

The actual decision was binary for years: pay the frontier premium or run something smaller yourself. Fast open-weights APIs split it into three options. The right pick follows from workload shape, data sensitivity, and burstiness, which benchmark charts never capture.

• Your workload is output-heavy generation, like bulk copy variants, summaries, or classification with short inputs.
• You need burst speed on bounded tasks that fit inside 128k tokens with room to spare.
• Latency itself is the product, like interactive tools where waiting loses the user.
• Your data can leave your infrastructure, since this is a hosted endpoint.
• You can tolerate rate ceilings, or you can budget for a dedicated Cerebras endpoint.

Check three or more, and the fast open-weights API is worth a pilot. Miss the first one, and input-heavy agent loops will bleed money at full-price cached input. Miss the last one, and self-hosting looks different. A single local GPU now serves this model class at usable speeds. One commenter’s vLLM setup ran about 45 tokens per second (HN), which covers background jobs if not interactive ones. The trade is control versus burst capacity. I laid out that calculus in the local-first deep dive (local-first AI teams).

The frontier tier keeps its place for the hardest judgment work. Claude Sonnet 5 runs $2.00 per million input and $10.00 per million output with a 1M context (OpenRouter). That premium buys capability you cannot get elsewhere, which is why it survives the price comparison. The pattern that emerges is routing rather than replacement, because each lane has a job it is cheapest at. Fast cheap models take the volume while frontier models take the decisions, and self-hosting takes the steady work. I compared how the frontier labs split marketing workloads earlier this month (Anthropic vs OpenAI workloads). The routing discipline there applies here unchanged.

What I’d watch next

Three signals would change this math again, and all three are checkable. First, Cerebras capacity arriving on OpenRouter would put 1,850 tokens per second behind unified billing. That would collapse the comparison into pure price. Second, any change to cached-input billing at Cerebras would flip the agent-loop verdict overnight. That lever is the single biggest one in the math. Third, a context window beyond 128k would remove the main argument for the sub-agent lane, where cautious teams start. The HuggingFace download curve says the demand is there. The next pricing page revision decides who captures it, which is why this page is worth a re-read next quarter.

Filed under news, which is where model releases become budget decisions on this site. The Cerebras docs are the primary source, while the launch thread on HN is where the skepticism lives.