A 9B Model Just Beat 35B Models at Coding. The Self-Improvement Method Behind It Is the Real Story.

There's a 9-billion-parameter model beating 35-billion-parameter models at coding.

Not on some made-up benchmark. On Terminal-Bench 2.1, SWE-Bench Verified, and NL2Repo — the ones people actually care about. A 9B dense model, running on a single GPU, outscoring Qwen3.5-35B and Gemma4-31B on real agentic coding tasks.

It's called Ornith-1.0, it was released two days ago, it's MIT licensed, and the Hacker News thread is a warzone.

The Numbers Are Absurd

Let me just lay them out, because they're worth staring at.

On Terminal-Bench 2.1 (Terminus-2), which tests whether a model can actually operate a terminal and complete real development tasks:

• Ornith-1.0-9B: 43.1
• Qwen3.5-35B: 41.4
• Gemma4-31B: 42.1

The 9B model — four times smaller — beats them both. On SWE-Bench Verified, Ornith-9B scores 69.4, compared to Qwen3.5-9B at 53.2 and Gemma4-12B at 44.2.

Then there's the 35B MoE version, which is where it gets genuinely ridiculous:

• Terminal-Bench 2.1: 64.2 (Qwen3.5-35B: 41.4, Qwen3.6-35B: 52.5)
• SWE-Bench Verified: 75.6 (Qwen3.6-35B: 73.4)
• NL2Repo: 34.6 (Qwen3.5-35B: 20.5)

And the flagship 397B MoE goes toe-to-toe with Claude Opus 4.7 on SWE-Bench Verified (82.4 vs 80.8) and beats it on SWE-Bench Pro (62.2 vs 51.6 for Qwen3.5-397B). GLM-5.2-744B still edges it on Terminal-Bench (81.0 vs 77.5), but for an MIT-licensed model with no regional restrictions? That's a foot in the door of the frontier.

But Here's What's Actually Interesting

The benchmarks are table stakes. Everyone benchmarks against Qwen now. The part that made me pay attention is the training method.

Ornith-1.0 calls itself "self-improving." That phrase gets thrown around so much in AI that it's basically lost all meaning — every startup that adds a feedback loop to their fine-tuning pipeline claims their model "improves itself." But Ornith's approach is different in a way that's worth understanding.

Most coding model fine-tuning works like this: you give the model a problem, it generates a solution, you check if the solution works, and you reinforce the good solutions. The model gets better at producing answers.

Ornith does something extra. It also learns to generate the scaffold — the problem decomposition, the test strategy, the search trajectory — that drives those solution rollouts. It's not just learning to write better code. It's learning to write better frameworks for writing code.

Think about what that means. When you give Ornith a coding task, it doesn't just pattern-match to a solution. It first generates its own internal scaffolding — breaking down the problem, deciding what to test, figuring out the search path — and then solves within that scaffold. By jointly optimizing the scaffold and the solution during RL training, the model discovers better strategies for how to approach problems, not just what the answer is.

This is a small but meaningful shift. Most models are trained to be better answer-generators. Ornith is trained to be a better problem-solver.

The Community Reaction: A Split Verdict

The HN thread has 261 points and 51 comments, and they fall into two camps.

Camp 1: "This is just a benchmaxxed Qwen fine-tune."

User S0y: "These are simply benchmaxxed versions of either Qwen or Gemma 4."

User v3ss0n, pulling no punches: "Self-Improving bullshit. It is just Qwen 3.5 finetune benchmaxxed. Nothing spectacular. Even fails at benchmarks. Long session tool calls sucks and hallucinate a lot with that too. Just use Qwen 3.6 and 3.5 122b."

There's also a mystery: Ornith mentions a 31B dense model variant in its README, but there are no benchmarks or weights for it anywhere. Multiple commenters flagged this. It's a weird gap in an otherwise detailed release.

Camp 2: "No, this actually works."

User Narew, who tested it on real C++ codebase work: "From what I personally tested Ornith-1.0 35B is slightly better than Qwen-3.6 35B. The part that I find interesting is that the model is way faster than Qwen3.6 35B. It seems Ornith produces a smaller chain of thought. On my test it can be 3 times faster to produce the answer."

User lhl (Eugene Yan, well-known in the ML infra space): "I've been testing Ornith-1.0 35B (my own FP8-block quant) and I like it. It runs at >200 tok/s with vLLM on an RTX PRO 6000, I've run >140M cached tokens of agentic coding work on it over the past few days... the good thing: it overthinks/doom-loop a lot less than Qwen 3.6."

User fareesh: "I've used a lot of local models and all of them felt like toys. This one actually felt useful."

And ricardobayes made a point I think is underappreciated: "This is the first Qwen fine-tune that is not immediately rejected by the local LLM community, and in some cases even being recommended."

That last one is significant. The local LLM community is brutal about fine-tunes. They've been burned by a hundred "we improved on Llama/Qwen" releases that fall apart the moment you use them for anything real. Getting genuine recommendations from that crowd is not nothing.

The Overthinking Problem

lhl's observation about doom-looping is the most interesting real-world signal in that thread.

If you've used any reasoning model for coding — Qwen, DeepSeek, GLM — you've probably experienced the doom loop. The model gets stuck in a chain of thought that goes in circles. It second-guesses itself, re-reads the problem, tries an approach, abandons it, tries another, comes back to the first one. Your token bill grows. The clock ticks. The answer doesn't come.

Ornith's approach to scaffold generation might be why it doom-loops less. If the model has a structured plan before it starts reasoning — a scaffold it generated and was trained on — it has a map. It knows where it's going. Qwen 3.6's reasoning is powerful but undirected. It explores broadly. Sometimes that breadth is exactly what you need. Sometimes it's a 2-minute thinking trace for a problem that should take 20 seconds.

This is the kind of thing benchmarks don't capture well. SWE-Bench measures "did you solve the issue?" It doesn't measure "how many tokens of circular reasoning did you burn getting there?" But in production, that second metric matters enormously. It's the difference between an agent that costs $0.02 per task and one that costs $0.50.

The "Self-Improving" Question

User LoveMortuus asked the obvious question: "Why don't these 'self-improving' ones eventually improve to the point of being better than the bleeding edge?"

The answer is that Ornith's "self-improving" is about the training process, not continuous runtime improvement. During RL training, the model learned to generate better scaffolds alongside better solutions. Once training is done and you download the weights, it's a fixed model. It doesn't keep getting smarter on your machine.

But the training method itself is a genuine advance. Most coding RL works on a single axis: did the solution pass the tests? Ornith adds a second axis: was the scaffold good? That dual optimization means the model is learning a meta-skill — how to structure problem-solving — not just memorizing more solution patterns.

The implication: future models trained this way could develop genuinely better reasoning strategies, not just better reasoning coverage. We might see smaller models that think more efficiently, not just bigger models that brute-force more.

User GenseeAI raised the governance angle: "Self-improving systems are exciting, but they also make provenance and governance much harder. Once agents can modify their own behavior over time, understanding why an agent behaved a certain way becomes increasingly important."

Fair point. But Ornith isn't there yet — it's a fixed model trained with a clever method. The governance concern becomes real when we start deploying models that adapt their scaffolding live, during inference. We're not there. But the arrow is pointing that way.

What This Means for You

Here's why I think Ornith matters beyond the benchmark drama.

For people running local models: The 9B variant runs on a single 80GB GPU. The GGUF quantized versions run on consumer hardware through Ollama or llama.cpp. If you've been waiting for a local coding model that doesn't immediately disappoint you, this is worth your evening.

For the open-source ecosystem: The gap between open and closed models in agentic coding has been the most painful one. GLM-5.2 and DeepSeek closed much of the general reasoning gap. But Terminal-Bench and SWE-Bench — the "can this thing actually write and debug real code in a real environment" benchmarks — have been dominated by Claude and GPT. Ornith-397B scoring 82.4 on SWE-Bench Verified puts it within striking distance of Claude Opus 4.7 (80.8). That's not parity, but it's in the conversation.

For the broader trajectory: The interesting play here isn't "we trained a bigger model." It's "we trained a smarter model with a better method." The scaffold-solution joint optimization is a proof of concept that meta-reasoning can be taught. If this technique gets adopted and refined by labs with more compute, the returns could compound. A 9B model beating a 35B model today might become a 3B model beating a 35B model tomorrow.

The Honest Caveats

I'd be dishonest if I didn't mention the skepticism. The HN thread has a lot of "benchmaxxed" accusations, and they're not entirely unfair. SWE-Bench in particular has a history of being gameable. The missing 31B weights are a yellow flag. And "deepreinforce-ai" is not a lab anyone had heard of before last week.

But here's the thing: multiple independent users in that thread tested the model on real work — real C++ codebases, real Go projects, real feature implementations — and came back with positive reports. Not "this is the second coming of Claude." Just "this works better than what I had before, and it overthinks less." That's a humble, credible endorsement.

And lhl running 140 million cached tokens of agentic coding on it over several days is not a casual test. That's someone putting real load on the model and liking what they see.

Where This Goes

The open-source AI story in 2026 has been the same story told in different ways: the gap is closing. GLM-5.2 tied GPT-5.5 on reasoning. DeepSeek's DSpark made inference 85% faster with software alone. Qwen AgentWorld showed language models could simulate physics. And now Ornith is showing that a clever training method can make a small model punch four weight classes above its size.

The frontier labs still have the lead. Claude Opus 4.8 scores 85 on Terminal-Bench to Ornith's 77.5. But the gap is measured in single-digit percentages now, not multiples. And the open models are free, MIT-licensed, run on your own hardware, and don't rate-limit you.

If you're building with AI agents — whether that's CopperRiver automating your workflow or your own custom pipeline — the message is the same: the open-source model you dismissed as "not good enough" six months ago might be worth another look. The ground is moving fast.

Ornith-1.0 is available on Hugging Face and GitHub under MIT license. The 9B dense variant fits on a single 80GB GPU. GGUF versions are available for local inference through Ollama or llama.cpp.

---

If this kind of open-source AI analysis is useful to you, CopperRiver runs these models locally on your Mac — browsing, coding, automating, all without API rate limits. Plans start at $9/mo.

---

Related Reading

• You're Spending 95% of Your RL Training Budget on Layers That Don't Matter
• Compounding Correctness: Why Spending More Tokens Now Actually Makes AI Better
• DeepSeek's DSpark Just Made AI 85% Faster — With Software, Not Silicon
• Qwen AgentWorld: The AI Model That Simulates Reality (And Beats GPT-5.4 Doing It)