Achilles1089

fable-coder-35B-A3B

README

License: apache-2.0

TL;DR

fable-coder is a chained distill + behavioral fine-tune for Claude-Code-style agentic coding:

markdown
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

Table with columns: Setting, Value
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	— verified Claude Code coding sessions (our own generation + community Fable-5 traces + Glint corpus + swarm-salvage). Instruction-pair data from earlier rounds was for this round.

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.

Table with columns: Benchmark, r6 (this model), r4 (prior round), Base (huihui)
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	—

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):

Table with columns: Quant, Weights, GPU / Mac (with room for context)
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:

bash
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

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

Available on FriendliAI

Dedicated Endpoints

Run this model inference on single tenant GPU with unmatched speed and reliability at scale.

Learn more

Model Details

Model Provider

Achilles1089

Model Tree

Base

huihui-ai/Huihui-Qwen3.6-35B-A3B-Claude-4.7-Opus-abliterated

Fine-tuned

this model

Input Modalities

TextImageVideo

Output Modalities

Text

Supported Functionality