Qwen3.8-27B vs Opus 4.6 Max: Local Agentic Coding Benchmarks

Last updated: October 8, 2026 - Qwen Cloud now lists the hosted model at $0.50/$3 per million tokens with a 1M context, and Ollama lists an official qwen3.8:27b build (an 18 GB download).

On August 14, 2026, Qwen released Qwen3.8-27B on Hugging Face as an FP8-quantized, Apache-2.0 open-weights model. The headline is a size story: a 27B dense model - roughly 30 GB of FP8 weights, runnable on a high-end laptop or a single workstation GPU - that Qwen's own evaluations put ahead of Opus 4.6 Max on SWE-bench Pro (61.7 vs 53.4), with DeepSWE 1.1 at 42.2 (up from 13.3 for the previous generation's 27B) and community runs placing it above Opus 4.7 Max's 40.0 on the same benchmark. The Hacker News thread (1,228 points, 725 comments) greeted it with variations on "Opus at home."

This post is the decision-intent read: what the benchmarks actually say, what hardware runs it, what it costs to run locally versus hosted, and the honest cases for staying on a frontier API. If you are choosing across sizes and vendors rather than evaluating this one model, start with the current local-model shortlist, which ranks it against Gemma 4 and Qwen3.8-Flash-Next by hardware tier. It is the companion to our open-weights coding showdown, which covers the wider field, and to the Qwen3.8 Max release analysis for the 2.4T flagship that opened the generation.

The Numbers That Made It a Story#

Qwen evaluated the model with the Claude Code harness at temp 1.0, top_p 0.95, and a 256K context window, correcting problematic tasks and re-running every open baseline on the refined benchmark (Opus 4.6 Max's SWE-bench Pro score is the officially reported one). The full tables are on the model card; here is the part that matters for coding:

Read it as: Qwen3.8-27B wins the agentic coding rows (SWE-bench Pro, DeepSWE, QwenSWEBench) and the multimodal agent rows (OSWorld, AndroidWorld), while Opus 4.6 Max still leads the harder terminal and repo-scale rows (Terminal Bench, NL2Repo) and the deep-reasoning rows (HLE by ten points, GPQA narrowly). That split - local model beats the flagship at agentic loop work, flagship still wins raw reasoning - is exactly the shape our local Qwen is a different tool, not a worse Opus thesis predicted.

The caveats matter as much as the rows. These are vendor-run numbers with the harness and sampling choices Qwen made, every baseline was re-run on the same harness (the "fine print" section of the model card is the honest read), and the HLE gap says the model is not a general frontier replacement. One HN commenter's rule earned wide agreement: the only benchmark that matters is your own repo.

Architecture: How a 27B Holds 262K Context#

The model is a hybrid: 64 layers in a repeating pattern of three Gated DeltaNet linear-attention blocks followed by one full attention block. That is how a 27B dense model holds a native 262,144-token context with an extension path past 1M via YaRN (the config guidance covers the rope_parameters change and its static-YaRN tradeoff on shorter texts).

It is natively multimodal - images and hour-scale video - and thinking is on by default with a reasoning_effort control (xhigh default, medium, low) plus preserve_thinking to keep reasoning traces across turns, which is the same pattern our Fable 5 effort-levels analysis covers for Claude. Qwen's own guidance on effort: lower reasoning effort can make total task time worse in agentic loops, because faster per-turn responses lead to more failures and retries.

Hardware and Real-World Speed#

The FP8 release is ~30 GB of weights. The simplest local path is now Ollama's official build: ollama run qwen3.8:27b pulls the 18 GB default build (the same size as the qwen3.8:27b-q4_K_M tag), and qwen3.8:27b-q8_0 is the 30 GB 8-bit option (Ollama library, checked October 8, 2026). Community reports from the launch thread, all running within 24 hours of release:

• MacBook M5 Max 48 GB via LM Studio (Unsloth Q4 GGUF): 15 tokens/s in power-save mode, 30 tokens/s in performance mode, "perfectly usable for local coding through OpenCode"
• Strix Halo laptops and RTX 4090s running the FP8 or Unsloth quantized builds
• A 17 GB Q4 GGUF build that Simon Willison ran for the now-traditional pelican-SVG test: correct shape and one leg per side of the bike, at the cost of 22,276 reasoning tokens and 21 minutes - the overthinking tax that comes with thinking-mode-by-default

For the bigger MoE sibling, the Qwen3.8-Flash-Next Strata guide now tracks the HN discussion, Google Trends demand, and the local-versus-hosted decision for running 125B on consumer hardware.

If you are weighing it against Aleph Alpha's sparse 78B Kolibri, our guide on how to run Kolibri locally has the RAM and quant math: Kolibri needs more memory overall but activates only 3.46B parameters per token.

Two honest hardware notes from the thread: the model is memory-hungrier per token of KV cache than Gemma 4 or Muse Glimmer (one tester could not fit 128K context on their card), and quantizing hurts it more than some peers - test your quant against your workload before standardizing.

Local Cost vs Hosted Cost#

At launch the model card listed a hosted Qwen3.8-27B on Qwen Cloud as "coming soon". As of October 8, 2026 the Qwen Cloud model page lists it at $0.50 per million input tokens and $3 per million output tokens, with a 1M-token context (991K max input, 131K max output). So the choice is now between running it yourself and paying per token:

• Self-hosted: a one-time hardware cost. A 48 GB unified-memory Mac, a 24 GB+ GPU, or two mid GPUs runs the FP8 or Q4 quant. Per-token cost is electricity; per-seat cost is zero; your code never leaves the machine.
• Hosted: $0.50/$3 per MTok on Qwen Cloud, with 1M context. Other hosted open-weights options are the DeepSeek V4 Flash API at $0.14/$0.28 (now with peak/off-peak pricing from August 16) and the 2.4T Qwen3.8 Max on QwenCloud or Vercel's AI Gateway at $2/$6.
• Frontier API: Opus 4.6/4.7-class coding at $5/$25 per MTok. The local model removes the per-token meter entirely for a workload it can carry.

The self-host break-even math applies directly: if your agent loops burn hundreds of thousands of tokens a day, a $3,000 workstation replaces a recurring API bill in a few months; if your usage is light, the API wins.

Decision Guide#

Use Qwen3.8-27B if: your work is agentic loop coding (fix this, extend that, run the tests) with modest reasoning depth; you want zero per-token cost, data stays local, or you hit license or compliance constraints; you have 24 GB+ VRAM or 48 GB unified memory; or you want a private second opinion alongside a frontier model, the exact pattern of routing to local models for the cheap tier.

Stay on the frontier if: your tasks are reasoning-bound (the HLE gap is a real signal), you need the hardest repo-scale and terminal work (Terminal Bench, NL2Repo still favor Opus), you want the safest agent harness with the best-honed tool ecosystem, or your eval shows the 27B's thinking-mode latency (minutes per hard task) does not fit your loop.

Wait if: you want independent benchmark confirmation before trusting vendor-run numbers. If you need 1M context today, the hosted Qwen Cloud version has it by default.

When to Skip the Local Switch#

The honest reasons to stay put: (1) your workload is already solved by a subscription plan with included usage; (2) your prompts are long-context heavy and the KV-cache memory profile bites; (3) you cannot tolerate the longer wall-clock per hard task; (4) your team's evals do not reproduce the leaderboard. "It beats Opus on a vendor benchmark" is not by itself a migration reason - your benchmark is lying to you unless it is yours.

FAQ#

Is Qwen3.8-27B better than Opus 4.6 Max?#

On Qwen's own evaluations, it scores ahead on SWE-bench Pro (61.7 vs 53.4) and DeepSWE 1.1, and behind on HLE (30.8 vs 40.0), Terminal Bench 2.1, and NL2Repo-Bench. Treat it as stronger at agentic loop work and weaker at deep reasoning, with vendor-run caveats attached to every number.

Can I run Qwen3.8-27B on a MacBook?#

Yes. Community testers ran it on M5 Max 48 GB machines at 15-30 tokens/s via LM Studio with the Unsloth Q4 GGUF, including real coding-agent use through OpenCode. A 48 GB unified-memory machine is the comfortable floor for long context.

How much VRAM does Qwen3.8-27B need?#

The FP8 release is roughly 30 GB of weights, so 24 GB VRAM is marginal and 32 GB is comfortable for moderate context. The model is memory-hungrier per token of KV cache than Gemma 4 or Muse Glimmer, so long-context users should budget accordingly.

Is Qwen3.8-27B free to use?#

The weights are Apache-2.0, so self-hosting costs only hardware and electricity. The hosted Qwen Cloud version is now live and costs $0.50 per million input tokens and $3 per million output tokens (checked October 8, 2026).

What context length does Qwen3.8-27B support?#

Native 262,144 tokens, extendable past 1M via YaRN (static scaling, so the model card recommends enabling it only when long context is actually needed). The hosted Qwen Cloud version serves 1M by default.

Does it support tool calling and agent harnesses?#

Yes - it is designed for agent use: thinking on by default with reasoning_effort control, preserve_thinking for cross-turn reasoning traces, and it served its benchmark runs through the Claude Code harness. vLLM, SGLang, and TokenSpeed all have official serving recipes.

Continue Reading#

• GVS5H: Can Qwen3.8-27B Match Fable 5 on Coding? - a file-ledger harness claims a 27B model reaches Fable 5 level on LiveCodeBench Hard, and why Hacker News doubts it
• Run Qwen3.8-27B Locally - every listed download from the 16.1 GB 4-bit MLX build to the 55.6 GB BF16 weights, plus the Ollama command
• Best Local AI Models in 2026 - the current local-model shortlist by laptop, desktop and workstation tier
• Qwen3.8 Max Ships: 2.4T MoE, 1M Context, $2/$6 - the flagship that opened the Qwen3.8 generation, with the full benchmark table and pricing verification
• GLM-5.2 vs DeepSeek V4 vs Qwen3: Open-Weights Coding Showdown - the wider open-weights field, self-host footprints, and pick-X-if decisions
• Qwen3.6-27B Is the Local Coding Model to Test First - the predecessor's guide to running 27B-class Qwen locally
• The Best Local Coding LLMs in 2026 - hardware, quant, and compliance math for the whole local tier
• Step 5 Preview: Pricing, Benchmarks and the October 15 Open Weights - a 600B open-weights-on-the-way rival that does not fit consumer hardware
• Local Qwen Is a Different Tool, Not a Worse Opus - why local models deserve their own eval bar
• Run Qwen3.8-Flash-Next on a Gaming PC With Strata - the 125B sibling on 12 GB of VRAM and 64 GB of RAM, with speeds and the license catch

Sources#

• Qwen3.8-27B-FP8 model card - architecture, benchmark tables, quickstart, YaRN config, best practices (verified August 15, 2026)
• Qwen3.8-27B base model (verified August 15, 2026)
• Qwen3.8 announcement (cited in the model card citation block)
• QwenCloud hosted model page - 404 on August 15, 2026; live on October 8, 2026 at $0.50/$3 per MTok with 1M context
• Ollama qwen3.8 tags - official qwen3.8:27b builds and sizes (checked October 8, 2026)
• Hacker News thread on Qwen3.8-27B - community hardware reports, speed numbers, and the eval-skepticism discussion (accessed August 15, 2026)
• Unsloth GGUF quantizations - community quant builds (linked from the launch thread)