27B Dense Model Tops Hugging Face All-Time Likes: Frontier-Level Agentic Ability on 16GB VRAM

A 27B Model Just Rewrote the Open-Source Leaderboard

Hugging Face's most-liked open-source model of all time has a new champion. And it's not a flagship behemoth with 2.4 trillion parameters — it's a 27B dense model from Hangzhou that, after quantization, runs on roughly 16GB of VRAM and fits comfortably on a single RTX 4090.

Bilibili creator Cui Hao broke down this phenomenon in his latest video: the model has racked up around 15,100 likes, surpassing FLUX.1 (roughly 14,700) and its Kimi K-series rivals. The week before, it was sitting at second place — then gained 866 more likes in a single week, added 1.28 million downloads, and jumped straight to the top.

What's even more striking is its growth curve. Within 12 hours of release, it cracked the top four in HF's all-time rankings. Two days later, it crossed one million downloads. The community spontaneously contributed around 500 quantized variants. Hugging Face even launched a countdown page ahead of time. Overseas communities gave it a nickname: "Local Opus."

Why This One? The Answer Is "Intelligence Density"

For the past two years, the open-source playbook defaulted to chasing parameters: 70B, 400B, 671B — the bigger the number, the more impressive it sounded. But there's a fatal problem with massive parameter counts: you need somewhere to put them. A 400B model still needs two to three hundred gigabytes of VRAM even after quantization. The average developer's single RTX 4090 can't even get in the door, and they end up going back to cloud APIs.

There's a common misconception worth clearing up here: many people assume MoE (Mixture of Experts) architectures save VRAM. They don't. MoE saves compute, not VRAM. Only a small fraction of parameters are activated per inference pass, but all the weights must be loaded into memory — so VRAM usage is still calculated against the total parameter count.

This model, by contrast, is a dense 27B architecture: FP16 needs 54GB, FP8 needs 28GB, and 4-bit quantization lands around 16–18GB. A single RTX 3090 or 4090 runs it comfortably.

Cui Hao put it this way: people used to assume the top-tier trim was the only reliable option — V8 engine, all-wheel drive, the works. But someone commuting daily quickly realizes the mid-trim gets better mileage, is easier to park, and still overtakes when needed. The extra money buys horsepower you use twice a year. The 27B dense model is that mid-trim.

MoE (Mixture of Experts) works by splitting a model into multiple "expert" sub-networks, with a gating mechanism activating only a few of them per inference pass. Take DeepSeek V3 as an example: total parameters are 671B, but only roughly 37B are activated per forward pass, dramatically reducing theoretical compute costs. However, all expert weights must reside in VRAM simultaneously to be available on demand — which is why a 671B MoE model still requires hundreds of gigabytes of VRAM even after quantization. Dense models have no such distinction: every parameter participates in every inference pass. The structure is simpler, latency is more predictable, and the model is far easier to load in full on a single consumer GPU or a two-card setup.

How Much Can the Mid-Trim Handle? Let the Benchmarks Talk

Officially published benchmarks show this model excels on multi-step tasks:

• SWE-Bench Pro: 61.7
• LiveCode Bench V6: 90.3
• OS World: 84.3

Compared to the previous generation at the same parameter count, the Deep SWE score jumped from 13.3 to 42.2 — a remarkable leap. On the official comparison table, it leads Claude Opus-class top-tier models on SWE-Bench Pro, LiveCode Bench, and OS World, though it trails on Terminal Bench and GPQA Diamond.

In other words, this isn't a clean sweep — it's exceptionally strong on multi-step (Agentic) tasks, with only modest gains on pure knowledge and pure reasoning.

Third-party validation followed quickly. Artificial Analysis's composite score puts it on par with GPT-5-class top-tier reasoning models — which are cloud-only. On the Agentic Index, it scored 51, surpassing Claude Opus at its highest reasoning tier. Teams building AI coding tools gave a direct assessment: this is the first time a local model has reached frontier-level capability.

Perhaps most concrete is a legal domain validation — Harvey and Engram set up a synthetic law firm, running 250 legal tasks with an average score of 67, higher than every other model in that study.

SWE-Bench evaluates a model's ability to solve real GitHub software engineering issues: the model must read an issue description, autonomously modify the codebase, and produce a patch that passes tests — widely regarded as the gold standard for measuring Agentic coding capability. OS World measures success rates on multi-step desktop tasks in a simulated OS environment, covering file operations, app interactions, and similar scenarios, making it a key indicator of real-world "local agent" usefulness. LiveCode Bench focuses on dynamically updated competitive programming problems, effectively preventing models from gaming scores by memorizing past problems. All three benchmarks point to the same class of capability: complex tasks requiring multi-turn planning, tool use, and self-correction — not single-turn Q&A or static knowledge retrieval.

A Few Things That Need to Be Said Clearly

The benchmarks look impressive — but Cui Hao also honestly flagged several things worth viewing with a cool head.

First, most benchmark numbers are self-reported by the vendor. The testing environment and configuration may differ significantly from your real-world setup. That third-party composite score ties the lower tier of cloud frontier models, not the top tier. As of the time of evaluation, it had no independent MMLU or Arena rankings.

Second, it's noticeably slower. Independent testing found it consumes more tokens per task compared to the previous generation. Local throughput is roughly 9–22 tokens per second, and enabling thinking mode slows it down further. What you save on API bills, you pay for in time.

Third, a popularity ranking measures hype, not absolute capability. FLUX.1 is an image model; DeepSeek R1 is a reasoning model — they're not competing in the same lane. The only thing this leaderboard genuinely tells you is that developers are willing to use it.

The Top Spot Is the Result of a Compounding Curve

Zoom out, and this moment looks more like a compounding result than a sudden breakthrough. According to the video's data, Alibaba has cumulatively open-sourced over 460 models, with total global downloads exceeding 3 billion and more than 300,000 derivative models. In just the first seven months of 2026, its models were downloaded roughly 2.045 billion times on Hugging Face — 4.9× Google's figure and 9× Meta's.

Adoption patterns are also shifting: less than a month after release, Perplexity chose it as the preferred model for its local agent; earlier, Reuters, Airbnb, and Pinterest had also made the switch.

There's also an ironic detail worth noting: what topped the chart wasn't the 2.4-trillion-parameter flagship. That version uses a custom tiered license that prohibits free local deployment. The 27B smaller model — downloadable, modifiable, commercially usable — ended up being the one to claim the all-time top spot.

Quantization is the key technology that makes large models viable on consumer hardware: by reducing the numerical precision of weights — compressing from FP32 or FP16 down to INT8, INT4, or lower — it cuts VRAM usage and bandwidth requirements by multiples, at the cost of minor accuracy loss. The community spontaneously contributing around 500 quantized variants reflects the complete ecosystem that has formed around open-source models: from GGUF-format llama.cpp builds and AWQ/GPTQ GPU-accelerated versions, to ultra-low-bit variants optimized for Raspberry Pi or Apple Silicon. Different users take what they need. This community distribution mechanism is something closed-source cloud APIs fundamentally cannot replicate: every quantized variant was packaged and uploaded after someone tested it on their own machine — an implicit reliability filter that's already happened before you ever hit download.

The Real Story Is "Intelligence Density"

So the real protagonist of this story isn't "who's number one" — it's the concept of intelligence density.

For two years, the open-source world defaulted to chasing parameter counts and benchmark scores. What won this time was a solution that compresses capable intelligence into 16GB of VRAM. If your hardware can run it, this is genuinely meaningful: you now have an option that depends on no cloud API whatsoever — data stays in your own infrastructure, and your bill doesn't run on a per-token meter.

For teams that care about data compliance and want to control inference costs, both of those properties will only become more valuable over the next year.