Blame for README.md

---
license: apache-2.0
base_model: huihui-ai/Huihui-Qwen3.6-35B-A3B-Claude-4.7-Opus-abliterated
pipeline_tag: text-generation
library_name: transformers
tags:
  - code
  - agentic
  - coding-agent
  - moe
  - qwen3.6
  - claude-distill
  - gguf
  - uncensored
  - dappit
language:
  - en
---

# fable-coder-35B-A3B

**A sovereign, open-weights agentic coding model by [Dappit Labs](https://dappit.io).** 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](https://dappit.io)** · [@dappitdotio](https://x.com/dappitdotio)
> **Trained on hardware provided by [Manifest Network](https://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](https://huggingface.co/Achilles1089/fable-coder-35B-A3B-GGUF)**, 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](https://ollama.com/achillessafehavencalls/fable-coder):**
```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](https://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}},
}
```