GGUF files • Base model • Methodology • Fine print

Qwen3.8-27B-noslop

Qwen3.8-27B with the machine-generated house style trained out of its weights. No more tapestries, no more Elara in Oakhaven, no more "Here is a step-by-step guide", and far fewer em dashes. Same 27B brain, same vision tower, same chat template, same MTP head. Swap the weights and keep your stack.

You know the voice. A testament is borne. Knuckles go white. Something hangs in the air, thick as ozone. Every answer opens with an announcement and closes with a summary, and between the clauses sits the punctuation mark that gave the whole genre away. Qwen3.8-27B-noslop was built to put that voice down, and the behavior lives in the model, not in a prompt or a filter.

Highlights

• -42% slop score on held-out writing prompts (0.497 to 0.289), measured with a purpose-built detector of more than 100 hand-weighted patterns.
• -73% em dashes (62 to 17 across 288 sampled responses) and -63% responses that use a dash as punctuation (82 to 30).
• Capability intact. Hidden-test pass rates in two real coding agents, pi and Claude Code, are identical to an identically quantized base model.
• Drop-in. Same architecture, tokenizer, chat template, vision tower and multi-token-prediction head. Works with transformers, vLLM and llama.cpp, with speculative decoding preserved.
• Honestly evaluated. The released checkpoint was chosen on prompts the optimizer never saw, from eight finalists, with sampling. Limitations are listed below, not buried.

Results

Coding agents: same ability

How the released checkpoint was picked

The search produced a Pareto front of eight candidates. Each was exported and re-tested on the untouched test split with sampling, and trial 28 had the lowest slop score by a clear margin.

Model details

Family

Quick start

from transformers import AutoModelForImageTextToText, AutoTokenizer

name = "RefinedNeuro/Qwen3.8-27b-noslop"
tok = AutoTokenizer.from_pretrained(name)
model = AutoModelForImageTextToText.from_pretrained(name, torch_dtype="auto", device_map="auto")

msgs = [{"role": "user", "content": "Write the opening scene of a mystery set in a lighthouse during a storm."}]
text = tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True, enable_thinking=False)
out = model.generate(**tok(text, return_tensors="pt").to(model.device), max_new_tokens=400, do_sample=True, temperature=0.7, top_p=0.8, top_k=20)
print(tok.decode(out[0], skip_special_tokens=True))

# vLLM and SGLang: follow the Qwen3.8-27B recipe and replace the model name
# https://recipes.vllm.ai/Qwen/Qwen3.8-27B

# llama.cpp, with the GGUF repo (MTP speculative decoding)
llama-server -m Qwen3.8-27B-noslop-Q4_K_M.gguf --spec-type draft-mtp -ngl 999 --flash-attn on

Recommended sampling (the values we evaluated with, non-thinking mode): temperature=0.7, top_p=0.8, top_k=20. Use the same serving setup you use for Qwen3.8-27B; everything else in the base model card applies.

Honest fine print

We would rather you hear it from us:

• Em dashes are reduced, not removed. Roughly three quarters are gone on writing prompts. No token ban or sampler trick is applied, so some remain, and the model sometimes substitutes a spaced hyphen.
• The dash reduction is a writing-mode effect. In coding-agent sessions (long system prompts, tool use, summary-style replies) final messages still contained an em or en dash in roughly 85 to 90 percent of runs, the same as the base.
• Slop is reduced, not abolished. Stock names such as Elias or Oakhaven and phrases like "Here is a practical step-by-step guide" still appear, less often.
• One agent quirk. In 3 of 24 runs with the pi coding agent (Q2_K_XL), the model kept re-verifying finished work until the time limit. The matched base never did. Suggestive, not statistically established, and absent with Claude Code.
• Responses are about 7 percent shorter on average. Markdown formatting is unchanged, on purpose.
• The slop score comes from our own lexicon-based scorer, a proxy for taste, not taste.

---

Methodology (the long version)

1. Goal and definition of slop

The target was a model whose final answers are free of the recognizable "AI house style" while keeping the original model's capabilities. We defined slop operationally, as things a scorer can count:

• Hard failures (severity 1.0): em dash (U+2014) and its look-alikes (U+2015, U+2E3A, U+2E3B, small and vertical em dashes, —), an en dash used as a dash (digit ranges are exempt), a spaced en dash, a double hyphen between words, and a spaced hyphen used as a dash (list bullets and compounds are exempt). A model that stops writing em dashes and starts writing " - " gets no credit.
• Soft penalties: roughly 100 hand-weighted regular-expression entries covering AI vocabulary (delve, tapestry, testament, symphony of, ...), transition tics (moreover, in conclusion), assistant framing ("Here is a step-by-step guide", "great question", "I hope this helps", "one of the most ..."), fiction clichés (shivers down the spine, "couldn't help but", air thick with, orbs, ozone, body-language reflexes such as knuckles white and held breath), stock character and place names (Elara, Thorne, Elias, Silas, Vance, Aethel*, Oakhaven), rhetorical templates ("not just X but Y", "It isn't X, it's Y", trailing participial clauses) and emoji. Repeated hits count with diminishing returns. The per-response soft score is S = sum of weights, and severity is 1 - exp(-S / 1.2).
• Guards that deny credit for evasion: empty or very short output, responses much shorter than the original model's answer to the same prompt, repetitive n-grams (distinct-3-gram ratio), non-Latin drift, and responses that ask the user for input instead of doing the task.
• Deliberately not slop: Markdown formatting. Headers, bold text and lists are left alone.

The lexicon was iterated by reading hundreds of real base-model outputs and adding entries for what Qwen3.8-27B actually does, with unit tests (21 passing) for the scorer.

2. Prompts

639 hand-written prompts in 18 categories: fiction, roleplay, essay, explain, advice, work email, marketing, technical, casual, rewrite, poetry, opinion, dialogue, speech, review, social, travel and food, humor. They were split per category with a fixed seed into 351 train, 144 eval and 144 test. The test split was never used for any optimization decision. A separate set of 62 hand-written capability prompts (math, facts, code, strict formatting, logic) supports the divergence term.

3. Method: Arbitrary-Rank Ablation with Heretic

We used Heretic (master branch, 2.0.0.dev0) with its Arbitrary-Rank Ablation (ARA) modifier. ARA captures, for every targeted module, the input and output at the last prompt token for a "good" and a "bad" set of prompts, then fits a rank-50 LoRA per module (L-BFGS, row magnitudes preserved) that

1. keeps outputs on the good set unchanged,
2. pulls outputs on the bad set toward the nearest neighbours of the original good outputs, and
3. pushes them away from the original bad outputs ("overcorrection").

The contrast. Both sets use the same 351 training prompts. They differ only in the system prompt: the good set uses a plain-writer system prompt, the bad set uses an exaggerated slop-inducing system prompt. We compared this explicit contrast with a milder one (default assistant prompt as the bad side) on a 9B stand-in model with 24 trials each, and the explicit contrast gave clearly better trade-offs, so it was used for 27B.

Three jointly optimized objectives (each a separate Optuna objective, multi-objective TPE):

1. mean slop severity of generated answers on the eval prompts (our scorer),
2. the fraction of answers containing a hard-banned dash,
3. a multi-token KL divergence (32 tokens) to the original model on the capability prompts, so capability damage is penalized.

Searched parameters per trial: start layer, end layer, preserve-good weight, steer-bad weight, overcorrect weight, neighbour count. Search model: 4-bit (bitsandbytes) on one RTX 3090 24 GB, ~3.5 minutes per trial, 80 trials (20 random startup), seed 7. The reasoning part of the model was never targeted or measured; answers were generated with thinking disabled.

4. Selection: held-out, sampled, not the optimizer's own score

The optimizer's Pareto front (eight candidates) was exported as adapters and each was evaluated on the untouched test split, 144 prompts x 2 samples at temperature 0.7 (top-p 0.8, top-k 20), 300 new tokens, with a neutral system prompt. We found that the optimizer's greedy-decoding numbers overstate held-out gains, which is why the final choice was made on this sampled test. Held-out results (288 samples each; "too short" guard excluded, because it fires on legitimately short answers):

Selected trial 28: start layer 7, end layer 63, preserve-good weight 0.513, steer-bad weight 0.001, overcorrect weight 0.980, 5 neighbours. On the optimizer's own 96-prompt eval set (greedy) it reached slop 0.248 against 0.436 for the base, with 4.2 percent of responses containing a dash against 18.75 percent for the base, at KL 0.066. Trial 60 is a close runner-up if fewer em dashes matter more than overall slop.

5. Merge

The rank-50 adapter was merged shard by shard into the original bf16 safetensors on CPU (no full-model load), producing this repository: 18 shards, same names and configuration as the base. The 15 mtp.* tensors of the multi-token-prediction head are untouched; we verified end to end that the merged model converts to GGUF, keeps its nextn tensors, and serves with llama-server --spec-type draft-mtp with healthy draft acceptance (47.0 percent on the 27B Q4_K_M). On a 9B stand-in with the same architecture, acceptance was 40.5 percent before and 41.2 percent after merging, i.e. unchanged.

6. Quantizations

See the GGUF repository: Q8_0, Q4_K_M, Q3_K_M, Q2_K_M, plus Q3_K_XL and Q2_K_XL that apply Unsloth's per-tensor type maps to this model, all with an importance matrix computed on this model.

7. Agent testing

We ran the Q2_K_XL quantization (and a base model built with the identical recipe, so only the weights differ) inside two real coding agents, pi and Claude Code, through a local llama-server. Six hand-written tasks with hidden tests (bug fix, write a cache class, write tests that must kill 3 of 4 mutants, write a README and docstrings, extend a CLI, explain code and find a bug), four runs per task, 24 runs per cell. Pass rates were identical (pi 23/24 and 23/24, Claude Code 22/24 and 22/24). The caveats listed in the fine print above (dashes persist in agent mode, one looping failure mode with pi) come from this test.

8. Limitations and open work

• Dashes are reduced, not eliminated, and not by a hard guarantee. A sampler-level ban would be a separate decision.
• Gains are largest on prose-style writing. Agentic and long-system-prompt settings were outside the tuning distribution.
• Thinking-mode text was not optimized and not evaluated.
• The scorer is a hand-built proxy and mostly blind to slop in technical text and poetry.
• Evaluation numbers come from one search, one seed and a single held-out split; treat small differences as noise.
• A second round with agent-style prompts in the contrast set, and a scorer tuned to the remaining tells, are the obvious next steps.

Acknowledgements

Built on Qwen3.8-27B by the Qwen team (Apache-2.0) and the Heretic project by p-e-w. This model is not endorsed by either.

Citation

@misc{qwen38_27b_noslop,
  title  = {Qwen3.8-27B-noslop: removing the AI house style with Arbitrary-Rank Ablation},
  author = {RefinedNeuro},
  year   = {2026},
  url    = {https://huggingface.co/RefinedNeuro/Qwen3.8-27b-noslop}
}

Please also cite Qwen3.8 and Heretic.