Ornith 1.5 vs Qwen 3.8: An In-Depth Local LLM Comparison

In August 2026, two open-weight models aimed at local deployment arrived within five days of each other: Alibaba's Qwen team released Qwen 3.8 27B on August 14th, followed by Deep Reinforce's Ornith 1.5 35B on August 19th. Both carry permissive open-source licenses, both target users who want to run serious AI on their own hardware, and both launched with bold performance claims.

This article cuts through the marketing with a deep comparison grounded in public benchmarks, independent third-party evaluations, and real community hardware tests. The headline conclusion, spoiled upfront: which one is better depends entirely on what you're optimizing for.

Architecture Differences: Ornith 1.5 vs Qwen 3.8

The key to understanding this matchup is seeing the two models' fundamentally different architectural choices — nearly every downstream difference in VRAM usage, speed, and long-context behavior traces back to these decisions.

Ornith 1.5: Mixture-of-Experts (MoE)

Ornith 1.5 35B is a Mixture-of-Experts model with 35 billion total parameters, but only roughly 3 billion are activated per token. The model contains 256 independent experts, and a routing mechanism selects 8 of them for each token, leaving the other 248 idle for that pass.

This design delivers a genuine computational efficiency advantage: you carry the knowledge of all 256 experts while only paying the compute cost of 8. That's why it runs faster than its total parameter count would suggest. It uses the MIT license and sits in the middle of a three-model family (a 9B dense version, the 35B MoE, and a 397B flagship) — positioned as the go-to option for consumer and prosumer hardware.

But there's a critical catch: even though only 3 billion parameters activate per token, all 35 billion must be loaded into memory simultaneously. Because the router might choose a different combination of experts on any given token, the model can't predict which experts will be needed — so all of them must be on standby at all times. MoE is cheap on compute, but it doesn't get you a free pass on VRAM.

Qwen 3.8: Dense Model + Hybrid Attention

Qwen 3.8 27B is a dense model — all 27.7 billion parameters activate on every token — released under the Apache 2.0 license. That might sound less efficient than MoE, but Qwen closes the gap through "hybrid attention."

The model has 64 layers, of which only 16 use traditional full attention with its ever-growing KV cache. The remaining 48 use a linear attention mechanism called "gated DeltaNet," which maintains a fixed-size internal state. The practical result: Qwen's KV cache stays remarkably small even as context length grows.

Two completely different engineering bets, both aimed at solving the same fundamental problem — running large models efficiently. Ornith makes computation cheap; Qwen makes long-context memory overhead manageable.

Benchmark Comparisons: The Source Matters More Than the Score

The most common flaw in comparison videos is lining up vendor-published numbers side by side and calling it a day. But where those numbers come from matters more than the numbers themselves.

Vendor-Reported Benchmarks

Ornith 1.5 35B scores in the high 60s on Terminal Bench 2.1 and high 70s on related coding benchmarks in Deep Reinforce's own testing. Qwen 3.8's self-reported numbers show a generational leap: Terminal Bench 2.1 jumped from 63.4 to 73.0, Deep SWE from 13.3 to 42.2, and OS World Verified from 63.9 to 84.3.

The problem: all of these numbers come from each company testing its own model with its own framework. That doesn't mean they're fabricated, but you should treat them the way you'd treat an automaker claiming their car is the fastest.

Independent Third-Party Validation

The only truly independent evidence in this entire comparison comes from Artificial Analysis — a third-party benchmarking organization with no financial relationship with Alibaba. It assigned Qwen 3.8 an intelligence index score of 52, roughly on par with OpenAI's lower-tier GPT models at maximum reasoning settings, and an agentic index score of 51, which actually beats Claude Opus 4.8 running at maximum reasoning.

This is the central tension of this comparison: Qwen's performance claims have real third-party validation behind them, while Ornith — at least for now — does not. Commenters on Hacker News expressed genuine skepticism about whether its "self-improvement" training methodology holds up at the 35B scale. That's not a knock on Ornith's capabilities — it's a statement about the current difference in external confirmation.

Real-World Coding Tests: Surprising Results

This is where the marketing stops and reality begins — real users testing on their own hardware.

Test 1: 30-Question One-Shot 3JS Coding Suite

One community member built 30 one-shot coding tasks using three.js (each model gets one attempt per task). At Q6 quantization, the results were:

• Qwen 3.8 27B: 24/30 — top of the leaderboard
• Ornith 1.5 35B: 15/30
• Previous-gen Qwen 3.6: 13/30

On the surface, Qwen wins cleanly. But digging deeper: some of Ornith's "passes" produced blank screens or broken output that technically met the test criteria. Strip those out and its true usable rate is even lower. That said, on the tasks it did complete successfully, output quality was noticeably better than prior-gen Qwen. Ornith also consumed 20–40% more tokens across the full suite.

Test 2: Building a 3D Game from Scratch

On an Apple M3 Ultra with 512GB unified memory, the tester asked both models to build a playable GTA-style 3D game from a single natural language prompt.

• Qwen 3.8: Completed the task in one shot, no additional guidance needed. This is significant for autonomous coding agent use cases.
• Ornith 1.5: Required 6 separate iterations with continuous hand-holding before reaching a comparable result. The tester was blunt: "Ornith is just not operating at the same autonomous level as Qwen right now."

But the story flips again when it comes to long-context speed: when the context stretched into extreme lengths, Ornith held up well — roughly 75 tokens/sec early on, dropping only gradually to around 45 tokens/sec past 1.6 million tokens. Qwen collapsed to roughly 5 tokens/sec under the same load. That's the difference between "still usable" and "effectively stalled."

Both findings are simultaneously true, and which one matters more depends entirely on how you work.

VRAM Comparison: 24GB Is the Critical Dividing Line

If a model doesn't fit in your GPU, no benchmark matters.

Ornith 1.5 35B: Recommended at Q4 quantization, a full setup requires roughly 23GB VRAM, and the official guidance targets 27GB or more. Because all 256 experts must be loaded, there's no way to save on VRAM. The upside is the n-cpu-moe flag, which lets you offload some experts to system RAM and run on a 12GB card — but with a significant speed penalty.

Qwen 3.8 27B: At the same Q4 quantization, it needs only about 16–19GB, fitting comfortably in a standard 24GB card with 56,000–64,000 tokens of context to spare. Thanks to hybrid attention, the memory cost of extended context is minimal — an 8K context adds only about 0.5GB of cache, and 32K adds just around 2GB.

Hardware Recommendations by VRAM Tier

• 12GB GPU: Ornith needs CPU offloading; Qwen needs more aggressive low-quality quantization
• 16GB GPU: Qwen is noticeably more comfortable
• 24GB GPU (RTX 3090/4090 and similar mainstream high-end cards): Both are usable, but Qwen fits more easily
• 32GB+ GPU: Both can run Q6/Q8 high-quality quantization with longer context windows

Both models are well-supported by llama.cpp, Ollama, and LM Studio, and both support MTP (multi-token prediction) speculative decoding for speed boosts.

Token Economics: The Hidden Cost Most People Ignore

Every token generated costs time, and if you're paying in a production workflow, it costs money too. A model that scores higher on benchmarks but takes three times as long isn't necessarily the better practical choice.

Qwen 3.8 has a reputation for over-thinking — in Artificial Analysis evaluations it generated around 160 million output tokens, versus a median of 43 million for open-weight models of comparable size. That's nearly 4x the verbosity. More output means more thorough reasoning (which partly explains its high accuracy), but it also means longer real-world wait times per response.

Ornith, meanwhile, consumes 20–40% more tokens per task, with some of that spent on outputs that were ultimately broken — plus the need for multiple corrective iterations, each of which is an additional cost.

The metric that actually matters isn't raw tokens/sec — it's cost per correct answer. By that measure: Qwen's verbose single responses are offset by its strong one-shot reliability (usually no multi-turn correction needed); Ornith's faster raw speed is offset by its need for more iterations.

Which Should You Choose: Ornith 1.5 or Qwen 3.8?

Choose Qwen 3.8 27B if:

• Reliability and autonomy are paramount, especially if you plan to plug it into a coding agent and let it work unsupervised
• You want performance claims backed by independent validation
• You're working with 16–24GB VRAM and want comfortable fit with a mature tooling ecosystem

Choose Ornith 1.5 35B if:

• You specifically need the MIT license for a commercial project
• You regularly work with very long context conversations and have the VRAM headroom (the long-context speed advantage is real)
• You're interested in the "self-improvement" training methodology and don't mind spending time on guided iteration

It's worth emphasizing: Ornith is barely a week old, and its headline claims are still almost entirely vendor-reported, with independent validation scarce. That doesn't mean it's a bad model — testing shows genuine advantages in long-context speed and output quality on tasks it completes successfully. But in this space, trust is earned through time and independent verification, and Qwen has traveled further down that road.

Both models also have headroom for further speed improvements — MTP speculative decoding and Qwen's NVFP quantization targeting Blackwell GPUs are both in progress. Revisit this comparison in a few weeks and the results may well look different again.