The low price only holds if you set two things right. Repeat the same prompt start on every request, and turn the model's thinking off when a request does not need it.
Is Qwen3.8 Flash Next cheap enough, and good enough, for an app that sends tens of thousands of short requests a day? That question comes up once a product moves from a demo to real traffic. A small price per request then turns into a daily bill.
What's new
Qwen released Qwen3.8 Flash Next on 26 August 2026. Qwen calls it an experimental preview of the design that will underpin Qwen4, its next model generation.
The model is a mixture of experts (MoE). That means each token passes through only a small part of the network. Qwen3.8 Flash Next has 125 billion parameters, and 6 billion of them work on each token. Each token therefore needs far less computing than the full size suggests.
Qwen also changed how the model reads long prompts. In three of every four layers, a cheaper method keeps a running summary of earlier text. The fourth layer looks back at selected blocks of the text in full detail. The summary method, Gated DeltaNet, comes from a December 2024 research paper. A summary stays the same size however long the prompt gets. That is why long prompts cost less to serve.
Qwen reports the scores below against its own Qwen3.8 27B, which we also serve. These are Qwen's numbers from its model card, not our measurements.
| Benchmark (what it tests) | Qwen3.8 Flash Next | Qwen3.8 27B |
|---|---|---|
| SWE-bench Pro (fixing real issues in code repositories) | 62.5 | 61.7 |
| LiveCodeBench v6 (competitive programming problems) | 91.9 | 90.3 |
| CoWorkBench (Qwen's own test of long office tasks) | 73.9 | 70.7 |
| IFBench (following detailed instructions) | 81.3 | 79.5 |
| GPQA Diamond (graduate-level science questions) | 91.7 | 89.2 |
| AndroidWorld (completing tasks on an Android phone screen) | 84.5 | 81.9 |
Qwen3.8 Flash Next scores slightly higher than Qwen3.8 27B on every row. Qwen ran SWE-bench Pro through the Claude Code agent with a 256K-token limit. Your prompts may behave differently.
Specs and context window
The context window is the most text the model can read in one request: prompt, history and documents together. For Qwen3.8 Flash Next on our API, it is 256K tokens.
| Spec | Qwen3.8 Flash Next on our API |
|---|---|
| Model ID | qwen/qwen3.8-flash-next |
| Input | Text and images |
| Output | Text |
| Context window | 256K tokens |
| Longest answer per request | 131,072 tokens |
| Time limit per request | 300 seconds |
| Reasoning | On by default |
| Tool calling | Supported |
| Parameters | 125B total, 6B active |
| Licence | Qwen Community License 1.0 |
| Processing region | EU-hosted |
Qwen's own model card allows up to 1,000,000 tokens with extra settings. Our API serves the 256K-token window shown above, as the model page lists it.
Reasoning means the model writes out its thinking before it answers. That thinking, the reasoning trace, counts as output tokens. It shares the max_tokens budget with the answer.
We also measure speed in our own status checks. Over the seven days before 23 October 2026, the median time to first token (TTFT) was 596 ms. TTFT is the wait before the first token of the reply arrives. Output then ran at 53 tokens per second, with reasoning tokens included. These are short test requests, and incidents show on our status page.
Pricing
You pay per token, with no base fee. These are our prices of 23 October 2026, per million tokens:
| Token type | Price per million tokens |
|---|---|
| Input | $0.20 |
| Cached input | $0.05 |
| Output | $0.50 |
Cached input is the part of a prompt that exactly matches the start of a recent request. We keep that start in GPU memory, so we do not have to read it again. That repeated part is then billed at $0.05 instead of $0.20, as the model page lists. Finding that start in memory is called a cache hit, and a hit is best effort. Your response shows how many tokens came from the cache in usage.prompt_tokens_details.cached_tokens.
Here is what that means for a hypothetical ticket-triage app. Each request carries 4,000 tokens of fixed instructions and tool definitions, 800 tokens of new ticket text and a 300-token answer. The app sends 50,000 requests a day.
Fixed prompt, from cache: 4,000 x $0.05 / 1,000,000 = $0.00020
New ticket text: 800 x $0.20 / 1,000,000 = $0.00016
Answer: 300 x $0.50 / 1,000,000 = $0.00015
Per request: $0.00051
Per day (x 50,000): $25.50If the fixed prompt never comes from the cache, all 4,800 input tokens bill at the full input price. The day then costs $55.50, more than twice as much. If reasoning stays on and writes 1,000 tokens of thinking per request, output grows to 1,300 tokens. The day then costs $50.50, even with every cache hit.
Reasoning also costs time. At 53 tokens per second, the 300-token answer takes about 6 seconds. With 1,000 tokens of thinking first, the reply takes about 25 seconds. These inputs are assumptions, and real speed varies with load and prompt length. The example favours the cache, because it assumes every request after the first one hits it.
How to call it
You call the model with any OpenAI client. Set our base URL, your API key and the model ID. The serverless inference docs list every supported field.
The base URL sends your requests to us. Lyceum is a sovereign European AI inference provider for open-source models. That means we are built and run in Europe, and our serverless models run in Paris and Finland. We don't keep your prompts or outputs, and we never use them for training.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["LYCEUM_API_KEY"],
base_url="https://api.lyceum.technology/openai/v1",
)
response = client.chat.completions.create(
model="qwen/qwen3.8-flash-next",
messages=[
{"role": "system", "content": "Sort each support ticket into billing, bug or account."},
{"role": "user", "content": "I was charged twice for October."},
],
reasoning_effort="none",
max_tokens=300,
)
print(response.choices[0].message.content)The line reasoning_effort="none" switches the thinking off for that request. Our API also accepts chat_template_kwargs with enable_thinking set to false. One of the two is enough. Or you call qwen/qwen3.8-flash-next-instant, the same model with reasoning off, at the same price. The Instant ID helps with coding tools that cap max_tokens and hide the model's thinking.
Leave reasoning on for harder, multi-step requests. Then set max_tokens high enough for the thinking and the answer together. For long outputs, set stream to true, so tokens arrive as they are written.
Where it fits in the Lyceum catalogue
Within our catalogue, Qwen3.8 Flash Next is a model for high-volume, lighter work. Our routing alias lyceum/simple, which picks a model for light requests, sends them to Qwen3.8 Flash Next today.
| Model ID | Input / cached / output per million tokens | Context | Pick it when |
|---|---|---|---|
| qwen/qwen3.8-flash-next | $0.20 / $0.05 / $0.50 | 256K | Requests vary, and some need reasoning |
| qwen/qwen3.8-flash-next-instant | Same prices as Qwen3.8 Flash Next | 256K | Your client cannot switch reasoning off |
| qwen/qwen3.8-27b | $0.40 / $0.10 / $2.40 | 256K | You want a dense model, where every parameter works on each token |
| z-ai/glm-5.3-flash | $0.20 / $0.05 / $0.50 | 1M | Prompts are longer than 256K tokens |
The same triage day on Qwen3.8 27B costs $72.00 instead of $25.50. Most of the gap is output: $2.40 per million tokens there, against $0.50 here. The full list with current prices is on our models page.
If your app sends many short requests, start with Qwen3.8 Flash Next and reasoning off. Then run it on serverless inference against a day of your own traffic, and compare the usage numbers.