A 27-billion-parameter dense model under Apache 2.0 that beats Claude Opus 4.6 Max on SWE-bench Pro and computer use, takes text, images and video, and holds 262K tokens natively. It is the most-liked language model on Hugging Face and the base almost every open-weight fine-tune now starts from. If your constraint is that data cannot leave your network, this is the current answer.
A permissive licence on a model this capable removes the two conversations that usually kill a self-hosted plan: whether you are allowed to use it commercially, and whether you have to tell the vendor what you are doing with it. You do not, and you do not.
SWE-bench Pro comes in at 61.7 against 53.4, and OSWorld computer use at 84.3 against 72.7. It trails on terminal coding (73.0 against 78.2) and slightly on GPQA Diamond (89.2 against 91.3). That is a genuinely mixed result rather than a clean win, and it is remarkable at 27B.
All 27.8 billion parameters activate on every token. Memory sizing is simple and predictable, with none of the routing overhead or expert-placement complexity a sparse model brings. In BF16 that is roughly 56GB of weights, so it fits on a single 80GB accelerator with room for context.
Text, images, and video up to hour scale, from one checkpoint. You do not bolt on a separate vision encoder or run a second model for document work, which removes a whole integration seam from a self-hosted stack.
Search Hugging Face for Qwen3.8-27B and you get quantisations, GGUF conversions, abliterated variants and merges, several with hundreds of thousands of downloads of their own. That ecosystem is a real operational asset: someone has already solved the quantisation you need.
From the Qwen model card, set against the Claude tier Alibaba chose to compare with. We reproduce their comparison set rather than substituting our own, and we flag that a vendor picks the columns that flatter it. The pattern is consistent though: competitive at 27B, ahead on agentic and computer-use work, behind on terminal coding.
| Capability | Qwen3.8-27B | Claude Opus 4.6 Max | Qwen3.6-27B |
|---|---|---|---|
Agentic coding SWE-bench Pro ahead of the closed comparison | 61.7 +8.3 vs Opus 4.6 Max | 53.4 | not published |
Agentic computer use OSWorld the widest margin in the card | 84.3 +11.6 vs Opus 4.6 Max | 72.7 | not published |
Browser use WebArena +16 points on the previous Qwen generation | 64.8 | not published | 48.8 |
Terminal coding Terminus behind, and the gap is real | 73.0 -5.2 vs Opus 4.6 Max | 78.2 | not published |
Graduate science GPQA Diamond within about two points | 89.2 -2.1 vs Opus 4.6 Max | 91.3 | not published |
These are Alibaba's published numbers against a comparison set Alibaba chose, which is how every vendor card works and is worth stating plainly. Two things we would want before recommending a switch: the same evals run on the quantisation you actually intend to deploy, since a 4-bit GGUF is not the model in this table, and a run on customer tasks rather than public benchmarks. Open weights make both of those cheap to do, which is itself an argument for this family.
What changes for a team weighing this against an API. Two comparisons decide it: against the frontier APIs on capability and cost, and against the sparse Qwen tier above it on hardware.
| Dimension | vs a frontier API | vs Qwen3.8-Flash-Next |
|---|---|---|
Where the data goes | This is usually the reason the conversation starts. Weights on your hardware means no prompt or document leaves your boundary, no data-retention negotiation, and no vendor-side classifier deciding your request was disallowed. For regulated work that is not a cost argument, it is a feasibility one. | Both are open weights, so neither has this problem. The choice between them is about hardware and licence, not about privacy. |
Cost shape | You trade per-token billing for fixed capacity. At low volume an API is cheaper, and Qwen's own hosted tier at $0.14 / $0.42 undercuts most self-hosting once you price the GPU hours honestly. Self-hosting wins on sustained high volume, on privacy, and when you need the latency floor of local inference. | Flash-Next activates 6B per token against this model's 27.8B, so it is cheaper per token to run, but it needs 180B of weights resident. Dense 27B is the cheaper machine, sparse 180B is the cheaper token. |
Hardware sizing | Roughly 56GB of BF16 weights, so one 80GB accelerator with room for context, or a quantised build on considerably less. Predictable because it is dense: no expert routing, no placement strategy, no surprise memory spikes on an unlucky batch. | Flash-Next needs the full 180B resident even though only 6B activate. That is a multi-GPU deployment. If you have one card, this is your model and the decision is already made. |
Licence risk | Apache 2.0 is about as settled as licensing gets. No field-of-use restriction, no user threshold, no acceptable-use policy that can be revised under you after you have shipped. | Flash-Next ships under qwen-community-1.0, not Apache 2.0. Read it before you build on it. On a client project we default to the Apache-licensed model unless the capability gap is proven and the licence has been through legal. |
We treat open weights as a deployment option rather than an ideology. The model sits behind the same abstraction as the hosted APIs, so a workload can move from Qwen3.8-Flash to a self-hosted 27B and back as the privacy, latency and volume picture changes, with the eval suite deciding rather than the licence.
The layer pattern is 16 repeats of three Gated DeltaNet blocks followed by one Gated Attention block, each with its own FFN. The linear-attention blocks carry most of the depth cheaply and the full-attention blocks do the long-range work, which is how a 27B dense model reaches 262K context without the memory curve getting silly.
Native rather than extrapolated is the important word. The card also gives explicit output guidance: up to 262,144 reasoning tokens and 131,072 for the final response, which is unusually concrete and worth respecting in your serving config.
Reasoning is enabled unless you turn it off, with depth tuned through reasoning_effort. That is the right default for an agent and the wrong one for a classification endpoint, so set it per call site rather than globally.
Hour-scale video with the right configuration, from the same weights that do text and images. Anyone who has run a separate video pipeline alongside a language model will recognise how much integration that removes.
Both ship cookbooks for this checkpoint. That matters more than it sounds: most open-weight pain is serving pain, and a maintained recipe is the difference between a day and a fortnight.
Not a community licence, not a bespoke agreement, not a user-count threshold. The most capable model at this size with a licence your legal team already knows.
The limits, the endpoints, and the lines that decide whether this model fits your transport and your budget. Kept here so nobody has to reconstruct it from three vendor pages.
| Hugging Face repo | Qwen/Qwen3.8-27B |
|---|---|
| Licence | Apache 2.0. Commercial use with no separate agreement |
| Parameters | 27,781,427,952 BF16. Dense, so all 27.8B activate on every token |
| Architecture | Qwen3_5ForConditionalGeneration. 16 x (3 x (Gated DeltaNet to FFN) then 1 x (Gated Attention to FFN)) |
| Layers | 64, hidden dimension 5,120 |
| Context window | 262,144 tokens native, extensible to 1,000,000 |
| Recommended output | Up to 262,144 reasoning tokens, 131,072 for the final response |
| Input | Text, images, and video up to hour scale with the right configuration |
| Thinking | On by default, disableable per request, depth tuned with reasoning_effort |
| Serving | SGLang and vLLM both ship official recipes. TokenSpeed also supported |
| Deployment targets | Azure and SageMaker one-click, plus any Transformers-compatible runtime |
| Hugging Face signal | 6.4M downloads and 14,239 likes, second only to FLUX.1-dev overall |
| Hosted equivalents | Qwen3.8-Max at $2 / $6 and Qwen3.8-Flash at $0.14 / $0.42 on Alibaba Cloud Model Studio |
How we take an open-weight model from interesting to load-bearing. Step two is where most pilots quietly fail.
Privacy, latency floor, or sustained volume. If none of those apply, Qwen3.8-Flash at $0.14 / $0.42 through the hosted API is cheaper and simpler than anything you will run yourself, and the honest recommendation is to stay there.
The published benchmarks are BF16. Almost nobody deploys BF16. A 4-bit GGUF is a different model with different failure modes, and the gap shows up on exactly the long-context and tool-calling work you bought the model for. Evaluate the artefact, not the announcement.
56GB of weights plus KV cache for your actual context length and batch size. Long context is where deployments run out of memory in production having been fine in testing, so size against p95 context and concurrency.
SGLang or vLLM, using the cookbook for this checkpoint. Drifting off the recipe is how you end up debugging a rotary embedding at midnight. Pin the runtime version alongside the model.
Thinking is on by default. That is right for an agent loop and wasteful for classification or extraction. Turn it off where judgement is not needed and tune reasoning_effort where it is.
Behind one abstraction, the same workload should be able to run on the self-hosted weights or the hosted API. That gives you a real answer when a GPU node fails at 2am, and it keeps the comparison honest as both sides change.
The weights are free. Inference is not. These are the hosted Qwen tiers you would be measuring self-hosting against, at the Singapore endpoint.
| Qwen3.8-27B weights | Free | Apache 2.0. Your cost is the hardware and the engineering. |
|---|---|---|
| Qwen3.8-Max | $2 / $6 | Hosted flagship, closed weights. Cached input $0.25 per million. |
| Qwen3.8-Flash | $0.14 / $0.42 | Flat across the full 1M context, no long-context surcharge. |
| Regional difference | 60 to 70% less | The Beijing endpoint against Singapore. A data-residency decision before it is a pricing one. |
| Free tier | 1M tokens | Per eligible model for new accounts, 90 days from Model Studio activation. |
| For comparison | $10 / $50 | GPT-6 Astra and Claude Fable 5.1. Qwen3.8-Flash is roughly seventy times cheaper on input. |
The number that surprises people is not the weights being free, it is Qwen3.8-Flash at $0.14 input. That is cheap enough to change which steps are worth doing with a model at all, and cheap enough that self-hosting has to justify itself on privacy or latency rather than on cost. We price both paths against real volume before recommending either, and on more than one engagement the honest answer has been to use the hosted tier and spend the saved effort on evals.
There is no vendor classifier between your prompt and the model, no refusal path, and no abuse monitoring you inherit for free. Everything a hosted API does on your behalf becomes your responsibility: input filtering, output review, rate limiting, and an audit trail. Teams consistently underestimate this, and it is the main reason a self-hosted pilot stalls before production.
The abliterated and uncensored variants near the top of the Hugging Face trending list are the same architecture with the safety training removed. They are useful for research and a genuine liability in a product. Pin exact repo revisions, verify checksums, and treat a model download the way you treat any other third-party dependency.
The licence settles copyright and patent grant. It says nothing about whether your use is lawful under the EU AI Act, sectoral regulation, or your own customer contracts. Provenance, disclosure and evaluation obligations attach to what you build, not to what you downloaded.
Regulated work, on-premise constraints, and anything where a data-processing agreement would take longer than the build. At 27B with these numbers, the capability cost of staying inside the boundary is now small enough that the conversation is about hardware rather than about compromise.
Apache 2.0 at this capability is rarer than the scores. It removes a legal review, a vendor negotiation, and a category of risk that outlives the model. We weight that heavily on client work, and it is why we default to the 27B over the stronger community-licensed Flash-Next.
Every published number here is BF16 and almost nobody serves BF16. We evaluate the exact artefact going to production, and we have seen 4-bit builds lose materially on long-context tool use while looking fine on short prompts. That gap is invisible unless you look for it.
Qwen3.8-Flash at $0.14 per million input is hard to beat with your own GPUs once you count the hours, the on-call, and the engineer maintaining the serving stack. We price both honestly, and self-hosting has to win on privacy, latency or volume rather than on a spreadsheet that omits salary.
Qwen is the most-downloaded and most-forked open family on Hugging Face and it appears in almost no frontier-vendor benchmark table. That is a positioning choice, not a capability judgement, and it is worth remembering when you read any launch post.
Every model we integrate runs through the same operating system. Three pillars, sixteen layers, one Compound Growth Loop. The methodology that keeps AI work from rotting after the first ship.
Read the K-FrameworkDirect API integration with the model. No LangChain, no orchestration vendor, no agent framework built on quicksand. Typed contracts, the same way we wire up Postgres.
An eval suite built from your real tasks gates every prompt and model change. Quality is measured before it ships, not vibed in a demo.
Governance, audit, and oversight wired in from day one. Who called what, with which prompt version, at what cost. Your auditors get answers, not screenshots.
A model in production without observability is roulette. We instrument every integration so engineering and finance can see the same numbers, and so a regression at 3am surfaces before a customer opens a ticket.
Tokens in, tokens out, dollars spent. Sliced by feature, tenant, and route. Budgets enforced where it matters.
Real distributions, not averages. We know which routes are slow, and why.
The same eval suite that gates a release runs continuously in production. A regression on real traffic surfaces fast.
PII scrubbed at the proxy, shipped to your SIEM. Retention controls match your compliance window.
Dashboards your team owns, not ours. At handoff you get the queries, the alerts, and the runbook. We are not in the path to read your metrics.
