Qwen 3.8 27B vs Muse Glimmer vs Qwen 3.6 27B: Best local models comparison

A 27B model now fits on a single consumer GPU, so teams that needed a hosted API for privacy, cost, or latency can keep the model on their own hardware. The hard part is no longer fitting the weights. It is deciding which of three strong local options to standardize on, because each one is marketed as the efficient or specialized choice and the public comparisons rarely test the workloads that matter in production. Qwen 3.8 27B, Muse Glimmer, and Qwen 3.6 27B all run from a 24 GB card, but they are not equals: Qwen 3.8 27B leads on every capability metric.

Qwen 3.8 27B is the best local model in the 27B class, and it is not close. It beats Muse Glimmer and Qwen 3.6 27B on production coding, agentic terminal work, long-context retrieval, multimodal understanding, decode throughput, and context length. Muse Glimmer is the closest challenger and the better pick only when a 24 GB card cannot spare the memory for 3.8's vision tower and long context. Qwen 3.6 27B is the previous generation, still serviceable for light text work but behind on every metric. Standardize on Qwen 3.8 27B unless you are hard memory-constrained, then confirm with an evaluation on your own tasks.

What "best local" actually measures

Local deployment changes which numbers decide the purchase. On a hosted API you compare intelligence and price per token. On your own GPU you compare how much VRAM the model leaves for context and concurrency, how many tokens per second it returns, and whether it can take images or hold a long session. A model that fits the card but trails on quality forces a second model for harder work, which doubles your serving and evaluation burden.

Five criteria decide the comparison:

1. Memory footprint at a usable quantization, including the cache and runtime overhead.
2. Decode throughput on consumer hardware, because local agents chain many tool calls.
3. Quality on the workload you actually run, usually coding, agentic terminal work, or retrieval.
4. Context length and long-context recall.
5. Multimodal input and structured tool use, when your product needs them.

Each model below is described at the quantization a team would actually deploy, not at a marketing BF16 number.

Qwen 3.8 27B: the clear winner on every metric

Qwen3.8-27B is a 27B vision-language model with a 262,144-token native context, image and video input, thinking controls, and support for Transformers, vLLM, and SGLang, as documented in its model card. Its raw BF16 checkpoint is about 54.7 GB, the official FP8 checkpoint is about 28.75 GiB, and a 4-bit build lands near 16 to 18 GB. Those figures cover weights only; the context cache, vision tower, and runtime buffers add to the total, which is why a 24 GB card needs a Q4 file and a bounded context.

It leads the group on every capability metric. On a 128K retrieval probe it recovers scattered facts at about 95 percent, against roughly 68 to 71 percent for the two text-only models, which matters directly for agents that hold a large schema, a long transcript, or a document set in context. On applied work it scores near 45 percent on production coding, about 60 percent on agentic terminal tasks, and around 74 percent on multimodal understanding, each figure ahead of both challengers. At FP8 on an RTX-class GPU it returns roughly 218 tokens per second with a time to first token near 0.6 seconds, so it also wins the throughput axis that local agents depend on when they chain hundreds of tool calls.

The 262K native context is a capacity figure; running at full length costs memory, but having the headroom changes what you can build without chunking. It is the only model here that can read an image or a screenshot as part of a workflow, which makes it the default for any product surface that mixes text and documents with vision. Muse Glimmer and Qwen 3.6 27B cannot, so they drop out of any multimodal or long-session task by construction.

The only cost is memory headroom. Its KV cache at length is the largest of the three and its vision tower adds fixed overhead even on text tasks, so a 24 GB card needs a Q4 file and a capped context. That is a configuration choice, not a quality trade.

Muse Glimmer: the closest challenger, still behind

Muse Glimmer is a 27B-class dense text model built by Muse AI with a custom speculated decode path, shipped in GGUF, MLX, and FP8 forms for llama.cpp, vLLM, and SGLang. The published artifact sizes are close to Qwen's: about 52 GB BF16, about 26 GiB FP8, and roughly 14.8 GB at Q4. It is text-only, with a 128K native context and no vision encoder.

It is the nearest rival on the coding and terminal rows, scoring near 41 percent on production coding and about 58 percent on agentic terminal work, just behind Qwen 3.8 27B on both and clearly ahead of Qwen 3.6 27B. Its decode at FP8 on an RTX 5090 reaches around 205 tokens per second, also behind 3.8's 218, and its time to first token sits near 0.7 seconds. On 128K retrieval it lands near 71 percent, a 24-point gap below 3.8 and the same order as the older 3.6.

Where it loses is scope and context. Without vision, Glimmer cannot take an image or a PDF rendered as an image, so any multimodal workflow needs a different model or a preprocessing step. Its 128K window is half of Qwen 3.8 27B's and its recall at length is weaker. It matters only for teams that cannot fit 3.8's context and vision overhead on a 24 GB card; there it is the lighter fallback, but it does not beat 3.8 on any capability metric.

Qwen 3.6 27B: the previous-generation fallback

Qwen3.6-27B is the prior generation in the Qwen local line, a 27B dense text model with a 128K context and basic thinking controls, released about four months before 3.8. Its weight sizes track the family: roughly 54 GB BF16, about 27 GiB FP8, and near 15.2 GB at Q4. It has no vision tower, so its memory budget is the cleanest of the three once you drop the multimodal overhead.

It trails both newer models on every applied row. Measurements put it near 34 percent on production coding, about 47 percent on agentic terminal tasks, and around 68 percent on 128K retrieval. Its decode is faster than nothing here at roughly 105 tokens per second on an RTX 5090 at FP8, but less than half of Qwen 3.8 27B's rate and well behind Glimmer's.

The reason it still exists in the comparison is cost and simplicity. It is the smallest artifact, the easiest to fit on a 16 to 24 GB card with room for context, and the cheapest to serve when your tasks are text summarization, classification, or short tool calls that do not need frontier quality. Teams standardizing on a single cheap local model for internal text tooling, where agent quality can be modest, get the lowest operating friction from 3.6. For any customer-facing or agentic work, 3.8 is the better choice on every metric that affects the result.

Side-by-side on the workloads that matter

The numbers below come from the respective model cards and from independent measurement on the same hardware class where published. Treat them as a starting comparison, not as a substitute for your own eval.

Workload	Qwen 3.8 27B	Muse Glimmer	Qwen 3.6 27B
Production coding (%)	44.8	41.2	34.5
Agentic terminal (%)	60.2	58.0	47.1
128K retrieval recall (%)	95.0	71.0	68.0
Multimodal understanding (%)	74.0	n/a	n/a
Decode (tok/s, RTX 5090 FP8)	218	205	105
Time to first token (s)	0.6	0.7	1.1
Native context	262K	128K	128K
Vision input	yes	no	no

Qwen 3.8 27B tops every row where the three can be compared, and it is the only model with vision and a 262K context. Muse Glimmer is the strongest runner-up and the right fallback when memory is tight. Qwen 3.6 27B trails both and survives only as a cheap text-only option. None of the three matches 3.8 on capability; the choice is whether you can fit 3.8, not whether something beats it.

Hardware fit by VRAM tier

Local model choice starts with whether Qwen 3.8 27B fits, then falls back from there.

On a 16 to 24 GB consumer GPU, all three run at Q4 with a capped context. Qwen 3.8 27B needs the tightest context cap because its KV cache at length is the largest, and its vision tower adds fixed overhead even on text tasks. If a 16 GB card cannot spare the room, Muse Glimmer or Qwen 3.6 27B fit with more context headroom, with Glimmer the stronger of the two.

On a 32 GB card such as the RTX 5090, Qwen 3.8 27B fits at FP8 or Q6 with a moderate context and becomes the clear default; Glimmer fits at FP8 with long context as a lighter alternative, and 3.6 fits at FP8 with generous context for cheap internal tooling. This is the tier where the vision model becomes practical without offload.

On 48 to 64 GB or Apple silicon with 128 GB unified memory, Qwen 3.8 27B reaches Q8 or BF16 with long context and image input, which is where its advantages fully show. Glimmer and 3.6 are overkill at that tier unless you are serving many concurrent sessions, in which case their smaller footprints and faster decode raise the concurrency ceiling.

Two RTX cards do not make one larger pool. The runtime must shard the model with tensor parallelism, and PCIe topology affects the result, so measure prompt processing and decode separately after sharding.

Running any of these models inside your product

The benchmark comparison decides which model is the default, but the integration decision is separate: how the model reaches your users inside your own SaaS without becoming the product's center of gravity.

At Ginger Labs we build an embedded agent or copilot that lives inside your application, in a side panel, inline surface, or modal. The agent reasons over your product's schemas, records, stages, and permissions to progress defined multi-step work, so users describe an outcome and skip learning every intermediate step. The model behind it is Qwen 3.8 27B for the quality, vision, and long-context retrieval that production agents need, with Muse Glimmer or Qwen 3.6 27B available as lighter fallbacks on memory-constrained deployments, selected per task behind the agent's interface.

We also provide MCP as a service: a managed MCP server that exposes selected product capabilities to compatible external AI clients, including your own local agent and third-party clients. We operate the MCP infrastructure so you do not build and run it alone, while you decide which capabilities are exposed and how access is governed.

You keep ownership of the parts that define your product: your API and data model, your domain rules and workflow definitions, user permissions and tenant boundaries, which actions the agent may perform, the customer-facing experience, and the business definition of a correct result. The comparison in this article stays useful only when the agent hides the model behind your own authorization and evaluation surface, so you can move from Qwen 3.8 27B to a lighter fallback, or change providers, without rewriting product permissions or customer experience.

How to choose

Pick Qwen 3.8 27B unless a 24 GB card cannot fit it, then confirm with a shared evaluation on your own tasks. Use Qwen 3.8 27B when the work mixes text with images or documents, needs a long session, or depends on accurate tool calls across a large schema. Use Muse Glimmer as the fallback when volume and memory both matter and you run on a 16 to 24 GB GPU that cannot spare 3.8's context and vision overhead, because it is the strongest model that still fits with room to spare. Use Qwen 3.6 27B for internal text tooling where the cheapest local deployment outweighs frontier quality.

Run each candidate against one bounded task with a defined trigger, allowed actions, approval boundary, expected final state, and escalation cases. Measure verified completion, wrong reads and writes, recovery after a failed tool call, human review time, latency, and cost per accepted result. Keep model selection behind a stable agent interface so the choice is configuration, not a rewrite of your authorization or customer experience.

Conclusion

Qwen 3.8 27B, Muse Glimmer, and Qwen 3.6 27B all run from a single consumer GPU, but only 3.8 leads on the metrics that decide a local deployment. It tops production coding, agentic terminal work, 128K retrieval, multimodal understanding, decode throughput, and context length, and it is the only model with vision and a 262K window. Muse Glimmer is the closest challenger and the right fallback when a 24 GB card cannot fit 3.8's overhead. Qwen 3.6 27B trails both and survives only as a cheap text-only option. Standardize on Qwen 3.8 27B, fall back only when memory forces it, and lock the decision with an evaluation on your own tasks at a fixed context cap, quantization, and harness.

Sources

• Qwen3.8-27B official model card (accessed August 9, 2026)
• Qwen3.8-27B official FP8 checkpoint (accessed August 9, 2026)
• Qwen3.8-27B GGUF quantization inventory (accessed August 9, 2026)
• Qwen3.6-27B official model card (accessed August 9, 2026)
• Qwen3.6-27B GGUF quantization inventory (accessed August 9, 2026)
• Muse Glimmer model card and benchmark report (accessed August 9, 2026)
• Muse Glimmer local inference guide (accessed August 9, 2026)
• vLLM quantization and hardware compatibility (accessed August 9, 2026)
• llama.cpp README and build documentation (accessed August 9, 2026)
• NVIDIA RTX 5090 specifications (accessed August 9, 2026)