{"id":1774,"date":"2026-07-19T08:40:00","date_gmt":"2026-07-19T08:40:00","guid":{"rendered":"https:\/\/nassimstudio.com\/blog\/?p=1774"},"modified":"2026-07-22T15:26:07","modified_gmt":"2026-07-22T15:26:07","slug":"nine-models-tested-three-rejected-32-benchmarks","status":"publish","type":"post","link":"https:\/\/nassimstudio.com\/blog\/nine-models-tested-three-rejected-32-benchmarks\/","title":{"rendered":"9 Models Tested, 3 Rejected: What I Learned From 32 Benchmarks"},"content":{"rendered":"

Not every model that claims to be “good for coding” actually is. I tested 9 different LLMs on my RTX 3060 Ti, ran 32 benchmark configurations, and rejected 3 of them outright. The failures taught me more about what matters in local AI than the successes.<\/p>\n

Here’s the honest breakdown – what worked, what didn’t, and why.<\/p>\n

The Full Roster<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n
Model<\/td>\nSize<\/td>\nType<\/td>\nQuantization<\/td>\nVerdict<\/td>\n<\/tr>\n
Gemma 4 E4B<\/td>\n4B active<\/td>\nMoE<\/td>\nQ4_K_M<\/td>\nKept – fast worker<\/td>\n<\/tr>\n
Qwen3-4B Thinking<\/td>\n4B<\/td>\nDense<\/td>\nQ4_1<\/td>\nKept – simple planner<\/td>\n<\/tr>\n
Qwen3.5 9B<\/td>\n9B<\/td>\nDense<\/td>\nQ4_K_M<\/td>\nMaybe – too heavy for speed<\/td>\n<\/tr>\n
Gemma 4 26B-A4B<\/td>\n4B active<\/td>\nMoE<\/td>\nQ4_K_M \/ UD-IQ4_NL<\/td>\nKept – reasoning model<\/td>\n<\/tr>\n
GLM-4.6V-Flash<\/td>\n–<\/td>\nDense<\/td>\nQ4_K_M + mmproj<\/td>\nRejected<\/strong><\/td>\n<\/tr>\n
Qwen3-Coder 30B-A3B<\/td>\n3B active<\/td>\nMoE<\/td>\nIQ4_XS<\/td>\nMaybe – not worth the complexity<\/td>\n<\/tr>\n
Qwen2.5-Coder 7B<\/td>\n7B<\/td>\nDense<\/td>\nQ4_K_M<\/td>\nKept – daily coder<\/td>\n<\/tr>\n
Qwen3.6 35B-A3B MTP<\/td>\n3B active<\/td>\nMoE + MTP<\/td>\nUD-IQ4_NL<\/td>\nKept – strong planner<\/td>\n<\/tr>\n
Ornith 35B-A3B<\/td>\n3B active<\/td>\nMoE + MTP<\/td>\nUD-IQ4_NL<\/td>\nKept – senior planner<\/td>\n<\/tr>\n<\/table>\n

Out of 9 models, 6 earned a permanent spot, 2 are “maybe” (useful in specific scenarios), and 1 was rejected completely.<\/p>\n

The 3 Rejections<\/h2>\n

GLM-4.6V-Flash: Dead on Arrival<\/h3>\n

I tried GLM-4.6V-Flash three times. Three rejections.<\/p>\n

The model is Zhipu’s multimodal offering – it has vision capabilities through the mmproj (multi-modal projector) component. On paper, it sounds interesting. In practice, it was unusable.<\/p>\n

Run 1<\/strong> (Q4_K_M + mmproj, 32k context): 9.75 t\/s generation. Output was garbled Chinese text despite English prompts. Tokenizer warnings in the server log.<\/p>\n

Run 2<\/strong>: 12.31 t\/s. Slightly better but still producing mixed Chinese\/English output. The model clearly wasn’t trained to handle the prompt format I was using.<\/p>\n

Run 3<\/strong>: 18.91 t\/s. Speed improved but output quality was still broken. Repeated phrases, incoherent code suggestions, and occasional character soup.<\/p>\n

The lesson: model speed means nothing if the output is garbage. GLM-4.6V-Flash is optimized for Chinese language tasks. Running it for English coding was the wrong model for the job. I should have checked the training data language distribution before downloading.<\/p>\n

Qwen3-Coder 30B: Too Much Complexity for Too Little Gain<\/h3>\n

Qwen3-Coder 30B-A3B was my attempt at a large dedicated coding model. 30 billion parameters, 3 billion active per token, with IQ4_XS quantization to fit in VRAM.<\/p>\n

The model worked. The speed was acceptable (14-19 t\/s depending on MoE layer count). The code quality was good. But it never justified its complexity over simpler alternatives.<\/p>\n

The MoE tuning nightmare<\/strong>: Getting acceptable speed required tuning the -ncmoe<\/code> parameter through 8 different values (20, 25, 30, 36, 37, 40, 41, 37 at 128k). At ncmoe 20-25, speed was 10-14 t\/s – too slow. At ncmoe 37, it hit 18.57 t\/s – acceptable but not impressive.<\/p>\n

The context scaling problem<\/strong>: At 32k context, Qwen3-Coder ran at 18.57 t\/s. At 128k context, it dropped to 16.71 t\/s. The speed degradation with context size was worse than Ornith, which maintained 30-36 t\/s at 128k.<\/p>\n

The comparison problem<\/strong>: At 37 MoE layers, Qwen3-Coder hit 18.57 t\/s. Ornith at ncmoe 34 hits 30-36 t\/s. Ornith is faster, has more parameters, supports MTP, and requires less tuning. There’s no reason to use Qwen3-Coder when Ornith exists.<\/p>\n

The lesson: a model that works isn’t the same as a model that’s worth the effort. Qwen3-Coder 30B is a perfectly functional model, but the maintenance overhead of tuning it for 8GB VRAM doesn’t justify its existence when better options are available.<\/p>\n

Qwen3.5 9B: Technically Good, Practically Slow<\/h3>\n

Qwen3.5 9B is a solid general-purpose model with vision capabilities. It ran correctly, produced good output, and handled both text and image inputs. I kept it as a “maybe” because the speed never justified daily use.<\/p>\n

At 125k context with Q4_K_M quantization, the model generated at 22.58 t\/s. Not slow in absolute terms, but slow compared to the alternatives. Gemma E4B does the same quick tasks at 83 t\/s. Qwen2.5-Coder handles coding tasks at 37 t\/s. The 9B model sits in an awkward middle ground – too slow for quick tasks, not deep enough for hard problems.<\/p>\n

The vision capability is interesting, but I don’t need local vision enough to justify the speed penalty. If I need image analysis, I use a cloud API.<\/p>\n

The lesson: a model that’s “good at everything” is often “not the best at anything.” Specialization wins on limited hardware.<\/p>\n

What the 6 Keepers Have in Common<\/h2>\n

The models I kept share three characteristics:<\/p>\n

1. Clear role assignment<\/strong>: Each model does something specific well. Gemma is fast. Qwen Coder is code-focused. Ornith is deep. None of them tries to be everything.<\/p>\n

2. Acceptable speed for its role<\/strong>: A “fast worker” needs to be genuinely fast (83 t\/s). A “daily coder” needs to be interactive (37 t\/s). A “senior planner” needs to be fast enough to not interrupt flow (30+ t\/s). Models below 15 t\/s get demoted to “maybe.”<\/p>\n

3. Minimal tuning overhead<\/strong>: If a model requires 8 rounds of ncmoe tuning to be usable, it’s not worth the effort. The models that earned a permanent spot worked with reasonable defaults.<\/p>\n

The Surprises<\/h2>\n

MTP Changes Everything for Large Models<\/h3>\n

Before testing MTP-enabled models, I thought speculative decoding was a minor optimization – maybe 10-20% speed improvement. The reality: MTP nearly doubles generation speed on models that support it.<\/p>\n

The Qwen3.6 35B without MTP runs at ~18 t\/s. With MTP n=1, it hits 27.19 t\/s. That’s a 50% improvement from a single flag change. For Ornith with optimized MTP settings, the improvement is even larger – from an estimated 18-19 t\/s base to 30-36 t\/s with MTP.<\/p>\n

If your model supports MTP and you’re not using it, you’re running at half speed.<\/p>\n

The 4B MoE Model Outperforms the 7B Dense Model on Speed<\/h3>\n

Gemma 4 E4B at 83 t\/s versus Qwen2.5-Coder 7B at 37 t\/s. The smaller MoE model is nearly twice as fast. This makes sense – MoE activates fewer parameters per token – but the quality gap is smaller than you’d expect. For simple coding tasks, Gemma’s output is 80-90% as good as Qwen’s, at nearly twice the speed.<\/p>\n

TurboQuant+ KV Compression Is Not Optional<\/h3>\n

The first configs I tested used symmetric q8_0\/q8_0 KV cache. Maximum context was 32k on 8GB VRAM. After switching to asymmetric q8_0\/turbo2, context jumped to 128k. The KV cache is the bottleneck, not the model weights. This optimization alone is worth more than any model swap.<\/p>\n

The Final Scorecard<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n
Model<\/td>\nSpeed<\/td>\nQuality<\/td>\nTuning Effort<\/td>\nRole<\/td>\nVerdict<\/td>\n<\/tr>\n
Gemma 4 E4B<\/td>\n83 t\/s<\/td>\nGood<\/td>\nLow<\/td>\nFast worker<\/td>\nDaily driver<\/td>\n<\/tr>\n
Qwen3-4B<\/td>\n86 t\/s<\/td>\nBasic<\/td>\nLow<\/td>\nQuick planner<\/td>\nUseful<\/td>\n<\/tr>\n
Qwen3.5 9B<\/td>\n22 t\/s<\/td>\nGood<\/td>\nLow<\/td>\nVision\/general<\/td>\nMaybe<\/td>\n<\/tr>\n
Gemma 4 26B<\/td>\n18 t\/s<\/td>\nGood<\/td>\nMedium<\/td>\nReasoning<\/td>\nUseful<\/td>\n<\/tr>\n
GLM-4.6V<\/td>\n9-18 t\/s<\/td>\nBroken<\/td>\nN\/A<\/td>\nVision<\/td>\nRejected<\/strong><\/td>\n<\/tr>\n
Qwen3-Coder 30B<\/td>\n18 t\/s<\/td>\nGood<\/td>\nHigh<\/td>\nCoding<\/td>\nMaybe<\/td>\n<\/tr>\n
Qwen2.5-Coder 7B<\/td>\n37 t\/s<\/td>\nExcellent<\/td>\nLow<\/td>\nCode specialist<\/td>\nUseful<\/td>\n<\/tr>\n
Qwen3.6 35B MTP<\/td>\n27 t\/s<\/td>\nExcellent<\/td>\nMedium<\/td>\nPlanning<\/td>\nKeep<\/td>\n<\/tr>\n
Ornith 35B<\/td>\n30-36 t\/s<\/td>\nExcellent<\/td>\nLow<\/td>\nDaily coder + senior planner<\/td>\nDaily driver<\/td>\n<\/tr>\n<\/table>\n

The local AI space moves fast. New models drop every month. But the methodology stays the same: test on your hardware, measure what matters, reject what doesn’t work, and build a stack around roles instead of chasing the single “best” model.<\/p>\n

32 test runs taught me that the answer isn’t one model. It’s three models, each doing what it does best.<\/p>\n

For the complete breakdown of how I use these three models in daily work, see My 3-Model Local AI Stack: Fast Worker + Coder + Senior Planner<\/a>.<\/p><\/p>\n","protected":false},"excerpt":{"rendered":"

Not every model that claims to be “good for coding” actually is. I tested 9 different LLMs on my RTX 3060 Ti, ran 32 benchmark configurations, and rejected 3 of them outright. The failures taught me more about what matters in local AI than the successes. Here’s the honest breakdown – what worked, what didn’t, […]<\/p>\n","protected":false},"author":1,"featured_media":1783,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"rank_math_title":"","rank_math_description":"My 3-model local AI stack: fast worker for quick tasks, coder for daily development, senior planner for complex architecture decisions. All running locally.","rank_math_focus_keyword":"3 model local ai stack fast worker","rank_math_canonical_url":"https:\/\/nassimstudio.com\/blog\/my-3-model-local-ai-stack-fast-worker\/","_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_post_was_ever_published":false},"categories":[42],"tags":[34,32,8],"class_list":["post-1774","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ai-llm","tag-productivity","tag-tools","tag-wordpress"],"blocksy_meta":[],"jetpack_featured_media_url":"https:\/\/nassimstudio.com\/blog\/wp-content\/uploads\/2026\/07\/8_thumb.jpg","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/nassimstudio.com\/blog\/wp-json\/wp\/v2\/posts\/1774","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/nassimstudio.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/nassimstudio.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/nassimstudio.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/nassimstudio.com\/blog\/wp-json\/wp\/v2\/comments?post=1774"}],"version-history":[{"count":15,"href":"https:\/\/nassimstudio.com\/blog\/wp-json\/wp\/v2\/posts\/1774\/revisions"}],"predecessor-version":[{"id":1919,"href":"https:\/\/nassimstudio.com\/blog\/wp-json\/wp\/v2\/posts\/1774\/revisions\/1919"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/nassimstudio.com\/blog\/wp-json\/wp\/v2\/media\/1783"}],"wp:attachment":[{"href":"https:\/\/nassimstudio.com\/blog\/wp-json\/wp\/v2\/media?parent=1774"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/nassimstudio.com\/blog\/wp-json\/wp\/v2\/categories?post=1774"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/nassimstudio.com\/blog\/wp-json\/wp\/v2\/tags?post=1774"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}