The fast builds of Qwen 3.6 on Apple Silicon ship a multi-token-prediction head, a small extra network that drafts the next few tokens so the model can verify several at once instead of generating them one at a time. The build I actually run does not have it. It is an abliterated 6-bit quant, and the MTP tensors were dropped when it was made. So my private model was the slow one, and the builds that were fast were not the model I wanted.

Here are the numbers I wanted when I was searching. The base model decodes at 75.7 tok/s. With the MTP head grafted back on and the draft depth tuned, it decodes at 112.0 tok/s. That is 1.48x on an M4 Max, and it stays lossless. The model checks every token itself. It cost one 555MB file and no retraining.

The draft head only proposes. The model still decides every token.

Why the graft is even possible

The MTP head is a separable sidecar, not woven into the body of the model. In an MLX build it is a single mtp.safetensors file, and every tensor in it sits under an mtp. prefix, so nothing in it collides with a weight in the base model. The other half is that the body and the sidecar have to agree on their quantization. The abliterated build I run and the MTP-optimized build I took the sidecar from are both 6-bit at group size 64. Same layout, so the head reads the body's hidden states the way it expects to. Copy the file in, tell the runtime it is there, and the head has a body to draft for.

The measurement

mtplx tune runs the model with no drafting, then at draft depths 1, 2 and 3, and reports decode speed and how often the drafts get accepted. On this machine depth 2 won: 112.0 tok/s against the 75.7 tok/s baseline, with the head's first guess accepted about 84% of the time. Depths 1 and 3 were a little slower. A grafted head that was a bad fit for the abliterated body would show up here as a low acceptance rate and no real speedup. 84% says the abliteration barely moved the hidden states the head was trained to read.

Why it is lossless

This is the part that is easy to distrust. Speculative decoding does not approximate the model or trade quality for speed. The head drafts a few tokens, the full model runs once and checks them, and any token that does not match what the model would have sampled gets thrown out. You get output from exactly the base model's own distribution, in fewer forward passes. The abliterated body is still the thing deciding every token, so the output is its output. The speedup is real and the quality question does not apply.

The recipe

The whole thing is a file copy and four small edits. No training, no conversion of the body.

# 1. new model dir, symlink the abliterated body into it
#    (shards, index, tokenizer, configs)
# 2. copy a compatible int4 / group-size-64 mtp.safetensors
#    from an MTPLX build of the same base model
# 3. merge the mtp quantization + policy keys into config.json
# 4. copy mtplx_runtime.json, relabel it for this model

mtplx inspect ./my-model    # can_run: true
mtplx tune   ./my-model     # picks the depth, here depth 2

The runtime that makes MTP work on Apple Silicon is MTPLX. None of this is new. Other people already ship models that keep or graft the head, huihui-ai and Shiftedx among them, and the technique has been written up on other hardware. What I had not found was a clean number for this exact graft on an M4 Max, so that is what this is.

The point

This is the same 128GB Mac that panicked three times trying to run a model too big for it. This was the opposite problem. The model fit fine, it was just slower than it needed to be, and the fix was a 555MB file I already had on disk for a different build. The speedup was sitting there the whole time. I ran the slow build for longer than I should have before I thought to check whether the head was separable and the quantization lined up.