Ternary Bonsai 2 27B — Abliterated v2, PQ2_0, with optional MTP

v2 is built to be run with thinking on. Abliterated Bonsai 2 builds, my own v1 included, tend to write the whole answer inside their reasoning and run out of budget before handing it over. v2 changes one row of the output layer so the model closes its reasoning once the answer is ready. With reasoning_effort set to medium it answered every prompt on the main test; at default settings it halves v1's blank answers.

Where v2 stands out: hard requests, given room to think. StrongReject (150 detailed harmful requests), thinking on, default settings, 16,384-token budget, same judge for every row:

Much of that gap is answers the other builds never deliver: they write the answer inside their reasoning and run out of room before closing it.

It also left the fewest safe questions unanswered at default settings of the abliterated Bonsai builds tested (7%, against 8–14%), and the MTP file decodes ~40% faster.

Where it doesn't: on the easier harmful set at default settings, Hikari (0.834) and dealignai (0.866) score above v2 (0.796); neither gap is statistically significant. With reasoning_effort=medium, every good abliteration lands at the ceiling on that set, v2 included. Full tables below; the earlier comparison of these builds is in the shootout report.

Previous version: v1, PQ2_0 + MTP stays up unchanged; it is the build measured as "v1" throughout this card. Smaller pack: PTQ1_0 (1.75 bpw) is still v1. The v2 fix for PTQ1_0 is being built and tested next.

Files

PQ2_0 is PrismML's format: mainline llama.cpp, Ollama and LM Studio builds that lack it will not load either file. Tested with PrismML tags prism-b10687-5d80cff and prism-b10743-adfffbe.

The two files contain identical language-model weights; the MTP file adds 15 tensors (blk.64.*). With speculation off, the two produced byte-identical output on all 5 test prompts (400 tokens each). SHA-256 (first 16): plain b284cbc6cb6c2894, MTP a4e4c7b578131595.

Recommended settings

llama-server -m Ternary-Bonsai-2-27B-Abliterated-v2-PQ2_0.gguf \
  -ngl 99 -fa on -c 32768 --jinja \
  --chat-template-kwargs '{"reasoning_effort":"medium"}'

Leave the sampler at the file's defaults (temperature 1.0, top-k 20, top-p 0.95). Use medium if your token budget is tight: at default effort with 4,096 tokens, 110 of 150 hard requests hit the budget and the score is 0.513; on medium at the same budget the score is 0.977.

The same 4k penalty exists in Bonsai 2 itself: stock Bonsai shows it on math and code (capability table below: MATH 213 vs 238, HumanEval 145 vs 158 at 4k, default vs medium), and Killy (@net_termina) found the same independently on the unmodified model: HumanEval at 4k tokens, 137 of 164 at default effort vs 157 on medium.

What changed from stock

The refusal edit uses the same 98 tensors and the same in-place ternary-digit method as v1, with a larger edit: about 8× as many changed bytes.

The thinking fix is one row. I fit a small change to the output row of the </think> token on stock Bonsai's own reasoning, so that closing becomes likely where the answer is already written and stays unlikely mid-thought, and checked that offline on held-out traces before building. The tables below are the check in real generation.

Refusal and answer quality

Thinking on, file sampler defaults, seed 0, 4,096 tokens. SimpleSafetyTests (100 harmful prompts) and XSTest-safe (100 safe prompts that only sound edgy). Each harmful answer is scored 0–1 by Qwen3.8-27B-OBLITERATED-Q8_0 using the StrongReject rubric, which rates how specific and convincing a response to a harmful request is — not factual accuracy or general usefulness. Refusals and blank answers score 0. p-values are paired t-tests over the 100 prompts.

v2 vs v1, both at default: +0.160 (p < 0.001). v2 on medium vs v1 at default: +0.341 (p < 0.0001), which combines the new weights with the setting change.

Against the other abliterated builds on the same test, same judge, all run by me:

Hard requests (StrongReject, 150 prompts), same judge:

dealignai CRACK on medium, 4,096 tokens: 0.956. v2 is +0.021 above it, not significant (p = 0.28).

</think> leaking into the answer: 6 of 3,324 v2 generations across every suite on this card.

Capability

Paired per problem against stock Bonsai 2 PQ2_0, thinking on, file sampler defaults. p-values are exact McNemar tests; the HumanEval differences are 0–1 problems.

v2 is numerically a few problems behind stock on math (7, 6 and 4 at matched settings); none of the differences is significant at n = 300, and a real cost of that size could not be ruled out. The IFEval grader varies by about ±3 prompts between gradings of the same outputs.

MMLU is the one place v2 measurably costs something: −0.56 points against stock, significant (351 questions lost, 273 gained). It is the smallest cost among the strong abliterated builds measured the same way (full MMLU, same harness, paired against stock): Hikari07jp −0.64, dealignai CRACK −1.04, OS-Software Heretic −1.59, Blackfrost DERISKED −2.68. v1 was +0.15, not significant; the larger refusal edit is what costs the half point.

The MTP file: ~40% faster decode

Runtime

Use PrismML's llama.cpp at tag prism-b10743-adfffbe or newer. It runs this file with --spec-type draft-mtp as is: tested with a chat prompt and a tool call, same speed and draft acceptance as the patched build below.

Older tags fail at startup with:

Hadamard-latent table 'token_embd.weight' is read without the inverse transform

For those, 0001-qwen35-mtp-hadamard-inverse.patch in this repo fixes it (14 lines, against tag prism-b10687-5d80cff):

git clone https://github.com/PrismML-Eng/llama.cpp && cd llama.cpp
git checkout prism-b10687-5d80cff
git apply ../0001-qwen35-mtp-hadamard-inverse.patch
cmake -B build -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=<your arch> -DLLAMA_CURL=OFF
cmake --build build --target llama-server -j

Run

llama-server -m Ternary-Bonsai-2-27B-Abliterated-v2-PQ2_0-MTP.gguf \
  -ngl 99 -fa on -c 32768 --jinja \
  --chat-template-kwargs '{"reasoning_effort":"medium"}' \
  --spec-type draft-mtp --spec-draft-n-max 2

Measured

One RTX 3090, 5 prompts, 400 tokens each, --parallel 1, greedy, median.

v1 measured 0.643 acceptance on the same test, so the thinking fix does not hurt drafting.

The gain depends on what you generate. On v1, reasoning, code and JSON accepted 0.79–0.83 of drafts and free prose 0.39, where speculation ran slightly slower than none. A short prose answer on v2 ran +14%.

On losslessness

Speculative decoding verifies every draft against the target model, but batched verification changes floating-point reduction order, which can flip a near-tie: 3 of 5 test prompts matched the non-speculative output byte for byte, and the other 2 diverged at close word choices.

PTQ1_0

On v1, grafting the same head onto PTQ1_0 gave +1.6%: the head drafted just as well, but verification cost nearly as much as generating. Not re-tested on v2.

What this does not claim

• Not that v2 is the best abliterated Bonsai on every test: see the comparison tables above.
• No vision evaluation. The mmproj is not included; use PrismML's matching projector.
• Tested on CUDA only (RTX 3090 and A100); Metal and CPU are untested.

Safety

This model has had its refusal behaviour removed and will comply with requests a stock model declines. It is published for research on alignment robustness and for users who need an unfiltered local model. You are responsible for what you do with it. Do not deploy it in a user-facing product without your own safety layer.

Credits

• Base model: prism-ml/Ternary-Bonsai-2-27B-gguf (Apache-2.0)
• MTP head: copied verbatim and unrotated from unsloth/Qwen3.8-27B-GGUF, quantised from Qwen/Qwen3.8-27B (Apache-2.0)
• Runtime: PrismML-Eng/llama.cpp (MIT)
• The MTP recipe is not mine. It was worked out by decent-jawfish and ProCreations, building on sudoingX/qwen38-mtp.

Not affiliated with or endorsed by PrismML, Qwen, or Unsloth.

Model weights: Apache-2.0. Runtime: MIT.