Sign up

peculiar-ragdoll/Nail-Qwen3.6-35B-A3B-MLX-5bit

🤗 On Hugging Faceimage-text-to-textapache-2.036B params72 GBsafetensors✓ HF checksums availableupdated today
Magnet

Straight to the point

Nail dominates Qwen3.6-27b and its ThinkingCap fine-tune on time-to-answer while matching their accuracy on reasoning and agentic software engineering ability, and wins on multi-turn conversation quality even when the 27b models use a higher quantization.

Say goodbye to overthinking, tool call failures, amnesic loops, and fluffy outputs.

Uncensored — Occult Nail 1.0 answers what Nail declines; use responsibly.

With full 256k context in 8bit KV precision, Nail runs on 32GB RAM.

This is a Qwen3.6-35B-A3B at a home-baked MLX quant of Unsloth's UD-Q5_K_XL per-tensor recipe (MTP head + vision preserved) with an improved and fixed chat template modified to force-append a terseness prompt at the end of other system prompts.
If you're not on Mac, use the GGUF build

The numbers

The numbers and plates below were measured on the shipped 4-bit build; this is the 5-bit — same weights and template at higher precision.

Reasoning and knowledge

Multi turn conversations, capped at 6 turns

Autonomous software engineering in Pi coding agent

Best conversation score, fastest to a working fix, fastest to a correct answer — against dense models that take 2-5x times as long, at accuracy parity with all of them. Four benchmarks, n=3 seeds, one Mac Studio M2 Ultra. Nail beats Opus4.8 (medium) 3-0 on first-attempt solves in a real SWE Live repo, no fluffing about. We used Pi for local models, Claude Code for Opus.

Which one. Many independent tasks, or you'd rather solve 3 problems in the time Qwen3.6-27b solves one → Nail. One long agentic session that has to stay coherent inside a single context → Dagger-27b, its dense sibling at the same ~21 GB RAM footprint.

Benched against 27b dense at higher-bit quantization because that's the quality bar many people prefer.

All benchmarks on Mac Studio M2 Ultra 64 GB, oMLX, 8bit KV cache.

Memory footprint in multi-turn conversations to the context ceiling

Nail with full context and unquantized KV cache fits and runs on a 32GB unified RAM Mac, because it uses less RAM per token in context even at full 16bit KV precision.

While Nail runs all the way to 92 turns and 262k tokens context on that machine, Dagger taps out at 42 turns and 73k tokens.

Constrained hardware makes Nail the marathon winner AND the sprint winner, without sacrificing quality over Dagger or ThinkingCap.

Dagger wins for users with a lot of RAM, and a very long task, who are not in a hurry.

The other axis: context

Long form stamina is context ceiling ÷ tokens-per-question:

Seconds-per-correct is a sprint metric. In a long session that keeps every turn's thinking in context, the binding resource isn't time — it's context space, and your ceiling is context ÷ tokens per question.

Nail declares the same 262,144-token native context as Dagger, so the ceiling is not where it loses — the fill rate is. On GPQA-Diamond Nail spends 5,777 tokens per question against Dagger's 2,380:

  • Hard questions chained inside the native context: Dagger 110 · ThinkingCap 63 · Nail 45 · stock Qwen 24.
  • Conversation turns inside 100k tokens, on a harness that keeps each turn's thinking (Claw-Eval per-turn think+answer): Dagger 57 · ThinkingCap 44 · Nail 35.

Nobody sat through a 110-step session — it matters for autonomous thinking, agentic work, and conversations you keep coming back to.

Nail's verbose thinking is free in seconds and expensive in context. It still beats stock Qwen on both, but here Dagger wins by 2.4×. Nail for throughput, Dagger for endurance — the two axes have opposite winners, and neither model answers both.

The secret sauce

The system prompt ships inside the chat template and applies on every call. If you send your own system prompt, yours is emitted first and Nail's is appended after it:

You are Nail-35b-a3b, a variant of Qwen3.6-35B-A3B. Answer directly, after thinking. Lead with the answer, then only what it needs to be correct and usable.
Never: open with preamble or pleasantries; restate the question; add filler transitions; hedge with niceties; or repeat a point you've already made.
Always: keep essential steps, caveats, uncertainties, and specifics — never drop correctness or a needed warning for brevity. Keep the final answer lean. Use the least structure that conveys it (plain prose when short; lists or code only when they earn their place). If genuinely uncertain, say so and explain why — never omit uncertainty for the sake of brevity.
If a user request is genuinely ambiguous, ask a sharp question, don't guess.

Byte-identical to Dagger's, apart from the name.

The prompt is always on and lives in the template, not the API — disabling it means editing chat_template.jinja.

Froggeric's chat template that we used as a base implements many tricks that drastically improves multi-turn agentic workflows with tool calling.

The composition of our battle tested prompt with the improved template is what makes Nail so effective.

What it is

| | |

|---|---|

| Base | Qwen/Qwen3.6-35B-A3B |

| Quant | MLX 5-bit, Unsloth UD-Q5_K_XL recipe (mixed 5/6/8-bit, home-baked) |

| Architecture | MoE — 35.11B total, 3.39B active/token, 8 of 256 experts + shared expert |

| Compute | 6.79 GFLOP/token (dense 27B costs 51.25) |

| Modality | Text, image and video in — the vision tower is intact. Untested |

| On disk | ~27 GB. Budget ~32 GB unified memory with KV cache at long context |

| Template | froggeric's fixed Qwen template, with Nail's system prompt force-appended |

| Weights changed | None |

Same size, different physics

We didn't pick family sizes off a leaderboard. Our shipped 4-bit Nail is size-matched to Dagger-27b 6bit MLX; this higher-precision 5-bit trades a larger footprint for less quantization loss.

27B beats 35B on paper, and most people stop reading there. But 27B dense fires all 27 billion parameters on every token, reasoning tokens included, while 35B-A3B fires about 3.4B per token no matter what the label says. At comparable intelligence, one model is doing 7.5× less arithmetic per token (6.79 vs 51.25 GFLOP).

A terse-thinking finetune like ThinkingCap feels fast, because fewer tokens on screen reads as fewer seconds, and that gain is real. But it doesn't touch the number that actually sets your tokens per second: how many parameters wake up per token in the first place. Nail thinks more and pays less for each thought — about 3.3× faster decode in practice, once routing and memory bandwidth take their cut. Dagger stacks a real finetune on a real prompt; Nail skips the finetune and wins on sparsity alone while gaining output quality comparative to its base, thereby catching up with similar GB-sized 27b dense models.

Benchmarks tell you what a model knows, not what it costs to ask on your own machine or what it can get done in a certain amount of seconds. Match the size to your RAM first, then find out what a minute or hour of running it buys you.

This is also why we report seconds per correct answer in addition to tokens. On tokens-per-correct, Nail looks near-worst in this family (3,113 — it's the chattiest thinker except for stock). On seconds-per-correct it wins every seed. Same runs, opposite conclusion; the token metric silently assumes every token costs the same, and across architectures it doesn't.

Reasoning

Nail answers faster at the same quality as 27b

You saw MMLU-Pro earlier with accuracy parity, here is GPQA-Diamond: graduate-level multiple-choice questions in biology, chemistry, and physics, designed to test deep domain knowledge and reasoning.

We didn't lead with this one, because we didn't bench stock qwen ourselves: It would take too long on our Mac.

GPQA-Diamond ran the full 198-question set × 3 seeds — 594 graded answers per model, 0 truncations. The stock Qwen row carries a dagger because we did not run it: three seeds was 48–90 hours of the box for a baseline bottlecap already published. That number is near-full-precision where our three arms are quantized and with 8bit KV cache, and ThinkingCap's numbers count thinking tokens where ours are totals. Treat it as an estimate; the ThinkingCap comparison is the measured one.

Accuracy differences across the three measured models sit inside seed noise. What isn't noise: Nail's MMLU-Pro accuracy came in at 84.0% on all three seeds, ±0.0 — the steadiest arm in the family.

Conversation

When chatting with Nail, you will get higher quality answers in less words, delivered faster.

| | answer tokens/conv | score | seconds per conversation |

|---|--:|--:|--:|

| Nail-35b-a3b | 3,392 | 60.5%\* | 284 |

| Dagger-27b | 2,217 | 58.8%* | 522 |

| ThinkingCap-27b | 5,393 | 55.0%* | 651 |

| Qwen3.6-27b (base) | 6,274 | 55.4%* | 912 |

**(\at the limited multi_turn subset of ClawEval we limited rounds to 6 instead of the default 8, to save some days of GPU burn, so scores are not comparable to official ClawEval scores, only internally comparable to the models we benched)*

We ran Claw-Eval multi_turn — 38 multi-turn advice and clarification tasks, 5.3 turns on average, simulated user, scored on the project's own rubric formula. The result card is at the top of the page.

Nail takes the official score at under half ThinkingCap's wall clock. Dagger is the more disciplined writer; Nail is the one that gets there fastest.

Agentic coding

Nail solves the same problems faster, beating ThinkingCap-Qwen-27b and Opus medium on correctness on real-codebase problems.

Ten problems — 2 SWE-bench instances and 8 self-contained multi-round tasks — driven by a real coding agent, n=3. This is a solvable band: a set of problems every local model solves at least once.

The MoE speed advantage survives contact with agentic work — that was the open question. On the self-contained tasks Nail runs 3–6× faster per attempt on six of eight (csv_lite 21 s vs 124–139; ring_buffer 17 s vs 81–105; word_wrap 15 s vs 59–66; textkit 20 s vs 54–93), ~2.5–3× on calc, and level on coverage_v6 (141 s vs 143–174). The chart above plots Opus-4.8 at medium reasoning effort on the same ladder: Nail is in its neighbourhood on the easy end and roughly 3× slower on the two hardest tasks. Remarkable for 3.4B active parameters on a desk, and still not faster than the API. Medium is also why Opus goes 0/3 on http-proxy-middleware-1163 while a stock 27B solves it.

The fixed template is most of why the results looks like this. Swap it for the stock Qwen template — same weights, same terseness directives, nothing else changed — and http-proxy-middleware-1163 drops from 3/3 to 1/3 while SWE wall clock doubles (1,099 s vs 527 s). The band falls to 93.3% and 83 s per solve. On the eight self-contained tasks the two are a dead heat, so the whole gain is tool-call correctness on real repos, which is exactly what the fixed template is for.

It also solves what Dagger's aggressive thinking compression can't: on vueuse-5336 from SWE Bench Live, Nail passed 3/3 in 116 s where Dagger went 0/3. Nail carries the same terseness prompt but no thinking-compression finetune, so it still reasons at length — and on problems where a subtle regression is waiting while the naive fix is right in sight, length is what saves you.

Where it costs you: Nail is chatty per turn — it spends the most output tokens of the four on several tasks, and csv_lite costs it 3.9× the tokens of the baseline-template build. Its lead here is wall clock, not economy: the tokens are cheap, not few. And the band is ten problems on one machine — a 100% pass rate over 30 attempts is not a claim that it doesn't fail, only that it didn't here.

Recommended sampling

temperature 1.0 · top_p 0.95 · top_k 20 · min_p 0

Qwen3.6 thinking-mode defaults; anything you pass explicitly wins. Don't add repetition or presence penalties — Nail's concision comes from the prompt, and penalizing tokens distorts thinking in ways we haven't tested.

For agentic coding drop to temperature 0.7 (steadier tool use, everything else unchanged) — that's what our SWE runs used. Thinking budget up to 32,768, max output 32,768.

Use

Recommended: oMLX on Apple Silicon, symmetric 16-bit or 8-bit KV cache, <256k operational context.

# 1. Download
hf download peculiar-ragdoll/Nail-Qwen3.6-35B-A3B-MLX-5bit --local-dir Nail-35b-a3b-5bit

# 2. Serve
omlx serve ./Nail-35b-a3b-5bit --port 8100

# 3. Point an agent at it
pi --provider omlx --model Nail-35b-a3b-5bit "your task"

For image or video input, load it as a VLM (mlx_vlm, not mlx_lm) — the vision tower is intact but we have not benchmarked it.

A harness with a large system prompt of its own will get Nail's instructions last, which is usually what you want. Override the concision directives explicitly and you have a 5-bit Qwen3.6-35B-A3B, not a Nail.

Limitations and out-of-scope use

  • The prompt is not removable through the API. It lives in chat_template.jinja. Any deployment that needs unmodified base behavior should use the Qwen base directly.
  • Safety and refusal behavior were not re-evaluated. We added an instruction that suppresses hedging and preamble; we did not measure what that does to refusals, safety caveats, or tone in sensitive domains.
  • Vision is inherited and untested. Every number on this card is text-only. We have no evidence about image or video behavior under the terseness prompt, and a prompt that suppresses preamble may well change captioning style.
  • No clean ablation. See the Claw-Eval section — we cannot tell you how much of Nail is the prompt and how much is the base.
  • Quantization loss is unquantified. A 4/5/6-bit MLX ladder now exists, but the cross-quant quality deltas have not been benchmarked.
  • Chattier thinker than Dagger/ThinkingCap. Nail wins on wall clock, not on total token economy — budget accordingly if you pay per token somewhere downstream, and see the context section for what that costs in a long session.

Method and honest caveats

We ran this campaign the way these models think: cheap pilot first, pivot before the expensive run, n=1 where the effect is robust and n=3 where the judge is noisy, n=100 paired where the delta is small enough to matter. Same guardrail as the prompt itself — shorten the path, never the rigor.

Everything ran on one Mac Studio M2 Ultra 64 GB through oMLX: n=3 seeds, temp 1.0 (0.7 for agentic coding), top_p 0.95, top_k 20, 8-bit KV cache, 131k operational context, 32,768 thinking budget. Agentic work used the Pi coding agent.

  • csv_lite is the template's one cost. On that task the fixed template spends 3.9× the tokens of the stock one (2,865 vs 726, non-overlapping across three seeds) for the same pass. Everywhere else on the band it is free or better.
  • The quant cuts both ways. This runs Unsloth's dynamic 5-bit recipe where the dense arms run 6-bit; more bits than the shipped 4-bit means a smaller decode tailwind and a smaller quant-loss handicap. The 7.5× active-parameter gap is the load-bearing part either way.
  • Not leaderboard numbers. GPQA-Diamond ran the full 198-question set. MMLU-Pro ran our own 100-question subset. Both used minimal-prompt extraction rather than the official harness at full precision, so neither is board-comparable — they're internally consistent and validated against the published base-model number.
  • Contamination. The SWE-bench instances predate Qwen3.6's release and may be in training data. The deltas between models are robust to that; absolute pass rates aren't.
  • Judge. Claw-Eval scores used the project's real grading formula and rubrics, with Opus as judge rather than their default model. Valid for relative comparison, not an official number.
  • Blinding. Judged runs used one identical name-free persona across all conditions, so the judge scored behavior, not a label.
  • Statistics. Seed-level n=3 is low power for small accuracy deltas; accuracy claims are framed as not-detectable, not as wins.

Why this isn't a frontier-lab product

Intelligence per token never reaches a commercial roadmap — providers are paid per token, and nobody pays more per token for equal intelligence. Run the weights yourself and it flips: your cost is tokens, and on your own hardware it's really seconds and RAM. Nail is what that reframing looks like when you follow it all the way down to active parameter count. (Longer version on Dagger's card.)

Credits

  • Qwen at Alibaba — Qwen3.6-35B-A3B.
  • Unsloth — the UD per-tensor quant recipe (MLX conversion ours).
  • froggeric — the fixed Qwen chat template.
  • jundot — oMLX.
  • The Pi coding agent team.

Citation

@misc{Nail-35B-A3B,
  title  = {Nail-Qwen3.6-35B-A3B},
  author = {Saga Ishtardottir},
  year   = {2026},
  url    = {https://huggingface.co/peculiar-ragdoll/Nail-Qwen3.6-35B-A3B-MLX-5bit},
  note   = {Qwen3.6-35B-A3B with a fixed chat template and an always-on terseness prompt}
}

License

Apache-2.0, inherited from Qwen3.6-35B-A3B.