What's new
Qwen3.8 27B costs more per token than its sibling Qwen3.8 Flash Next. Qwen's own scores for the two are close. So the case for 27B rests on what only it gives you here. It has open Apache 2.0 weights, we offer fine-tuning for it (early access), and you can host it on one GPU.
Should you build on Qwen3.8 27B or on the cheaper Flash Next, and what will one request cost? Teams ask this when a compact model has to carry an agent or a document pipeline at volume.
Qwen released Qwen3.8 27B on 14 August 2026 under the Apache 2.0 licence, which permits commercial use. It is the compact member of the Qwen3.8 family. Qwen reports clear gains over its predecessor, Qwen3.6 27B, in coding and agent work.
| Benchmark (what it tests) | Qwen3.8 27B | Qwen3.6 27B |
|---|---|---|
| SWE-bench Pro (fixing real GitHub issues) | 61.7 | 53.5 |
| Terminal Bench 2.1 (agent tasks in a command line) | 73.0 | 63.4 |
| CoWorkBench (long office tasks, Qwen's own test) | 70.7 | 61.0 |
| IFBench (following detailed instructions) | 79.5 | 69.1 |
Qwen reports the scores above on its model card, from its own test setups. We did not run them. Treat them as a guide to the direction of change, then test your own prompts.
Lyceum is a sovereign European AI inference provider for open-source models: a European company running open models on GPUs in European data centres. Our serverless models run in Paris and Finland, and the Qwen3.8 27B model page lists its processing region as EU-hosted. We don't keep your prompts or outputs, and we never use them for training.
Specs and context window
Qwen3.8 27B is a dense model with 27 billion parameters. Dense means every parameter works on every token. A mixture of experts (MoE) model, by contrast, runs only part of itself for each token.
Its layers mix two kinds of attention, the step where the model looks back over earlier text. Qwen built 16 of its 64 layers with full attention, which compares each token with every earlier one. The other 48 use Gated DeltaNet, a linear attention method published in December 2024. Those 48 layers keep a running summary of the earlier text, and that summary stays the same size however long the prompt gets. Full attention layers instead store a record of every earlier token, which grows with the prompt. So with only 16 such layers, long prompts need less GPU memory.
The context window is the amount of text one request can hold, prompt and answer together. On our API it is 256K tokens, which is 262,144. Qwen's model card gives the same native length.
| Spec | Qwen3.8 27B on our API |
|---|---|
| Model ID | qwen/qwen3.8-27b |
| Parameters | 27 billion, dense |
| Input | Text and images |
| Context window | 256K tokens |
| Longest answer | 131,072 tokens per request |
| Time limit | 300 seconds per request |
| Reasoning | On by default |
| Licence | Apache 2.0 |
Our status checks measured a median time to first token (the wait before the answer starts) of 302 ms. That median covers the 7 days to 23 October 2026. After the first token, the model wrote 45 tokens per second. Both figures come from short requests, and reasoning tokens count towards them. So the first token can be a reasoning token, and the visible answer may start later. The status page shows the current figures.
Pricing
You pay per token, with no base fee. On 23 October 2026, our prices were $0.40 per million input tokens, $0.10 for cached input and $2.40 for output.
Cached input is the part of a prompt whose start exactly matches a recent request. We reuse the work already done on it and bill it at the lower rate. This reuse is called prompt caching, and it happens automatically. A cache hit is best effort: we do not guarantee it, so the full rate can apply on any request.
Take a hypothetical agent turn. Every turn it sends the same 20,000-token start: the system prompt, the tool definitions and the history so far. It adds 1,000 new tokens and gets back 800 tokens, reasoning included.
Cache hit: 20,000 x $0.10/1M + 1,000 x $0.40/1M + 800 x $2.40/1M
= $0.0020 + $0.0004 + $0.00192 = $0.00432
Cache miss: 21,000 x $0.40/1M + 800 x $2.40/1M
= $0.0084 + $0.00192 = $0.01032A miss costs about 2.4 times as much as a hit. At 1,000 turns a day for 30 days, the bill is $129.60 with hits and $309.60 with misses. On a hit, the cached start and the output cost about the same, so long reasoning adds up fast.
The example favours caching in one way. It assumes the start never grows, while a real agent's history grows every turn. It also leaves out time: 800 output tokens at 45 tokens per second take about 18 seconds.
How to call it
Point any OpenAI SDK at our base URL and set the model ID. The Python example below also prints how many prompt tokens came from the cache.
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-27b",
messages=[
{"role": "system", "content": "Extract the invoice fields as JSON."},
{"role": "user", "content": "<invoice text>"},
],
max_tokens=8000,
)
print(response.choices[0].message.content)
details = getattr(response.usage, "prompt_tokens_details", None)
print("cached tokens:", getattr(details, "cached_tokens", None) or 0)The cached-token field is missing when nothing came from the cache. The last line reads it with a fallback for that reason.
Reasoning means the model writes out its working before the answer. To switch it off, send reasoning_effort set to "none". You can also call qwen/qwen3.8-27b-instant, the same model at the same price without a reasoning phase.
response = client.chat.completions.create(
model="qwen/qwen3.8-27b",
messages=[{"role": "user", "content": "Summarise this ticket in one line."}],
extra_body={"reasoning_effort": "none"},
)Three more behaviours from the model page:
- Images: send them as image_url content parts, from a public URL or a base64 data URL.
- Tools: pass tools in the OpenAI format. The model honours tool_choice set to "required" and a named function.
- Long answers: set stream to true, so tokens arrive while the model writes them.
The serverless inference docs list every request field and limit.
Where it fits in the Lyceum catalogue
Qwen3.8 27B sits next to two close relatives on our models page. The table shows them as listed on 23 October 2026. Speeds are 7-day medians from our status checks.
| Model | Input / cached / output per 1M tokens | Licence | First token / output speed |
|---|---|---|---|
| Qwen3.8 27B | $0.40 / $0.10 / $2.40 | Apache 2.0 | 302 ms / 45 tokens per second |
| Qwen3.8 27B Instant | same as Qwen3.8 27B | Apache 2.0 | not listed |
| Qwen3.8 Flash Next | $0.20 / $0.05 / $0.50 | Qwen Community License 1.0 | 596 ms / 53 tokens per second |
Qwen3.8 Flash Next is a mixture of experts model with 125 billion parameters in total. It costs less on every line of the bill. Our worked turn costs $0.00160 on Flash Next with a hit, against $0.00432 on 27B. Qwen also reports a slightly higher SWE-bench Pro score for Flash Next, 62.5 against 61.7.
Qwen3.8 27B wins on three other points. Its Apache 2.0 licence is a standard open licence without extra conditions. The Qwen Community License of Flash Next adds conditions for very large products and for companies that sell model access as a service. We offer fine-tuning for it in early access, as for GLM-5.3 Flash. Its 27 billion parameters are also small enough to host yourself later. The recipe from vLLM, an open-source engine for serving models, says it fits one NVIDIA Blackwell GPU in every precision. Precision is the number format of the weights, such as BF16 or FP8. Blackwell is the GPU generation of the B200 and B300.
We recommend running your own test prompts on Flash Next first. Move to Qwen3.8 27B when you need fine-tuning, the Apache 2.0 licence, or a model you may later run on your own GPU. Create an API key and run the example above on serverless inference.