Qwen3.8-27B vs Ornith-1.5-9B and NeoHorse-1-9B on a 16GB RTX 5060 Ti

The most common upgrade question on a 16GB card is whether to step up from a 9B model to something in the 27B class. The 9B is fast and small, with gigabytes to spare on the card; the 27B fills the card, keeps pace with a 9B in decoding only thanks to its speculative head, and promises better answers. I measured the dense Qwen3.8-27B in its GSQ-RCO build against two of the strongest 9B coding models I have tested, Ornith-1.5-9B and NeoHorse-1-9B, on the same fifty programming problems, the same five agentic projects, the same false-premise questions and the same latency probes, on my RTX 5060 Ti with every flag pinned. Whether the 27B is worth it comes down mostly to one switch, reasoning, and to one property pass rates don't show: how often a model claims success it hasn't earned. Below are the results, then the procedure to reproduce the comparison on your own card and your own problems, because the method generalises to any pair of model sizes.

The three contenders on the card

Qwen3.8-27B is the dense model Alibaba published on Hugging Face in August 2026 under Apache 2.0. The GSQ-RCO build at about 3.5 bits includes a multi-token prediction head; with it the model decodes code at about 57 tokens per second and loads a 131,072-token context in 15,450 MiB. Ornith-1.5-9B and NeoHorse-1-9B run at 8-bit, decode at about 44 tokens per second and take roughly 8.7 GB at a 32K context, leaving seven gigabytes free.

So, thanks to its speculative head, the 27B isn't slower than the 9B models in raw decoding on this card. Where it falls behind is what it does with that speed when it thinks, and that's where the comparison gets interesting.

Round one: coding without reasoning

Fifty Python problems with 560 executable assertions, each problem counted as solved only when every assertion passes. Reasoning off, temperature zero, two minutes per problem.

The 27B solved 34. Ornith-1.5-9B solved 8, NeoHorse-1-9B 8. Against each 9B the 27B won 26 problems and lost none. No other result in the campaign is as solid: they survive the correction for sixty comparisons with a p-value indistinguishable from zero.

The problems the 27B won span most of the bank. Twenty-two of them were the same against both 9B models: text decoding with mixed encodings, currency sums without floating-point drift, an Italian-aware slug generator, resource allocation, euro formatting, semantic version comparison, free calendar slots, topological ordering, a token bucket, an expression calculator, bracket validation, IP allow-lists, JSON pointers, URL normalization, HTTP range parsing, pagination, flattening, Roman numerals, bit counting, human duration parsing, session grouping and a path join that refuses traversal. Without thinking, the 9B models handle the easiest sixth of this bank; the 27B handles two thirds.

Speed was not a factor in this round. The 27B solved 22 of its problems in under ten seconds and all 34 in under thirty.

To have a size comparison like this run on your own code, my hub on AI infrastructure for companies explains how I approach self-hosted model selection.

Round two: coding with reasoning on

Same problems, reasoning on, five minutes of usable time and a ten-minute cap.

The gap closed. Within five minutes the 27B solved 12, Ornith-1.5-9B 10 and NeoHorse-1-9B 18. Against Ornith the 27B won 7 and lost 5; against NeoHorse it won 3 and lost 9. Neither difference is confirmed by the paired test. Within ten minutes the counts were 22, 12 and 20.

The reason is the same one that reverses the 27B's ranking against the 35B mixture of experts: all of the 27B's failures with reasoning on were answers still being written at the cap. Its thinking is long and dense, typically more than ten thousand tokens per coding problem, and at 44 tokens per second that doesn't fit into five minutes. The 9B models think for fewer tokens and finish more often, but what they finish is less often right.

With reasoning off the 27B solves four times what the 9B models solve. With reasoning on, on this card, it becomes their equal, not because it got worse but because it ran out of time.

The time limit is the variable that decides this round, and the curve over time shows it plainly. At two minutes, the three models had solved 6, 5 and 7 problems; at five minutes 12, 10 and 18; at ten minutes 22, 12 and 20. The 27B is the only one still climbing steeply at the end.

Round three: agentic bug fixes

Five small broken projects, each with a bug report, a visible test suite and file and shell tools; three runs each, reasoning on. A hidden oracle the model never sees compares each fix with a reference on random inputs.

The 27B delivered 15 correct fixes in 15 runs and no illusory ones. Ornith-1.5-9B delivered 5 correct, 7 illusory and 3 failures; NeoHorse-1-9B 4 correct, 8 illusory and 3 failures.

An illusory fix makes the visible tests green and is still wrong. It's the most expensive outcome in agentic coding, because nothing in the agent's own report tells you. On these tasks, when a 9B model reported success, it was wrong more often than right: 7 times out of 12 for Ornith, 8 out of 12 for NeoHorse. When the 27B reported success, it was right every time.

It didn't even pay for that in time. On the three long tasks, the 27B's correct fixes took a median of 744 seconds and the 9B models' illusory fixes a median of 764. On envmerge, the one task all three solved in every run, the 9B models were not faster either: a median of 50 seconds for the 27B against 68 and 69, because the 27B with its speculative head writes at a comparable speed.

Round four: false premises and silent failures

Fourteen questions with a false premise built in. The 27B corrected 13 and never went along with a premise; Ornith corrected 10 and never went along; NeoHorse corrected 6 and went along 6 times.

On coding without reasoning, the silence of failures is the same for all three: when they fail, they almost always return complete, plausible code that only the tests reveal as wrong. That held for 16 of 16 failures of the 27B and 41 of 42 for each 9B. The difference is how many failures there are in the first place.

Round five: waiting time

Without reasoning all three answer in seconds and the 27B is as fast as the 9B models on chat and commands. With reasoning the 27B is the slowest by a wide margin: a median of 131 seconds across all probes, against 17.9 and 27.3 for the 9B models.

Round six: energy per solved task

The 27B is cheaper per solved task in three categories out of four, because it solves so many more problems for the energy it spends. The exception is coding with reasoning, where NeoHorse's short thoughts win.

The time curve, problem by problem

The benchmark above shows the five- and ten-minute points. The earlier points of the curve, solved problems against the time allowed per problem, show where each model's reasoning starts to pay off; without reasoning, all of the 27B's 34 arrived within thirty seconds.

Two things stand out. Without reasoning the 9B models have already solved everything they will solve within ten to thirty seconds; more time does not help them. With reasoning, nobody solves more than three problems in the first minute, and the 27B is still climbing steeply at ten minutes, which is why a twenty-minute follow-up took it to 33.

What the 9B models solve that the 27B does not

The paired lists are short, and they say a lot. With reasoning on within ten minutes, Ornith-1.5-9B solved three problems the 27B did not: invoice totals with line rounding, a token bucket rate limiter and JSON pointer resolution. NeoHorse-1-9B solved six: Unicode truncation on grapheme clusters, invoice totals, the token bucket, JSON pointers, bill splitting and a secure path join. These are problems where the 27B was still thinking at the cap, not problems it got wrong. Inside a fixed time, a small model that finishes beats a large one that doesn't.

Memory headroom and what it buys

On a 16GB card the 27B with its speculative head and a 131K context leaves about one gigabyte of VRAM. The 9B models at 8-bit and a 32K context leave about seven, enough to keep an embedding model, a speech-to-text model or a second small assistant resident alongside. They load 262,144 tokens of context, twice what the 27B holds. If your workflow needs a code model and a retrieval model on the same card, or prompts larger than 131K tokens, the 9B is the only option of the three that fits.

How to reproduce this comparison on your own card

The method is more durable than my numbers, because the models will change and your problems are not mine. Here is the procedure I used, reduced to what a single developer can run in an afternoon.

1. Start each model with identical, pinned flags and one slot.

   $ llama-server -m Qwen3.8-27B-GSQ-RCO-IQ3_S-mtp.gguf -ngl 99 -c 65536 -fa on --cache-type-k q4_0 --cache-type-v q4_0 -b 512 -ub 256 -np 1 --fit off --spec-type draft-mtp --port 8080

   Verify: curl -s http://127.0.0.1:8080/props reports the context you asked for.

2. Write problems with executable tests, and write the lazy solutions you expect. If a plausible wrong answer passes its tests, the problem is worthless.

3. Send every problem to every model with the same prompt, the same sampler and the same time limit, once with reasoning off and once with it on.

   $ curl -s --max-time 240 http://127.0.0.1:8080/v1/chat/completions -H 'Content-Type: application/json' -d '{"messages":[{"role":"user","content":"<problem text>"}],"temperature":0,"cache_prompt":false,"chat_template_kwargs":{"enable_thinking":false}}'

   Verify: every line in the output has a finish_reason; length means the answer was cut, not that it was fast.

4. Compare models with a paired test on the discordant problems only, and correct for the number of comparisons you ran.

   from math import comb
   
   def sign_test(wins_a, wins_b):
       # Exact sign test on the discordant pairs.
       n = wins_a + wins_b
       tail = sum(comb(n, i) for i in range(min(wins_a, wins_b) + 1)) / 2 ** n
       return min(1.0, 2 * tail)
   
   print(sign_test(26, 0))   # 27B against a 9B without reasoning
   print(sign_test(3, 9))    # 27B against NeoHorse with reasoning, 5 minutes

5. For agentic tasks, add a check the agent cannot see, and count illusory fixes separately from failures.

The second step is the one that decides whether the whole exercise is worth anything. A bank of problems that a lazy answer can pass will report that every model is good.

The decision in yes-or-no form

So, is the 27B worth the card?

Yes, if you use it the way this card allows: without reasoning for interactive coding, and with time to spare for agentic tasks. In those two modes it solved four times as many problems as the 9B models, a margin that needs no statistics. It solved four times as many problems without thinking and shipped no wrong fix in fifteen agentic runs.

No, if you want an interactive reasoning model. With thinking on, the 27B waits minutes on simple questions and solves no more than a good 9B within five minutes. For that job, a faster thinker serves better, and on a 16GB card the best one I have measured is the 35B mixture of experts, as the comparison between the 27B and the Ornith 35B shows.

The 9B models keep their place for what they do well: they leave gigabytes free on the card, load enormous contexts, and with reasoning on NeoHorse is a capable problem solver. The difference between the two 9B models is covered in Ornith-1.5-9B vs NeoHorse-1-9B, and the hidden checks that expose illusory fixes in how local LLMs fake a fix. The weights used here are on the official Qwen3.8-27B model card and the community GGUF repositories of the two 9B models.

Moving from 9B to 27B on a 16GB card buys you correctness and costs you the ability to think interactively. Which of the two you need more decides whether it's an upgrade, and the measurement that tells you is a paired comparison on your own problems, with reasoning stated, time limits stated and illusory fixes counted. If you want that comparison designed and run for your team's workload, you can describe the case in the free quote form: two minutes, and I tell you upfront whether it's something I can help with.