qwen3.8-27b: the Qwen 3.8 27B vision-language chat model as a metered API

qwen3.8-27b is this platform's serving alias for Qwen 3.8 27B, the open-weight chat model Alibaba's Qwen team released in mid-August 2026 under the Apache 2.0 license. It is a dense 27 billion-parameter language model with a vision encoder bolted on, a 262,144-token native context window, and a thinking pass that is on by default and can be tuned or switched off per request. This page gives the identity facts with their owners, the honest split between calling it here and running the weights yourself, the exact call contract including the thinking switch, and a benchmark section that separates what the publisher claims from what anyone has independently checked. The route is serving today.

Last verified: 2026-09-11

What it is

Qwen 3.8 is the generation Alibaba announced at the start of August 2026 with a large flagship, and the 27B is its compact open-weight member: the weights went up on Hugging Face in the same month, and the repository has since passed seven million downloads. Per the official model card, it is built on the architectural foundation of Qwen3.5: a causal language model with a vision encoder, 64 layers of a hybrid design that mixes Gated DeltaNet linear attention with gated full attention, and training that included multi-token prediction. In plain words: it is one dense 27B stack (not a mixture of experts), it can look at pictures and video, and it was tuned to carry long multi-step tasks through to the end.

The facts that matter for planning, each with its owner:

Two identity rows need plain words here. Start with the context window: 262,144 tokens is what the model natively supports, and this platform sells exactly that, verified by a live probe recorded in the registry: a 261,120-token request fits, a 270,336-token request is rejected. Beyond the native window, the card describes extending to about one million tokens with YaRN RoPE scaling, which a host has to configure deliberately, and the card itself warns that the static form of that scaling can hurt performance on shorter texts. So when a marketplace advertises a million-token window for this model, that is a scaled configuration, not a different model, and when a speed tier offers less than 262k, that is a cap the host chose. This route serves the native window.

The thinking default deserves more than a table row because it is the first thing that surprises many people about this model. On the card, the default reasoning effort is named xhigh, the top of a three-level ladder with medium and low below it, alongside a preserved-thinking behavior that keeps reasoning blocks from earlier turns so the model does not re-derive context. In practice, confirmed by the hands-on reviews since release: at xhigh the model reasons at enormous length before answering, sometimes for many minutes on a trivial prompt, and the independent recommendation that circulated the week after release was to ignore the default and start low. A fair caveat from the card's own documentation: in multi-turn agent work, a lower effort can produce faster turns but more failed attempts and retries, so total time and total tokens do not always fall. On this platform the control is a single documented parameter, covered in the API usage section below.

On this platform the model answers to qwen3.8-27b on the chat route, alongside the rest of the chat catalog, and the models index reflects the catalog as it stands.

Use cases

The card's own emphasis, and the community record since release, point at the same jobs:

• Agentic coding. This is the model's headline: the publisher's table has it at 73.0 on Terminal Bench 2.1 and 61.7 on SWE-bench Pro, well above the previous 27B generation, with the evaluation harnesses named. Community discussion treats it as the interesting local-capable coding model of the moment.
• Tool-calling agents. The gateway accepts and forwards the standard OpenAI tool shapes (tools, tool_choice, streamed tool_calls fragments), and the card's results on long-horizon task benchmarks are built on exactly that behavior.
• Long-context reading. A 262,144-token native window holds whole repositories, long transcripts, or document sets in one request. This is also where host shopping matters: buyers on some flat-rate plans discover a 128k cap after subscribing, and one discussion thread after release had a user asking plainly whether anyone served the native window. This route does.
• Vision and document work. The card reports 91.1 on OmniDocBench 1.5 for document understanding and strong chart and screenshot results, and the independent hands-on record shows clean bounding-box JSON from photographs. The chat endpoint here forwards the standard OpenAI image content blocks; for a heavy vision workload, run a small test call first and watch the token usage.
• General chat with a switch. It is a strong general model that thinks first, and the switch matters: high for a hard problem, minimal for a rewrite or a classification, which is also the cost lever, because reasoning tokens are output tokens.
• What it is not: it is not the generation's flagship. Qwen 3.8 Max, at 2.4 trillion parameters with about 95 billion active per token, also released open weights, a first for the Max class per the release blog, and it outscores the 27B on every suite both publisher tables report, Terminal Bench 2.1 (86.6 versus 73.0) and GPQA Diamond (92.6 versus 89.2) among them; the 27B's case is efficiency and locality, not beating the flagship. And no 27B dense model is a frontier model; the benchmark section below puts the honest bounds on the claim.

Local or hosted: the honest split

This model has a real local ecosystem, and for some readers the right answer is to download it. The split:

Run it locally when a 16 to 24 GB machine is already on the desk, traffic is steady, you want the quant ecosystem, or the data must not leave a boundary you control. Ollama's library ships it as qwen3.8:27b, a Q4_K_M build of about 17 GB plus the projector, one command after installing Ollama. Unsloth's documentation publishes the full memory ladder, from 7 to 8 GB total at 1-bit through 16 to 19 GB at 4-bit to 56 GB at full precision, with a gigabyte or two extra if you want multi-token-prediction speculative decoding. The floor is real: a 16 GB laptop runs a small quant of this model today.

Call the hosted route when there is no GPU to dedicate, traffic is bursty or occasional, you want the full native window without cap surprises, or you want metering wrapped around the model: the cost of each call returned with the call, a prepaid wallet as the backstop, and per-key revocation. That inventory is what this platform actually does for the model.

Two honest warnings for the comparison. First, speed: measured local decode for this model lands around 20 tokens per second on a single high-end consumer card without speculative decoding, reaching 70 to 80 on a two-card vLLM setup, per published hardware testing after release. A hosted lane is not automatically faster, but a good one is in a different class from a single local card. Second, the break-even: self-hosting on a rented 80 GB GPU beats per-token pricing only at large steady volume, in the hundreds of millions of tokens per month by the published math. Below that, the hosted route is the simpler call. If the model is the point rather than the hardware, start hosted, and go local when the bill says so.

API usage

The route is POST /v1/chat/completions, OpenAI-compatible in shape and authorized by a console-issued Bearer key. The model id is qwen3.8-27b.

Four laws of this route that save debugging time:

1. The thinking knob is reasoning_effort. The model family's native control surface is its own ladder of effort levels (xhigh, medium, low) plus an enable_thinking switch, and different doors expose different pieces of it. At this endpoint you send one documented parameter: reasoning_effort, with the values minimal, low, medium, and high. minimal turns the thinking pass off, which is the fix for the overthinking default; the other values turn it on with increasing depth. The platform translates your value into the model's native switch on the way upstream, and if you send a raw enable_thinking or a nested template field yourself, the answer is a named unknown-parameter error, because the contract accepts only documented parameters. One name in, correct translation out.
2. Reasoning arrives separated. When thinking is on, the model's reasoning text comes back in a reasoning_content field, distinct from the answer in content, and reasoning deltas stream first. Budget for it: reasoning tokens are output tokens and are metered as such.
3. Every response carries your cost. The reply's usage object carries cost: the retail charge for that call at platform rates, worked out from input, cached-input, and output token counts. The prepaid wallet is debited as the call is recorded, and that balance is the spending stop. Spend caps per key are roadmap; revoking a key is instant. Current rates are on the pricing page, and the public /v1/models endpoint lists this model's rates and context window without a key.
4. Deep fresh contexts take time to first byte. A request with a long uncached prefix has to prefill before the first token arrives, and near the full 262,144-token window that takes real seconds. Set client timeouts accordingly, and use a stable prefix across turns where you can, because cached input is priced below fresh input.

curl

curl -X POST "https://api.ironstratum.com/v1/chat/completions" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-27b",
    "messages": [
      {"role": "user", "content": "Summarize this error log in three bullets: connection reset by peer on shard 2"}
    ],
    "reasoning_effort": "minimal",
    "max_tokens": 512
  }'

python

import os
import requests

resp = requests.post(
    "https://api.ironstratum.com/v1/chat/completions",
    headers={"Authorization": "Bearer " + os.environ["KEY"]},
    json={
        "model": "qwen3.8-27b",
        "messages": [
            {"role": "user", "content": "Find the off-by-one bug in this loop and explain the fix."},
        ],
        "reasoning_effort": "high",
        "max_tokens": 4096,
    },
    timeout=300,
)
resp.raise_for_status()

message = resp.json()["choices"][0]["message"]
# The thinking pass, when enabled, lands in reasoning_content;
# the answer itself is in content. Reasoning tokens are metered.
print("reasoning:", (message.get("reasoning_content") or "")[:400])
print("answer:", message["content"])

openai-sdk

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.ironstratum.com/v1",
    api_key=os.environ["KEY"],
)

response = client.chat.completions.create(
    model="qwen3.8-27b",
    messages=[
        {"role": "user", "content": "Look up the shipping rules and draft the refund policy section."},
    ],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "search_docs",
                "description": "Search the internal handbook",
                "parameters": {
                    "type": "object",
                    "properties": {"query": {"type": "string"}},
                    "required": ["query"],
                },
            },
        }
    ],
    tool_choice="auto",
    reasoning_effort="medium",
    max_tokens=4096,
)

message = response.choices[0].message
if message.tool_calls:
    call = message.tool_calls[0]
    print(call.function.name, call.function.arguments)
else:
    print(message.content)

Existing OpenAI-SDK code moves across in two lines: the base URL and the model id.

Benchmarks

Three evidence layers, each dated and labeled.

This platform's own measurements. What this platform has measured and published for this route is the context window, by live probe, recorded in the registry row: 261,120 tokens fit, 270,336 was rejected, tested 2026-08-20, with the failover slot independently confirmed at 261,113. Upstream rates are re-verified on a dated cadence and drift is handled by registry edit, not by surprise. This platform publishes no self-measured throughput for this lane: the serving hardware is not ours to pin, so the honest numbers below are other parties' measurements, labeled as such.

The publisher's card. From the official model card, self-reported, with the harness named for each (Claude Code harness at temperature 1.0 for the coding suites), against the peers the card itself compares:

Read that with its label on: publisher-reported, reference configuration, and the first serious independent benchmarking was still pending at release, a fact the early coverage said out loud. The shape that holds up in hands-on use: a clear step over the previous 27B generation, competitive with models many times its size on agentic coding and office work, and not a frontier model.

Other parties' measurements. For speed, treat these as other parties' numbers: published hardware testing after release measured roughly 20 output tokens per second on a single high-end consumer card without speculative decoding and 70 to 80 on a two-card vLLM setup; one hosting vendor's own model page measured its lane at 140 output tokens per second end to end with 939 milliseconds to the first reasoning token; one hands-on review ran the default quant on a 128 GB laptop and a desktop AI appliance without trouble. For quality, the independent record so far is early and thin: the same review found excellent bounding-box vision behavior and drastic default overthinking, and community verdicts on coding quality split between strong and uneven. If a workload matters, run it on your own tasks before committing, on this route or any other.

Getting started

1. Create your console account. While the platform runs its beta, access is by invite code requested in the console, which also holds the wallet and your keys.
2. Generate an API key. The intended shape is a key per project; each revokes alone, so exposure of one never halts the others, and the loaded wallet balance is today's only spend bound (per-key caps remain roadmap).
3. Check the rate. Rates for input, cached input, and output tokens sit on the pricing page, and usage.cost on each reply tallies spend as the work runs.
4. Make the first call. Grab the curl tab, put your key in KEY, and send a short instruction with reasoning_effort: "minimal" so the reply arrives fast. Growth after that means a longer messages array, nothing else.

For a deep fresh-context first call, set the client timeout past the prefill and expect real seconds before the first token. The other chat lanes are summarized on the chat category page; the models index lists the platform end to end.