fable-coder-35B-A3B
A sovereign, open-weights agentic coding model by Dappit Labs. 35B Mixture-of-Experts (≈3B active), built by layering Claude Fable-5 / Opus-4.8 agentic tool-use behavior onto an abliterated, Opus-4.7-reasoning-distilled Qwen3.6-35B-A3B.
Built by Dappit Labs · @dappitdotio Trained on hardware provided by Manifest Network. 🙏
⚠️ Numbers are from our own harness (see Evaluation); nothing here is a claim against official leaderboards.
TL;DR
fable-coder is a chained distill + behavioral fine-tune for Claude-Code-style agentic coding:
Qwen3.6-35B-A3B (Apache-2.0)
└─ Opus-4.7 reasoning distill (lordx64/…-Reasoning-Distilled)
└─ abliteration (huihui-ai/…-abliterated) ← our base
└─ LoRA fine-tune, agentic rounds r3→r4→r6 ← this model (r6)
- Reasons natively in Qwen
<think>chains (inherited from the Opus-4.7 prior; intact — verified). - Acts like a coding agent — emits tool calls and edits when driven inside an agent harness (the Fable-5/Opus-4.8 agentic SFT).
- Runs on a 32GB GPU at Q4/Q5 (a 24GB card works at short context), up to Q8 (~38GB) on a 48GB+ GPU or 64GB Mac. CPU/Metal too. (Realistic size-vs-hardware table below.)
- r6 is the released round; r4 (the prior round) is documented alongside for provenance.
Honest scope
This is not a single-teacher distillation from scratch, and it does not aim to exceed its teachers. It is a behavioral graft: the reasoning comes from the Opus-4.7 distill in the base; our LoRA rounds add agentic coding behavior distilled from verified Claude Fable-5 / Opus-4.8 Claude Code sessions. Evaluate and use it accordingly:
- Reasoning / math / knowledge: driven by the underlying Opus-4.7 distill. fable-coder ~matches it; it does not beat it.
- Agentic coding (edit files, run tests, iterate): this is where our training adds value over the vanilla base — see MBPP and the r4→r6 delta.
- Chat / assistant: works, but persona may drift toward a Claude voice (stacked Anthropic-style SFT).
Training
| Setting | Value |
|---|---|
| Base | huihui-ai/Huihui-Qwen3.6-35B-A3B-Claude-4.7-Opus-abliterated |
| Method | LoRA (unsloth + TRL SFTTrainer), adapter-continuation across rounds (never restarted from base) |
| LoRA | r=32, α=32, targets = attention (q/k/v/o) + MLP (gate_up_proj, down_proj) |
| Precision | bf16; train_on_responses_only; MoE router aux loss on |
| Seq length | 4096 |
| Final round (r6) | fresh continuation on the r4 adapter, LR 2e-5, 1 epoch (126 steps) |
| r6 data | 1,007 agentic-only windows — verified Claude Code coding sessions (our own generation + community Fable-5 traces + Glint corpus + swarm-salvage). Instruction-pair data from earlier rounds was removed for this round. |
| Data hygiene | rejection-sampled (kept only sessions whose tests/build passed); zero-overlap hash-assert vs prior rounds; secrets/PII scrubbed |
Lineage note (a documented lesson): an intermediate round (r5) that restarted from base with a filtered corpus regressed hard (HumanEval 90.9 → 71.3). The fix — and the method used for r6 — is strict adapter continuation plus an agentic-only final corpus. r6 recovered and improved.
Evaluation
Methodology & honesty. All numbers below are our own harness, q8_0 GGUF, native thinking (temp 0.6 / top-p 0.95), single-sample pass@1, run locally. They are not directly comparable to official leaderboards (different precision, harness, and prompting). AIME uses a 16k-token budget so long reasoning chains don't truncate.
| Benchmark | r6 (this model) | r4 (prior round) | Base (huihui) |
|---|---|---|---|
| HumanEval (pass@1) | 90.2 | 90.9 | 90.2 |
| MBPP (pass@1) | 78.2 | 76.2 | 73.0 |
| GSM8K | 94.7 | 95.0 | — |
| MATH-500 | 88.2 | 89.4 | — |
| AIME 24+25 (16k) | 73.3 | 71.7 | — |
| MMLU-Pro | 79.8 | 77.2 | — |
Read: r6 preserves the base's reasoning (GSM8K/MATH/MMLU-Pro/AIME all healthy) while improving the metric closest to its job — MBPP +5.2 over base, +2.0 over r4 — with no regression on any axis versus r4. Reasoning is preserved; coding — the model's actual job — improves.
🚧 Pending: SWE-bench Lite (agentic harness) is the key remaining test — it measures the actual coding-agent axis these benchmarks can't. Numbers will be added when verified.
Quantizations
Produced locally with llama.cpp from the bf16 master (llama-quantize):
| Quant | Weights | GPU / Mac (with room for context) |
|---|---|---|
| Q8_0 | 38GB | 48GB+ GPU · 64GB Mac — near-lossless |
| Q6_K | 29GB | 40GB+ GPU · 48GB Mac |
| Q5_K_M | 25GB | 32GB GPU |
| Q4_K_M | 22GB | 32GB GPU (or a 24GB card at short context) |
Sizes are the weights only — budget headroom on top for the KV cache + compute buffers. The good news: this model's KV cache is unusually small (only 2 KV heads), so long context is cheap — ~2.7GB at 32k, ~11GB at 128k, ~21GB at the full native 256k. That's why it's comfortable on modest hardware despite being a 35B.
Pre-made GGUF quants (Q4–Q8) → GGUF repo, or ollama run achillessafehavencalls/fable-coder. The full-precision bf16 weights are in this repo — or quantize your own levels (F16, IQ4_XS, etc.) with llama.cpp.
Usage
Run it instantly with Ollama:
ollama run achillessafehavencalls/fable-coder
Or serve the GGUFs with llama.cpp / LM Studio / vLLM. Thinking is native — the Qwen template opens <think>
by default; the server returns reasoning in reasoning_content and the answer in content. For
agentic use, run inside a harness that supplies a tool-use system prompt + tool registry (treat it
like Claude Code). Note: tool-name binding is loose at this data scale — downstream tool routers
should normalize invented names (e.g. read_file → Read).
Limitations
- Uncensored / abliterated base. Refusals are largely removed. You own compliance and safety for your use case. (See below.)
- Distill, not teacher-surpassing. Won't beat the Opus-4.7 prior on pure reasoning.
- Narrow agentic distribution. Training sessions skew web/app/game/web3 coding; out-of-distribution agent tasks are hit-or-miss.
- Our-harness numbers. Not official-leaderboard comparable; SWE-bench pending.
- Tool-name vocabulary doesn't bind to a fixed schema — normalize downstream.
License & Responsible Use
Released under Apache-2.0, consistent with the Qwen3.6-35B-A3B base and the Opus-4.7 distill it builds on (both Apache-2.0). We treat the model weights as an independent artifact, not a derivative work of the training data.
Provenance disclosures (in the spirit of full transparency):
- A portion of the fine-tuning data was distilled from Anthropic Claude Fable-5 / Opus-4.8 model outputs. Downstream users building products should verify compliance with Anthropic's usage policies for their specific use case.
- Some agentic-trace data was sourced from community corpora, including
Glint-Research/Fable-5-traces. Trace contributors are credited under Attribution.
Responsible use: this is an uncensored (abliterated-base) coding model released for sovereign/research use. You are responsible for compliance and safety in your deployment. Do not use it to generate malware, conduct unauthorized intrusion, or carry out other unlawful activity.
Attribution & Acknowledgements
- Manifest Network — provided the GPU compute this model was trained on. This release doesn't happen without them. 🙏
- Qwen team — Qwen3.6-35B-A3B (Apache-2.0).
- lordx64 — the Opus-4.7 reasoning distill this base builds on.
- huihui-ai — the abliterated base.
- Anthropic — the Claude Fable-5 / Opus-4.8 teacher behavior distilled here.
- Glint-Research, Met4physics, and community trace contributors — corpus sources.
- unsloth (MoE+LoRA training) and llama.cpp (GGUF + quantization).
Citation
@misc{fable_coder_35b_2026,
title = {fable-coder-35B-A3B: agentic-coding fine-tune of Qwen3.6-35B-A3B (Claude Fable-5/Opus distill)},
author = {Dappit Labs},
year = {2026},
howpublished = {\url{https://huggingface.co/Achilles1089/fable-coder-35B-A3B}},
}