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}},
}