Instructions to use Achilles1089/fable-coder-35B-A3B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Achilles1089/fable-coder-35B-A3B with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="Achilles1089/fable-coder-35B-A3B")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("Achilles1089/fable-coder-35B-A3B")
model = AutoModelForMultimodalLM.from_pretrained("Achilles1089/fable-coder-35B-A3B")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Achilles1089/fable-coder-35B-A3B with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Achilles1089/fable-coder-35B-A3B"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Achilles1089/fable-coder-35B-A3B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/Achilles1089/fable-coder-35B-A3B

SGLang

How to use Achilles1089/fable-coder-35B-A3B with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Achilles1089/fable-coder-35B-A3B" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Achilles1089/fable-coder-35B-A3B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Achilles1089/fable-coder-35B-A3B" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Achilles1089/fable-coder-35B-A3B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use Achilles1089/fable-coder-35B-A3B with Docker Model Runner:
```
docker model run hf.co/Achilles1089/fable-coder-35B-A3B
```

fable-coder-35B-A3B / README.md

Achilles1089

Upload README.md with huggingface_hub

8facca0 verified about 24 hours ago

preview code

Raw

History Blame Contribute Delete

8.94 kB

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