A row of small outlined blocks with one purple-topped block among them, suggesting many light requests served by one compact model.

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 NextQwen3.8 27B
SWE-bench Pro (fixing real issues in code repositories)62.561.7
LiveCodeBench v6 (competitive programming problems)91.990.3
CoWorkBench (Qwen's own test of long office tasks)73.970.7
IFBench (following detailed instructions)81.379.5
GPQA Diamond (graduate-level science questions)91.789.2
AndroidWorld (completing tasks on an Android phone screen)84.581.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.

SpecQwen3.8 Flash Next on our API
Model IDqwen/qwen3.8-flash-next
InputText and images
OutputText
Context window256K tokens
Longest answer per request131,072 tokens
Time limit per request300 seconds
ReasoningOn by default
Tool callingSupported
Parameters125B total, 6B active
LicenceQwen Community License 1.0
Processing regionEU-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 typePrice 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.50

If 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.

Stacked horizontal bars for the daily cost of a hypothetical ticket-triage app sending 50,000 requests a day. Qwen3.8 Flash Next with a cache hit and reasoning off costs $25.50, highlighted. With cache misses it costs $55.50, with 1,000 reasoning tokens per request $50.50, and Qwen3.8 27B costs $72.00. Each bar is split into cached input, new input and output.
In this calculated triage example at our 23 October 2026 prices, a cached prompt start with reasoning off costs $25.50 a day, and a cache miss or reasoning on roughly doubles it.

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

Two horizontal timelines for one hypothetical ticket-triage request on Qwen3.8 Flash Next at 53 tokens per second after a 0.6 second first-token wait. With reasoning off, the 300-token answer is complete after about 6.3 seconds, highlighted. With reasoning on, 1,000 tokens of thinking come first and the answer is complete after about 25.1 seconds.
At the speed our status checks measured up to 23 October 2026, a 300-token reply takes about 6 seconds with reasoning off and about 25 seconds with 1,000 tokens of thinking first.

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 IDInput / cached / output per million tokensContextPick it when
qwen/qwen3.8-flash-next$0.20 / $0.05 / $0.50256KRequests vary, and some need reasoning
qwen/qwen3.8-flash-next-instantSame prices as Qwen3.8 Flash Next256KYour client cannot switch reasoning off
qwen/qwen3.8-27b$0.40 / $0.10 / $2.40256KYou want a dense model, where every parameter works on each token
z-ai/glm-5.3-flash$0.20 / $0.05 / $0.501MPrompts 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.

FAQ

Sources

  1. huggingface.co
  2. recipes.vllm.ai
  3. arxiv.org