A downloadable 27-billion-parameter model has edged past several much larger proprietary systems on Artificial Analysis’s Agentic Index. It can also run on a single 24GB graphics card. Both claims are true—and both need fine print.
Three days after Qwen released Qwen3.8-27B, the model has produced the kind of result that makes the local-AI world sit up straight: it ranks above GPT-5.6 Terra, DeepSeek V4 Pro, Muse Spark 1.2, GLM-5.2 and the now-superseded Claude Opus 4.8 on the Artificial Analysis Agentic Index.
The striking part is not merely the list of names below it. Qwen3.8-27B is a downloadable, Apache-2.0-licensed dense model. With roughly 4-bit weights and a sensible context setting, it can run fully on one 24GB Nvidia RTX 3090 or RTX 4090. The systems it beats are generally consumed as hosted services.
That makes the result meaningful. It does not make it magic.
Qwen’s lead over GPT-5.6 Terra is 0.68 points before rounding. The leaderboard compares specific reasoning-effort variants, not entire model families. Claude Opus 4.8 is deprecated and no longer appears in the default live table. And the 24GB version you run at home will be quantized, while Artificial Analysis does not establish that your local 4-bit build will reproduce its exact score.
The honest headline, then, is still an excellent one: a model small enough for a well-equipped gaming PC is now competitive with serious hosted agents on an independent tool-use benchmark.
Kingy’s verdict: This is a genuine local-AI milestone, not a new overall intelligence champion. Qwen3.8-27B is seventh on the current live Agentic Index, and its win over Terra is narrow. What changes the equation is the combination of agentic performance, downloadable weights and single-GPU practicality.
Evidence cutoff: August 17, 2026, 4:00 p.m. PDT. Leaderboards change. Kingy reviewed the published benchmark data and model files; we did not independently rerun the full Agentic Index suite.
The result, without the rounding blur
Artificial Analysis displays whole-number scores on parts of its interface. Those rounded values make Qwen3.8-27B and two competitors look closer than they really are—and, in one case, tied. The underlying leaderboard data is more useful.
| Model configuration tested | Agentic Index, raw | Displayed | Status on live table |
|---|---|---|---|
| Qwen3.8-27B | 50.877 | 51 | Active, rank 7 |
| GPT-5.6 Terra (max) | 50.201 | 50 | Active, rank 8 |
| DeepSeek V4 Pro 0813 (Reasoning, Max Effort) | 49.563 | 50 | Active, rank 9 |
| Claude Opus 4.8 (Adaptive Reasoning, Max Effort) | 49.375 | 49 | Deprecated; hidden by default |
| Muse Spark 1.2 (xhigh) | 49.311 | 49 | Active, rank 10 |
| GLM-5.2 (max) | 45.667 | 46 | Active, rank 12 |
Qwen’s margins are 0.676 points over Terra, 1.315 over DeepSeek V4 Pro, 1.502 over Claude Opus 4.8, 1.566 over Muse Spark and 5.210 over GLM-5.2.
Those figures confirm the claim. They also show why “crushed” would be the wrong verb. Qwen did not run away from Terra or DeepSeek. It won a photo finish.
There is another essential piece of context: Qwen3.8-27B is not number one on the Agentic Index. Six active configurations currently rank above it: Claude Opus 5, Grok 4.6, Qwen3.8 Max, GPT-5.6 Sol, Claude Fable 5 and Kimi K3. Seventh overall is impressive for this weight class, but it is not frontier leadership.
The exact model names matter, too. The result belongs to Qwen3.8-27B, not to the much larger Qwen3.8 Max service. Its rivals were evaluated at named effort settings such as “max” and “xhigh.” A clean comparison therefore says Qwen3.8-27B beat those tested configurations on this index. It should not be inflated into a timeless claim that “Qwen beats GPT, Claude and DeepSeek.”
What the Agentic Index actually measures
The Artificial Analysis methodology defines the Agentic Index as an equal-weighted average of two evaluations: GDPval-AA v2 and τ³-Banking. That is a more demanding target than a static multiple-choice exam.
GDPval-AA v2 assesses economically useful work across a range of occupations. Models operate through tools such as a shell and web browser, and outputs are judged through blind comparisons. τ³-Banking tests multi-turn customer-service work in a simulated banking environment, where the model must follow policy, maintain state and use tools correctly.
Together, they aim at the messy capabilities people mean when they call a model “agentic”: planning, tool selection, executing a sequence of actions, recovering context and finishing a task instead of merely describing how one might do it.
That makes this result more relevant to local agents than another trivia or math score. A model running on your own workstation is useful only if it can reliably work through a repository, a document set or an operational workflow. The Agentic Index is at least trying to measure that territory.
It is still one composite number built from two benchmark families. A banking-support simulation does not tell you how well the model will refactor your TypeScript monorepo. Occupational tasks do not predict whether it will obey your company’s custom approval rules. Agent evaluations are also unusually sensitive to scaffolding: tool definitions, time limits, system prompts, inference budgets and retry policies can move the result.
Use the index as independent evidence of strong agent behaviour—not as a warranty for every agent you might build.
The broader intelligence table tells a different story
Artificial Analysis also publishes a broader Intelligence Index. On that measure, Qwen3.8-27B trails all five of the named models in this comparison.
| Model configuration | Intelligence Index, raw | Displayed |
|---|---|---|
| Qwen3.8-27B | 52.025 | 52 |
| GPT-5.6 Terra (max) | 56.576 | 57 |
| DeepSeek V4 Pro 0813 (max) | 53.198 | 53 |
| Claude Opus 4.8 (max) | 57.330 | 57 |
| Muse Spark 1.2 (xhigh) | 56.762 | 57 |
| GLM-5.2 (max) | 52.641 | 53 |
This is not a contradiction. Different evaluations reward different capabilities. A model can be unusually effective at planning and tool-mediated workflows without leading a broad suite of knowledge, reasoning, coding and long-context tests.
It also explains a confusing number on Qwen’s Artificial Analysis model page. The prominent 52 is the Intelligence Index. The Agentic Index is 50.877, displayed as 51. Mixing the two produces a slightly better headline and a much worse article.
The practical reading is more interesting anyway: Qwen3.8-27B appears to convert its relatively compact parameter budget into agent performance exceptionally well. It may be a better local operator than its broader intelligence score alone would suggest.
Why 27 billion parameters changes the economics
Qwen3.8-27B is the compact dense member of the Qwen3.8 family, released on August 14. According to the official Qwen model card, it combines 48 Gated DeltaNet layers with 16 full-attention layers in a 64-layer hybrid stack. It includes a vision encoder, supports a native 262,144-token context window and can be extended with YaRN under the right conditions.
The weights are available under the permissive Apache 2.0 licence. That is the difference between renting access to a score and owning a model you can actually deploy.
Local ownership gives developers several options that hosted APIs cannot fully match:
- keep source code, contracts or customer documents on premises;
- pin a model version instead of absorbing an unannounced service change;
- run repeatable evaluations against a fixed checkpoint;
- customize the serving stack, context allocation and agent scaffolding;
- avoid per-token charges for sustained workloads; and
- continue operating without a cloud-model dependency.
None of those advantages makes local inference free. Electricity, hardware, integration work and slower throughput all count. But a one-GPU deployment is categorically simpler than a multi-GPU server. It moves credible agent experimentation from the lab budget to the enthusiast workstation.
This is also why the result is more consequential than Qwen3.8 Max ranking near the top. A proprietary frontier endpoint scoring well is expected. A downloadable 27B model entering the same agentic neighbourhood creates choices.
Yes, it can run on one RTX 3090 or RTX 4090
Both the GeForce RTX 3090 and GeForce RTX 4090 have 24GB of GDDR6X memory. That is enough for Qwen3.8-27B—but not in its official full-precision form.
The official BF16 checkpoint contains about 55.56GB of tensor data, or 51.75GiB. Qwen’s official FP8 release also exceeds a 24GB card before runtime overhead. Single-card use therefore depends on a lower-bit community quantization, normally through GGUF and llama.cpp or a comparable stack.
The currently published Unsloth GGUF files make the trade-off visible:
| Weight format | Approximate file size | One 24GB card? | Practical reading |
|---|---|---|---|
| Official BF16 | 55.56GB | No | Requires far more memory or offload |
| Official FP8 | More than 24GB | No | Does not leave room for serving overhead |
| Q8_0 GGUF | 29.05GB | No | Too large for full 24GB GPU residency |
| Q6_K GGUF | 22.88GB | Marginal | Almost no room for cache and buffers |
| Q5_K_M GGUF | 19.83GB | Possible, constrained | Context and overhead need care |
| Q4_K_M GGUF | 17.11GB | Yes | Sensible starting point |
| UD-Q4_K_XL GGUF | 17.92GB | Yes | Higher-fidelity 4-bit option, slightly tighter |
File size is not total memory use. The runtime also needs the growing key-value cache, fixed recurrent state for the DeltaNet layers, compute buffers and the CUDA context. Loading the optional vision projection adds roughly another gigabyte before image tokens enter the context.
For a first attempt, the conservative configuration is text-only, one request slot, full GPU offload, flash attention, Q4_K_M or UD-Q4_K_XL weights, and a modest context. Start at 8K or 16K. Move to 32K only after measuring free VRAM and stability on your exact build. Our separate Qwen3.8-27B local hardware guide goes deeper on those settings, while the quantization guide compares the available GGUF choices.
The RTX 4090 should deliver materially higher throughput. The RTX 3090 gives you the same crucial 24GB capacity and can still be the better value if you already own one. For fitting the model, VRAM is the gate; for living with it every day, speed, power and cooling become the next questions.
The advertised 262K context does not fit the simple headline
Qwen’s architecture reduces cache growth because only 16 of its 64 layers use full attention. That is clever, but it does not repeal memory arithmetic.
At BF16 or FP16 cache precision, those attention layers require about 64KiB per token for the key-value cache. That is roughly 2GiB at 32K tokens, 8GiB at 128K and 16GiB at the native 262,144-token limit—before recurrent state, weights, buffers, the vision tower or desktop display use. An 8-bit cache roughly halves that component, but the total still does not make a stock 24GB setup a comfortable full-262K machine.
Some optimized community builds have pushed a single RTX 3090 or 4090 well beyond ordinary context settings. Those results are useful engineering demonstrations, not universal promises. Runtime version, cache type, model quant, speculative decoding, vision use and concurrent slots all change the ceiling.
This distinction matters because “supports 262K” is a model capability. “Runs at 262K on my 24GB card” is a system configuration. They are not interchangeable.
For most coding and research agents, a reliable 16K or 32K deployment with retrieval, file selection and summarization is more useful than a fragile attempt to stuff an entire workspace into memory. Long context is a resource to budget, not a trophy to max out.
The largest unknown is the quantization gap
Artificial Analysis’s score establishes how the evaluated Qwen3.8-27B configuration performed. It does not certify every community conversion.
Shrinking roughly 52GiB of BF16 tensors into a 16–17GiB 4-bit package necessarily changes numerical precision. Good quantization can preserve most of a model’s quality, but agent tasks can amplify small differences. One malformed tool argument, missed policy condition or premature “done” can turn a nearly correct trajectory into a failed run.
The exact Artificial Analysis provider, inference stack and precision are therefore part of the result, even when the public leaderboard encourages us to focus on the model name. Until the same agent suite is rerun against a named Q4 file on a named local backend, the safe claim is:
Qwen3.8-27B fits on one 24GB GPU at approximately 4-bit precision, and the model scored 50.877 on Artificial Analysis. It has not been shown that every 4-bit local build earns 50.877.
That caveat should guide how you evaluate it. Do not begin with vibes or a handful of chat prompts. Build a small task set from your real workflow: repository navigation, structured extraction, shell use, policy adherence and recovery from tool errors. Run the same cases repeatedly. Track completion, incorrect actions, retries, latency and memory—not just whether the prose sounds clever.
If Q4 misses a critical task, compare a higher-fidelity quant or a hosted endpoint before concluding that the base model cannot do it. If Q4 passes, you have something more valuable than a leaderboard claim: evidence that the economical version works for you.
What this means for local coding and research agents
The most plausible immediate use is not replacing every frontier API. It is moving more of the agent loop onto hardware you control.
A local Qwen3.8-27B can inspect private files, propose patches, run approved commands and iterate without shipping each token of context to an external provider. Its native vision capability also opens document and interface workflows, although vision consumes additional memory and should not be treated as free on a tight 24GB budget.
The model’s strong Agentic Index showing makes it a credible candidate for:
- local repository exploration and bounded coding tasks;
- document triage, extraction and evidence synthesis;
- tool-using research with an explicit source trail;
- repetitive back-office workflows with human approval gates; and
- hybrid agents that handle routine steps locally and escalate difficult cases to a frontier service.
That last design may be the sweet spot. A compact local model can do cheap, private and repeatable work while a stronger hosted model remains available for genuinely hard decisions. The benchmark result suggests Qwen3.8-27B deserves a place in that routing experiment.
Kingy’s hands-on local coding-agent guide covers a practical deployment path. The important operational rule is the same regardless of runtime: keep permissions narrow. A high agent score is an argument for useful capability, not for removing approval gates around deletion, deployment, purchases or production systems.
Who should try it—and who should wait
Try it now if you already have a 24GB Nvidia GPU, want local control, and are comfortable testing GGUF runtimes. Q4_K_M is the practical baseline. Start with a restrained context and benchmark your own jobs.
Consider it for a new workstation if local agent privacy or sustained use has real economic value to you. Compare the total system cost with hosted API use, and buy for the workload rather than for a single leaderboard snapshot.
Wait if you need guaranteed frontier performance, full native context on one card, high concurrency or vendor-supported 4-bit deployments. A hosted service or a larger-memory system is the less frustrating choice.
Do not switch solely because of rank 7. The result is close, the index is narrow and the market will move again. Switch when Qwen wins your evaluation at an acceptable speed and error rate.
The real breakthrough is the combination
Any one part of this story would be less remarkable on its own.
A 27B model that fits on a gaming GPU is useful but common. A seventh-place agent score is strong but not dominant. Open weights are welcome but do not guarantee operational quality. Put all three together—competitive agent behaviour, downloadable Apache-2.0 weights and credible single-card inference—and the result becomes important.
It means a developer with an RTX 3090 can now test a serious agent locally without pretending that a tiny model is equivalent to the frontier. It means a 4090 workstation can become an actual private automation box, not merely a chatbot demo. And it gives hosted model vendors another kind of competition: not just a cheaper API, but software people can own.
The frontier did not move wholesale into a gaming PC. One valuable slice of it did.
Frequently asked questions
Did Qwen3.8-27B really beat GPT-5.6 Terra?
Yes. At the evidence cutoff, Qwen3.8-27B scored 50.877 on the Artificial Analysis Agentic Index versus 50.201 for GPT-5.6 Terra at max effort. The lead is 0.676 points, so it is real but narrow.
Did it beat Claude Opus 4.8?
Yes, on the same index: 50.877 versus 49.375 for Claude Opus 4.8 at its tested adaptive-reasoning/max-effort setting. Opus 4.8 is deprecated and hidden from the default live leaderboard, so the comparison is historical rather than a current product recommendation.
Is Qwen3.8-27B the top agent model?
No. It is seventh on the current active Agentic Index. Six configurations rank higher, including Qwen3.8 Max. It also trails the named competitors on Artificial Analysis’s broader Intelligence Index.
Can the official Qwen3.8-27B checkpoint fit in 24GB?
Not in BF16 or official FP8. A 24GB RTX 3090 or 4090 requires a lower-bit community quantization. Q4_K_M and UD-Q4_K_XL are practical options; Q5 may fit with tighter constraints.
Can I use the full 262K context on one RTX 4090?
Not as a simple, stock, fully offloaded configuration. Highly tuned builds may reach very long contexts, but the native 262K window consumes too much total memory once weights, cache, state and runtime overhead are counted. Begin at 8K–16K and expand after testing.
Will a local 4-bit build match the Agentic Index score?
That has not been established. Quantization and serving settings can affect tool-use reliability. Treat the public score as evidence about the evaluated configuration and validate the exact local file and runtime you intend to use.
What is the best reason to run it locally?
Control. You can keep sensitive context on premises, pin the model version, customize the stack and run sustained workloads without per-token API charges. The trade-offs are hardware cost, power, setup effort and lower throughput than a large hosted service.