Workstream 1 In progress
Domain-specific distillation
Instead of making a small model a little better at everything, take trajectories from a much larger open-source teacher that excels in one domain, and train them into a ~27B student. Qwen's 27B-class models are already unprecedented for their size. A specialist trained this way inherits the teacher's behavior on its domain.
The practical result: you keep a shelf of specialists on your SSD and load the right one per project, instead of needing around 500 GB of VRAM for a generalist whose relevant parameters are a small fraction of the whole.
One generalist
A frontier-scale generalist needs around 500 GB of memory. One RTX 5090 has 32 GB. It doesn't fit, and most of it would sit idle on any one project anyway.
A shelf of specialists
Distill what the big model does well, one domain at a time, into 27B students. Each one is a file on your SSD.
Load the one you need
A 27B specialist at Q4_K_M is about 17 GB. It fits on one GPU with room left for context.
A 500 GB generalist model overflows a single RTX 5090, which has 32 GB of memory. It splits into a shelf of small specialist models stored on an SSD: a Swift and Apple-platform specialist, in progress, and further domains that are planned. The Swift specialist, about 17 GB at Q4_K_M, loads onto the GPU and fits with room to spare.
First release: a Swift and Apple-platform specialist
Small models still fall short on domain-specific programming like Swift. The first specialist is distilled from teacher trajectories from Kimi K3 and GLM 5.3 class models, aimed squarely at Swift, SwiftUI, and Apple's frameworks. I'm building it either way.
Workstream 2 Shipping results
Chain-of-thought efficiency
Qwen base models are strong partly because they think for a very long time and second-guess themselves. That's fine for a single benchmark question. In an agent loop that calls the model a hundred times, it's the difference between a task that finishes and one that times out.
Fine-tuning on teacher reasoning trajectories tightens it. The model may give up a little on benchmarks versus the base, and become far more usable in agentic harnesses. I think that's the right trade for anyone who actually runs these models.
Thinking on the same long code task, measured
Path shapes are an illustration of the behavior, not real model output. The numbers are measured: Case Study B on the Qwopus 3.8 Flash model card, one reported workload. It is not a general ratio.
Two reasoning traces from the same start to the same answer. The base model's path wanders, loops back, and second-guesses before arriving. The tuned model's path runs almost straight. On one measured long code task, the base model thought for 98,452 characters over 15.5 minutes and was cut off at its token limit; Qwopus 3.8 Flash thought for 2,959 characters over 21 seconds and finished.
Result: Qwopus 3.8 27B Flash
Collaboration, led by Jackrong. My role: testing and evaluation.
Qwen 3.8 27B, fine-tuned on the best 10% of about 1.5 million teacher examples, then reinforced with NeMo-RL and GSPO. Measured against the base on the same Q5_K_M + MTP setup:
| Measure | Flash | Qwen 3.8 base | Change |
|---|---|---|---|
| Decode throughput, math + physics + chemistry | 9.35 tok/s | 8.28 tok/s | +12.8% |
| MTP draft acceptance (weighted) | 80.7% | 66.1% | +14.6 pts |
| Total output, characters | 7,949,546 | 8,824,213 | −9.9% |
| MMLU-Pro mixed set, 2,500 questions | 91.28% | 92.73% | −1.45 pts |
The length change isn't uniform suppression. P95 output length fell 13 to 40% by subject while median length rose in all three. The model stopped spiraling on hard questions without getting lazy on normal ones. On a held-out battery of 14 agentic software tasks with hidden tests and no partial credit, it passed 13 in 26 minutes on one RTX 5090.
Source: the Qwopus 3.8 Flash model card, author-provided local results. The MMLU-Pro drop is the price, and it's published alongside the gains.
Case study First author
Fusion: fixing a model by subtraction
The problem. A heavy code curriculum broke chain-of-thought in the Qwopus Coder branch. It looped, ran away while thinking, and got bad enough that thinking had to be switched off.
The insight. Coder was a downstream finetune of Qwopus v2. So the difference between their weights is a clean task vector: everything the code training added, isolated.
The method. Add that vector back to the stable reasoning parent, a little at a time: a small share in the early layers, rising with depth. Embeddings, lm_head, norms, and the MTP heads are taken unchanged from v2. Try it:
W(41) =V2 +0.349 ·(Coder − V2)
v2 (stable reasoning) 65.1% Coder 34.9%
Each layer keeps most of the stable reasoning model (v2) and takes a share of the coder's difference from it. Written another way, each layer is (1 − α)·V2 + α·Coder, which is what the bar shows. The share rises with depth, from 12% in the first layer to 48% in the last, so the early layers stay closest to the stable reasoning parent. Embeddings, the output head, norms, and the MTP heads are copied from v2 untouched.
What didn't work. Two alternatives, DARE-TIES and a frankenmerge, both underperformed on the same SWE slice. Both ablations are published on the model card.
The result, at Q4_K_M: HumanEval 94.5%, MBPP 87.9%, GSM8K 95.0%. Clean termination across temperature sweeps, stable 60k-context needle tests, and about 100 tokens per second on a single RTX 5090 with MTP speculative decoding.
What compounds: curated trajectories
The most useful finding so far isn't a model, it's a dataset property. Curated trajectory data keeps paying. As base-model intelligence density rises, the same datasets keep lifting each new generation: much of the Qwopus 3.8 work reuses curated 3.6 trajectory sets against the new Qwen 3.8 base, and the uplift carries across.
That changes the economics for a one-person lab. Careful data curation is the asset. When a stronger base model ships, the curated data is already waiting for it.
Where it runs
All of this comes out of two devices: one NVIDIA RTX 5090 and one NVIDIA GB10, paid for out of my own pocket. Since May 2026 the GB10 has carried most of the compute for the Qwopus line.