The 27B Class: August's Small Open-Weight Models, Compared

What you need to know

• Three models, one shelf. Qwen3.8-27B, NVIDIA's Nemotron 3.5 Lightning and Meta's Muse Glimmer 30B all landed within three weeks in August 2026, all in the size class that fits a single 24–32GB machine.
• Same size, almost nothing else in common. Dense versus sparse, 131K context versus 1M, 256K of context versus 131K on two models that both ship a vision encoder. The parameter count is the least informative thing about them.
• Only one is built for a 24GB card without compromise. Muse Glimmer's short context and small KV cache are a design choice, not a limitation to work around.
• Every headline benchmark is vendor-reported. Three vendors, three harnesses, one model with no published scores at all — and one figure that is not a standard benchmark.
• The choice is a workload question, not a quality question. Long documents rule out one, unusual architecture is the risk on another, dense memory pressure is the cost of the third.

August 2026 has been an unusually generous month for open weights: Meta, Alibaba's Qwen team and NVIDIA all shipped, with more than eleven model releases in the first twenty days alone. Coverage has treated each as its own event — including ours. But builders do not choose models one release at a time. They choose once, per workload, from whatever is on the shelf that week, and the shelf now holds three models close enough in size to be genuinely confusable. They are not variations on a theme. They are three answers to the question of what a small model is for.

Same class, three incompatible bets

The reason this class matters is the hardware envelope. All three sit in the 24–32GB machine class — a single Mac, or a single GPU in a workstation somebody already owns. Above that line you provision servers; below it you run something on the desk.

Qwen3.8-27B: the dense generalist

Qwen3.8-27B is a dense model of 27.3 billion parameters — not a mixture-of-experts, not a hybrid, every parameter participating in every token. Its model card lists a 256K native context window (262,144 tokens) and a vision projector built into the model rather than bolted alongside it. It ships under Apache 2.0.

It also has the best raw coding numbers of the three, at least as its own vendor measures them. We covered the release and its terms when Alibaba shipped it alongside the 2.4T Qwen3.8-Max flagship and its revenue-linked licence, so we will not re-argue that here. The 27B is Apache 2.0 and clean.

What is interesting in this company is architectural: density is a deliberate choice, and the expensive one. A dense 27.3B is the heaviest of the three to hold in memory relative to what it computes, with no sparsity to exploit. That buys consistency — no router to mispredict, no expert-selection variance between similar prompts — and costs you the headroom the other two spend elsewhere.

Nemotron 3.5 Lightning: the throughput bet

Nemotron 3.5 Lightning is a mixture-of-experts model designated 30B-A3B: 30 billion total parameters, 3 billion active per token. It interleaves Mamba-2 processing with selected attention layers and sparse experts, reads up to a million tokens of context, and ships in both BF16 and NVFP4 checkpoints. We went through the architecture in depth in our launch coverage.

The bet is throughput and reach. Three billion active parameters means the arithmetic per forward pass is a fraction of what a dense 27B demands, and the Mamba-2 hybrid is what makes a million-token window tractable at this size — state-space layers carry a fixed-size recurrent state rather than comparing every token against every other one.

The cost is architectural unfamiliarity. Sparse expert routing and state-space layers are each areas where inference runtimes differ in maturity, and a stack that handles one may handle the other badly or not at all. On licence: NVIDIA's terms for this checkpoint should be checked directly on the model card, not assumed from the other two releases or from any summary, including ours.

Muse Glimmer 30B: the always-on bet

Muse Glimmer is 30 billion parameters under Apache 2.0, built for always-on local agents and reported to run on an RTX Pro 6000. Its native maximum context is 131,072 tokens — the shortest of the three by a wide margin, with a correspondingly small KV cache. We covered it in our launch piece on Meta putting a 30B agent model on a laptop, where the context figure was the conspicuous gap; the model card states a context length of 131,072, and the model's own configuration file carries the same figure.

The short context reads like a weakness until you notice what it is for. A model living resident on a laptop all day, waking to handle agent steps, competes for memory with everything else the machine is doing. A small KV cache is the right trade in that setting and the wrong one if your workload is a 300-page contract. Meta has not published benchmark scores for Muse Glimmer — a genuine gap, not an omission on our part.

Side by side

Every benchmark figure below is vendor-reported and self-benchmarked. The figures sit in one table for convenience and are not comparable with each other — see the next section for why.

Two cells deserve their own sentence. Qwen's own generation-over-generation comparison against Qwen3.6 27B reports DeepSWE moving from 13.3 to 42.2 and "QwenSWEBench" from 49.3 to 79.0 — but QwenSWEBench is a vendor-defined benchmark, Qwen's own construction rather than an industry-standard evaluation, and should never be quoted alongside standard benchmark names as though it belonged to the same family. Note also that the three licences are not equivalent in kind: two are Apache 2.0, while NVIDIA's OpenMDW-1.1 additionally covers published training data and recipes, which is a materially stronger provenance position than open weights alone.

Why the model cards cannot settle this

The temptation with three releases this close together is to line up the headline numbers and pick the biggest. That fails structurally, not by degrees. A benchmark score measures a model under a harness, and the harness decides how many attempts the model gets, what scaffolding surrounds it and what counts as a pass. Two vendors running the same named benchmark on the same model can produce materially different numbers without either doing anything dishonest. Two vendors running differently named benchmarks on different models produce numbers with no defined relationship at all.

Then there is the selection problem: a vendor publishes the evaluations where its model looks good. Not fraud, marketing — and it is why a table of self-reported bests across three labs tells you more about three marketing departments than about three models.

Independent third-party comparisons are starting to appear — community efforts running all three on the same problems, on the same card, at the same quantisation. That is the right shape of evidence and should be weighted well above anything in a model card. We do not have results we can stand behind yet, so we will not quote any.

How to actually choose

Start from the workload, not the model. Three questions decide this, and each eliminates one candidate outright.

Does your work involve long documents?

If it does, Muse Glimmer is out. A 131,072-token maximum is generous for an agent loop and inadequate for work where you feed the model a full contract, a codebase or a year of transcripts. That is the model doing what it was designed for, but it is a hard boundary: no amount of chunking makes a short-context model behave like a long-context one on tasks that need the whole document in view. If long inputs are the job, Nemotron's million-token window is the reason to look at it, and Qwen's 256K covers a great deal of practical work.

Can your serving stack handle an unusual architecture?

If it cannot, Nemotron 3.5 Lightning is the risk. Mamba-2 interleaved with selected attention layers and sparse experts is a lot of novelty in one checkpoint, and runtimes support these features on their own schedules. Check your exact stack version against the model card first, and confirm which checkpoint format you intend to serve — BF16 and NVFP4 are both published and are not interchangeable operationally. A model that loads in a notebook but will not serve on your production runtime has cost you a week.

How much memory headroom do you actually have?

This is where the dense model costs you. Qwen3.8-27B holds 27.3 billion live parameters and offers no sparsity to trade away when the card gets tight. Nemotron's 3B active parameters buy compute efficiency but not memory relief — all 30 billion still have to be resident, because the router's choice changes token by token. Muse Glimmer's small KV cache is the group's one genuine memory advantage, and the reason it is the only one of the three that fits comfortably rather than merely fits.

Answer those three honestly and the choice usually makes itself. Long documents plus a mature serving stack points at Nemotron; mixed coding and visual work on a machine with headroom points at Qwen; a resident, responsive agent on hardware you own points at Glimmer. If you are choosing for a coding assistant specifically, our guide to picking a self-hosted coding model covers the evaluation method, and if you intend to specialise whichever you pick, serving many LoRA adapters from one GPU is how you avoid buying a second card.

What to test this week, in Bengaluru or Manchester

The useful next step is not a migration but an afternoon of measurement on hardware you already have — the same afternoon whether your desk is in Pune, Hyderabad, Bristol or London. Pull whichever two survive your three questions and run them against the same twenty tasks from your own traffic, at the same quantisation, on the same card. Record what vendor tables never contain: memory at your real context length rather than a short prompt, latency at your real concurrency, and how each degrades as the input grows. For an always-on candidate, measure idle residency too — a model holding memory all day competes with everything else on the machine, and that cost appears in no benchmark.

Then run the sum in your own currency, because this is where the two markets diverge in a way that catches teams out. A 24GB card costs roughly the same in Bengaluru as in Manchester. Almost nothing downstream of it does: electricity tariffs differ, cooling differs, and the price and availability of local GPU rental differ substantially, so the cloud alternative you are measuring against is not the same alternative either. A break-even calculation that works in one office can fail in the other on inputs that have nothing to do with the model.

The bottom line

The 27B class is not a race with three entrants. It is three labs answering different questions and arriving at a similar size by coincidence of what fits on a desk. Qwen built a dense generalist with a long context and made you pay in memory. NVIDIA built a sparse hybrid that reads a million tokens and made you pay in serving-stack risk. Meta built something to sit on a laptop all day and made you pay in context length.

None of those is a mistake. All of them are wrong for somebody. The mistake is choosing on the parameter count, or on a table three vendors measured three different ways — and the fix is a harness of your own, twenty tasks long, run on your own card this week.