Ranked #1 Local / Private AI — Your Brain, Your Machine, Your Rules
Alibaba (Qwen Team)

Qwen3.8 — 27B

Qwen3.8-27B is the rare local model whose compromises line up with hardware people actually own: one dense 27B checkpoint for text, images, video, coding, and tool-using agents. A 4-bit build fits on a 24 GB-class GPU, while the Apache 2.0 license keeps the work private and commercially usable.

Updated August 15, 2026 Open WeightsApache 2.027B Dense
9.2out of 10
Official Website
Best for

Qwen3.8-27B is the rare local model whose compromises line up with hardware people actually own: one dense 27B checkpoint for text, images, video, coding, and tool-using agents. A 4-bit build fits on a 24 GB-class GPU, while the Apache 2.0 license keeps the work private and commercially usable.

Why It Wins

Qwen reports 61.7 on SWE-bench Pro, 73.0 on Terminal Bench 2.1, 42.2 on DeepSWE 1.1, 84.3 on OSWorld-Verified, and 70.7 on CoWorkBench. It has 262,144-token native context, optional YaRN scaling toward 1M, adjustable reasoning effort, preserved thinking across turns, and native image and video understanding.

Watch out

This is launch-day evidence, not settled truth. Most headline scores come from Qwen's own table; some use the Claude Code harness, corrected tasks, special prompts, or Qwen-created benchmarks. The common Q4_K_M package is roughly 18 GB including its vision projector, but runtime overhead and KV cache still limit how much context fits on a 24 GB card.

01

What It Actually Is

Imagine choosing a workshop, not a single hammer. A local AI model has to fit through the door, leave room on the bench, understand the material in front of it, and use the available tools without sending private work elsewhere. Qwen3.8-27B is compelling because those requirements meet in one checkpoint. It is a dense 27-billion-parameter vision-language model built on Qwen3.5’s hybrid foundation: three Gated DeltaNet layers are followed by one full-attention layer in a repeating pattern. The linear-attention sections help efficiency; periodic full attention lets the model still connect distant details.

The word “multimodal” matters here. This is not a text model with a decorative image upload button. Qwen trains and distributes it as an image-text-to-text model with native image and video input. A local coding agent can inspect a screenshot, read an error dialog, compare it with source files, and operate tools without first shipping the image to a separate cloud vision service. The model card also describes document, chart, browser, mobile, and hour-scale video tasks. That makes Qwen3.8-27B closer to a private general-purpose workbench than a specialized autocomplete engine.

Its launch numbers explain the excitement. Qwen reports 61.7 on SWE-bench Pro, 73.0 on Terminal Bench 2.1, 42.2 on DeepSWE 1.1, and 90.3 on LiveCodeBench v6. On multimodal-agent work it reports 84.3 on OSWorld-Verified, 64.8 on WebArena-Verified, and 70.7 on CoWorkBench. Compared with Qwen3.6-27B, gains appear in repository repair, terminal operation, office work, and computer use rather than in one conveniently chosen exam. That breadth is more interesting than any isolated number.

But a benchmark is a laboratory apparatus, not a law of nature. Qwen’s SWE-bench Pro and DeepSWE results use the Claude Code harness, long context, and declared sampling settings. Qwen also corrected problematic SWE-bench Pro tasks and reevaluated baselines. CoWorkBench and QwenSWEBench are in-house tests. MathVision uses a fixed prompt and corrected annotations; some visual-agent tests use specific graders or scaffolds. None of this makes the results useless. It tells us what was measured: Qwen3.8 inside a carefully chosen system. Ollama, LM Studio, llama.cpp, or a home-built agent may produce a different result.

The hardware story needs the same honesty. The official BF16 weight shards total about 55.6 GB before runtime overhead. Unsloth’s Q4_K_M file is about 17.1 GB, and the vision projector adds about 0.93 GB. An 18 GB download can therefore fit on a 24 GB GPU, but the remaining six gigabytes are not empty luxury; they must hold buffers and the KV cache that remembers earlier tokens. Longer context consumes more memory. A 24 GB card is a credible starting point for useful local work, not a promise of 262,144 tokens at maximum speed and full cache precision.

Qwen gives operators unusually good controls. The native window is 262,144 tokens, and the model card documents YaRN scaling toward one million in vLLM, SGLang, and TokenSpeed. Reasoning is enabled by default, with low, medium, and xhigh effort levels, while preserve_thinking can carry reasoning context across an agent conversation. Qwen also trained a multi-token-prediction head, which compatible inference systems can use to accelerate decoding. These knobs are valuable, but they are knobs: static YaRN may reduce quality on shorter text, and lower reasoning effort can cause retries that erase the apparent speed saving.

The right first test is deliberately ordinary. Load the quant you can keep resident, choose a context window that leaves memory headroom, and give Qwen a real task with a visible finish line: fix a failing test, extract figures from a private report, or reproduce a UI from a screenshot. Record whether the task finished, how many retries it needed, how fast it ran, and how much human correction remained. Then run Qwen3.6 or your current model under the same conditions. That experiment measures your workshop, not somebody else’s laboratory.

For now, Qwen3.8-27B is the best default at the intersection of privacy, capability, multimodality, and attainable hardware. Larger open models can be smarter in narrow or difficult areas, and smaller models can be faster. Qwen occupies the useful middle: strong enough to do serious work, small enough to live under one desk, and open enough that the desk can belong entirely to you.

02

Strengths and honest limitations

Key Strengths

  • A genuinely practical multimodal local agent: The same checkpoint reads text, screenshots, diagrams, documents, and video, then can reason and call tools. You do not need to route a private workflow through separate vision and coding models just to inspect a UI bug or extract a table before editing code.
  • Large generation-to-generation gains in Qwen’s tests: Qwen3.8-27B rises from Qwen3.6-27B’s 53.5 to 61.7 on SWE-bench Pro, from 63.4 to 73.0 on Terminal Bench 2.1, and from 13.3 to 42.2 on DeepSWE 1.1. The exact harness matters, but the improvement appears across several different kinds of software work.
  • The 27B size is useful rather than merely small: Unsloth’s Q4_K_M weights are about 17.1 GB and its vision projector about 0.93 GB. That makes a 24 GB GPU or a suitably equipped Apple-silicon machine a realistic home for the model, with room depending on runtime, cache precision, and context length.
  • Long-context and thinking controls are unusually complete: Native context is 262,144 tokens; Qwen documents YaRN scaling up to 1M for vLLM, SGLang, and TokenSpeed. Thinking can be disabled, set to low, medium, or xhigh effort, and preserved between turns for long agent loops.
  • Open license and fast deployment ecosystem: The official checkpoint is Apache 2.0. Qwen documents vLLM, SGLang, and TokenSpeed support; Ollama already lists an 18 GB qwen3.8:27b build, and Unsloth publishes GGUF quantizations from roughly 9 GB to 31.5 GB.

Honest Limitations

  • The scores are principally vendor-reported: Qwen ran most comparisons, and the table mixes public tests with QwenSWEBench, CoWorkBench, and RecreationBench, which are in-house. SWE-bench Pro and DeepSWE use a Claude Code harness with Qwen’s stated settings, so they measure a model-plus-scaffold system, not bare weights in every local app.
  • Twenty-four gigabytes does not buy the full 262K context: Model weights are only the first suitcase. The vision projector, runtime buffers, and growing KV cache need memory too. A 24 GB card can run a 4-bit build, but very long prompts require a smaller or quantized cache, partial CPU offload, or more memory.
  • Quantization changes the thing being measured: Qwen’s benchmark table does not establish that every 4-bit GGUF preserves the same reasoning, vision, and tool-use quality. The difference may be small or task-specific, but a production choice should be tested at the exact quant and context setting you plan to use.
  • Early integrations still need model-specific care: Thinking is on by default, Qwen recommends different sampling settings for thinking and non-thinking modes, and static YaRN can hurt shorter-text performance. Tool schemas, output limits, and chat templates are part of the product, not housekeeping to ignore.
03

Benchmark Snapshot

Repository repair — SWE-bench Pro: 61.7

Qwen reports 61.7 versus 53.5 for Qwen3.6-27B. The models were evaluated with the Claude Code harness, temperature 1.0, top-p 0.95, 256K context, and a refined set with problematic tasks corrected.

Terminal agent — Terminal Bench 2.1: 73.0

A 9.6-point gain over Qwen3.6-27B in Qwen's table. It is a strong signal for multi-step command-line work, although local speed and success still depend on the agent scaffold and available tools.

Computer use — OSWorld-Verified: 84.3

The largest practical surprise: a compact open checkpoint scores above every comparison in Qwen's table, including Opus4.6 Max at 72.7. Independent reproduction is especially important because computer-use results are sensitive to the surrounding harness.

Local footprint — Q4_K_M plus vision projector: about 18 GB

Repository metadata lists a 17.1 GB Q4_K_M GGUF and a roughly 0.93 GB BF16 vision projector. That fits the files on 24 GB-class hardware, while remaining memory determines usable context and concurrency.

04

The Verdict

Qwen3.8-27B becomes our #1 Local / Private AI recommendation because it offers the most useful overall package for an individual: serious coding and agent capability, native vision and video, a long context window, Apache 2.0 freedom, and a quantized footprint that can fit one high-end consumer GPU. It does not beat every larger model—DeepSeek-V4-Flash-0731 leads Qwen’s table on Terminal Bench and DeepSWE—but DeepSeek’s useful quants need roughly 100 GB rather than about 18 GB. That accessibility gap matters in a local category. Treat the 9.2 score as provisional: test the exact quant, tools, and prompts you will deploy, keep human review around consequential actions, and revisit the ranking when independent replications mature.

05

Frequently Asked Questions