What's new

One small purple-topped block standing beside a much larger outlined block, suggesting a compact model next to a large one.

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 27BQwen3.6 27B
SWE-bench Pro (fixing real GitHub issues)61.753.5
Terminal Bench 2.1 (agent tasks in a command line)73.063.4
CoWorkBench (long office tasks, Qwen's own test)70.761.0
IFBench (following detailed instructions)79.569.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.

A row of 64 thin columns, one per layer of Qwen3.8 27B, in 16 repeats of three outlined columns and one purple column. The 16 purple columns are full attention layers, which store a record of every earlier token that grows with the prompt. The 48 outlined columns are Gated DeltaNet layers, which keep a summary of fixed size.
Qwen's model card lists 16 full attention layers among 64, so only a quarter of Qwen3.8 27B's layers keep a record that grows with the prompt.

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.

SpecQwen3.8 27B on our API
Model IDqwen/qwen3.8-27b
Parameters27 billion, dense
InputText and images
Context window256K tokens
Longest answer131,072 tokens per request
Time limit300 seconds per request
ReasoningOn by default
LicenceApache 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.01032

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

Stacked horizontal bars for one calculated agent turn at list prices of 23 October 2026, split into input and output cost. Qwen3.8 27B: $0.00432 with a cache hit and $0.01032 with a miss, where the miss's input cost is highlighted. Qwen3.8 Flash Next: $0.00160 with a hit and $0.00460 with a miss.
In this calculated example at our 23 October 2026 list prices, input is over 80% of a Qwen3.8 27B turn that misses the cache.

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.

ModelInput / cached / output per 1M tokensLicenceFirst token / output speed
Qwen3.8 27B$0.40 / $0.10 / $2.40Apache 2.0302 ms / 45 tokens per second
Qwen3.8 27B Instantsame as Qwen3.8 27BApache 2.0not listed
Qwen3.8 Flash Next$0.20 / $0.05 / $0.50Qwen Community License 1.0596 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.

Sources

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