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 22 hours ago

preview code

Raw

History Blame Contribute Delete

8.94 kB

metadata

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