Qwen3.8-27B GSQ-RCO vs Qwen3.8-27B IQ4_XS on a 16GB RTX 5060 Ti

When two quantizations of the same model are compared, the result most people expect is a ranking: the bigger file is smarter, the smaller one is faster, and you pick. On my 16GB RTX 5060 Ti the comparison between two builds of Qwen3.8-27B produced something less tidy that taught me more. The GSQ-RCO build, a non-uniform quantization at about 3.5 bits that ships with a multi-token prediction head, is faster, holds more context and, on every capability test I ran, is either indistinguishable from or ahead of the uniform IQ4_XS build. That sounds like a win, and it mostly is. The capability half of the claim, though, has a statistical problem, and this article is mostly about it: on the main test the two builds solved 34 and 33 problems out of fifty, and that result can't be read as "equivalent". Walking through why shows, better than anything else I know, what a quantization comparison can and can't prove with the samples one developer can afford.

The two builds and why they differ

Both files come from the same weights: Qwen3.8-27B, the dense model Alibaba released on Hugging Face in August 2026 under Apache 2.0. The IQ4_XS build is a uniform quantization from a well-known community packager, about 4.25 bits per weight, the same treatment for every layer. The GSQ-RCO build from ISTA-DASLab assigns different precision to different parts of the network, chosen by minimizing the divergence from the full model on calibration data, and it includes the model's multi-token prediction layer, which llama.cpp can use as a built-in draft for speculative decoding.

On my card that difference in packaging has three direct consequences, all measured:

• Context: with the MTP head active, the GSQ-RCO build loads with 131,072 tokens of context in 15,752 MiB; the IQ4_XS build loads with 65,536 tokens in 15,744 MiB.
• Speed: on fifty coding answers without reasoning, the GSQ-RCO build decoded at a median of 56.8 tokens per second, the IQ4_XS at 25.4.
• File size: the GSQ-RCO file is about 1.28 times smaller, and that's part of how both the head and the longer context fit.

Why did the speed double?

Most of it is the speculative decoding head; the smaller file adds about 15%. Comparing the two builds directly mixes the two causes: inside the same coding cells the ratio between them ranged from 1.8 to 2.2. To separate them I ran the same GSQ-RCO file with and without --spec-type draft-mtp, everything else pinned. With the head the median decode on code went from 29.3 to 56.8 tokens per second, a ratio of 1.94 over fifty problems; on sampled reasoning the ratio was 1.5 to 1.6. So the GSQ-RCO file without its head decodes at 29.3 against 25.4 for IQ4_XS, and the head does most of the work.

If you test prompts, the head has a price: at temperature zero only 7 of the 50 answers were identical with and without it, while the solved count stayed essentially the same (34 with, 33 without). Speculative decoding on this file is fast, not output-neutral.

To have quantizations for a deployment measured on your own workload, my hub on AI infrastructure for companies describes how I run these comparisons.

The capability result, and the problem with it

Fifty Python problems with 560 executable assertions, reasoning off, temperature zero, two minutes per problem. A problem counts as solved only when every assertion passes.

GSQ-RCO solved 34, IQ4_XS solved 33. On the same problems, GSQ-RCO solved 7 that IQ4_XS missed, IQ4_XS solved 6 that GSQ-RCO missed. The paired test on those 13 discordant problems gives p = 1.0. This comparison was declared in advance as one of the two main questions of the campaign, and its verdict is INCONCLUSIVE.

This is where people slip. INCONCLUSIVE says that this experiment can't tell; it says nothing about the two builds being equivalent. Every test has a minimum effect it can detect with reasonable probability, and for fifty paired items with this pattern of disagreement it's about 0.20, twenty percentage points. If the two builds truly differed by five or ten points, I would very likely have got this same result. To see a difference as small as the one observed here with 80% probability would take on the order of five thousand problems. Nobody writes that many on their own.

A test that can't see a difference below twenty points has not shown that there is no difference. It has shown that, if there is one, it's smaller than twenty points.

"Quantization doesn't cost intelligence" is one of the most repeated claims in local inference, and it's usually supported by exactly this kind of result: two scores close together on a small benchmark. The data backs something narrower, and it still helps: on this kind of task, the cheaper GSQ-RCO build doesn't lose a large amount of capability, and it might lose a small one that fifty problems can't see.

The other tests point the same way

Every other comparison between the two builds either favours GSQ-RCO or can't decide, and none favours IQ4_XS.

The pattern is consistent, but each row on its own is either underpowered or doesn't survive the correction for testing many pairs at once. The one row with p = 0.02 shows why the correction exists: run sixty exploratory comparisons and a few will cross 0.05 by chance; this one doesn't hold up.

On the agentic tasks the two builds differ in time, not in correctness. Both builds delivered correct fixes on almost every episode, but IQ4_XS took so long that only 4 of its 15 fixes arrived within the usable time, against 14 of 15 for GSQ-RCO. A slower file isn't a dumber file; on a small card it's a file that misses deadlines.

Reasoning makes the speed gap worse

With reasoning on, the slower file pays twice: it decodes at half the speed and it thinks for many tokens. On the fifty coding problems with a ten-minute cap, 36 IQ4_XS answers were still being written when the clock ran out, against 28 for GSQ-RCO. In a follow-up with a twenty-minute cap on the problems that had been cut, GSQ-RCO reached 33 of 50 and IQ4_XS 24 of 50. In that extended window GSQ-RCO delivered 7 wrong answers and IQ4_XS none; the faster build finished more problems and finished some of them wrong.

On waiting time the picture is mixed. With reasoning off, the median wait across eight probes of daily work was 5.9 seconds for GSQ-RCO and 8.7 for IQ4_XS. With reasoning on, GSQ-RCO waited longer, 131 seconds against 100, because it thought for more tokens on the probes it answered; one IQ4_XS probe timed out at 900 seconds and isn't in its median.

Energy per solved problem

Faster decoding means the card works for less time per answer. Without reasoning, a solved coding problem cost 1.1 Wh above idle on GSQ-RCO and 2.6 Wh on IQ4_XS. With reasoning, 62.6 Wh against 118 Wh. On agentic fixes, 30.3 Wh against 77.2 Wh. In money, each is a fraction of a cent at my electricity price; the ratio, about two to one, follows the speed.

What a non-uniform quantization changes on the card

A uniform quantization applies the same format to every weight matrix. A non-uniform one spends more bits where the network is sensitive and fewer where it isn't, using a calibration set to decide. The bet is that the sensitive parts are a minority, so the same quality can be reached with a smaller file, or more quality with the same file. On this model the bet paid in size: the GSQ-RCO file is about 1.28 times smaller than the uniform IQ4_XS while sitting at a nominally lower average precision.

Keep the calibration set in mind. A non-uniform quantization is optimized for the data it was calibrated on, and on very different data it may hold up well in some places and badly in others. My coding problems and agentic tasks are a reasonable proxy for what I use the model for, and on those it held up. On a domain far from typical calibration data, a language or a notation that barely shows up in the calibration, the only safe statement is that I have not measured it.

The context that the formula got wrong

The capacity gap between the two builds needs a separate note, because the planner and the card disagreed. A VRAM estimate based on the usual formula (weights, plus KV cache per token times context, plus compute buffers) predicted that the IQ4_XS build would stop at 32,768 tokens of context. Loading it showed 65,536 tokens fitting in 15,744 MiB. The estimate was conservative by a factor of two. The GSQ-RCO build, with its MTP head active, loaded at 131,072 tokens in 15,752 MiB.

Both numbers come from loading the model and answering a long prompt, not from the formula. On a 16GB card the loaded figure settles whether a whole module of code fits in one request. That's why I never trust a context figure I have not loaded myself.

Working the paired test by hand

The verdict on the main coding test is easy to reproduce, and once you have done it, INCONCLUSIVE stops looking mysterious. Only the problems on which the two builds disagree carry information about which one is better: 7 solved by GSQ-RCO alone, 6 by IQ4_XS alone. If the builds were equally capable, each discordant problem would go either way with probability one half, and the exact two-sided probability of a split at least as lopsided as 7 to 6 is the binomial tail:

from math import comb

def sign_test(wins_a, wins_b):
    # Exact two-sided sign test on the discordant pairs only.
    n = wins_a + wins_b
    k = min(wins_a, wins_b)
    tail = sum(comb(n, i) for i in range(k + 1)) / 2 ** n
    return min(1.0, 2 * tail)

print(sign_test(7, 6))    # 1.0: no evidence in either direction
print(sign_test(17, 2))   # 0.0007: the 27B against the MoE without reasoning

Feed the same function the comparison between this 27B and the 35B mixture of experts without reasoning, 17 discordant problems to 2, and it returns about 0.0007. The two numbers come from the same fifty problems and the same procedure, and they could not be more different. Put side by side, the two show what a paired test is for: it ignores everything both models got right or wrong together, and asks only whether the disagreements lean one way.

Problem by problem: the thirteen that decide nothing

The paired test says the main coding result is balanced, and the list of discordant problems shows it in detail. Without reasoning, GSQ-RCO alone solved seven: decoding text with mixed encodings, an Italian-aware slug generator, a small expression calculator, URL normalization, Roman numerals, session grouping and a secure path join. IQ4_XS alone solved six: Italian business days, ISO 8601 durations, a true Damerau distance, glob matching without fnmatch, text wrapping and an exact integer determinant. There is no theme in either list, no family of problems where one build systematically loses. When two quantizations of the same weights really are close, this is how it looks.

With reasoning on and a ten-minute cap, GSQ-RCO alone solved eleven problems and IQ4_XS alone two. Most of GSQ-RCO's extra wins are problems IQ4_XS didn't finish in time, which is the speed difference showing up as a capability difference.

The speed gain on its own

The measurement I learned most from takes the quantization out of the picture: the same GSQ-RCO file with and without its prediction head.

All fifty problems decoded faster with the head, with the 10th and 90th percentiles of the ratio at 1.82 and 2.07. The head costs 1,296 MiB of VRAM.

Waiting time, side by side

Without reasoning GSQ-RCO is faster on every probe, by up to a factor of two on the code review. With reasoning the two builds are close on short probes, because both think for thousands of tokens and the slower decoder of IQ4_XS is partly offset by shorter thoughts: on shell commands IQ4_XS generated a median of 5,234 tokens against 8,916. On the code review the IQ4_XS answers that completed took 355 seconds, and one exceeded the 900-second timeout. Three of its six code reviews without reasoning were also cut by the probe's own 1,200-token budget, so its 43-second median is over the three that finished.

The decision in yes-or-no form

The two nd cells on capability say that the measurement can't decide, in either direction.

So which build should you run?

On a 16GB card, the GSQ-RCO build with its MTP head. It's about twice as fast, holds twice the context, costs half the energy per solved task, and on no test did it lose to the uniform build. The capability question remains open at the level of a few percentage points, and I won't claim otherwise. If a difference of that size would change your decision, you will need an evaluation many times larger, on your own tasks, to find it.

I would still consider IQ4_XS in two situations. One: your engine can't use the MTP head, and then most of the speed advantage disappears. Two: you need bit-exact reproducibility of answers across server configurations, because speculative decoding changed 43 of 50 answers at temperature zero on this file.

How to read a quantization comparison like this one

The method carries over to other models, and I would keep it even if the models change next month. Compare the two builds on the same items, count the discordant pairs, use an exact paired test, report the minimum detectable effect next to the verdict, and correct for the number of comparisons you ran. A result like 34 against 33 is then reported for what it is: no difference large enough for this experiment to see. The same reasoning is behind the Ornith vs Qwable comparison, where two 9B agents tied, and behind the warnings in what llama.cpp benchmarks get wrong. The full head-to-head of the GSQ-RCO 27B against the 35B mixture of experts I also run is in Qwen3.8-27B vs Ornith-1.5-35B-A3B.

Two quantizations of the same model make a small, clean experiment, a good place to learn what a small experiment can't say. The GSQ-RCO build wins on speed, context and energy by margins no statistics are needed for; on capability it's tied within a resolution of twenty points, which is a statement about the test as much as about the models. To have the capability question answered at a resolution that fits your workload before you choose a build, you can describe the case in the free quote form: two minutes, and I tell you whether it's something I can help with.