Instructions to use AnkitAI/Parable-Qwen3-4B-Claude-Fable-5 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use AnkitAI/Parable-Qwen3-4B-Claude-Fable-5 with Transformers:

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

pipe = pipeline("text-generation", model="AnkitAI/Parable-Qwen3-4B-Claude-Fable-5")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("AnkitAI/Parable-Qwen3-4B-Claude-Fable-5")
model = AutoModelForCausalLM.from_pretrained("AnkitAI/Parable-Qwen3-4B-Claude-Fable-5")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.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(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use AnkitAI/Parable-Qwen3-4B-Claude-Fable-5 with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/AnkitAI/Parable-Qwen3-4B-Claude-Fable-5

SGLang

How to use AnkitAI/Parable-Qwen3-4B-Claude-Fable-5 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 "AnkitAI/Parable-Qwen3-4B-Claude-Fable-5" \
    --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": "AnkitAI/Parable-Qwen3-4B-Claude-Fable-5",
		"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 "AnkitAI/Parable-Qwen3-4B-Claude-Fable-5" \
        --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": "AnkitAI/Parable-Qwen3-4B-Claude-Fable-5",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use AnkitAI/Parable-Qwen3-4B-Claude-Fable-5 with Docker Model Runner:
```
docker model run hf.co/AnkitAI/Parable-Qwen3-4B-Claude-Fable-5
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

Parable-Qwen3-4B-Claude-Fable-5

First release of the Parable series: small models trained on real agent behavior, every release eval-gated before publish.

Parable-Qwen3-4B is a Qwen3-4B fine-tune trained on real Claude Fable 5 and GPT-5.5 agent traces: multi-step tool use, planning, and <think> reasoning captured from actual agent sessions, not synthetic Q&A. It cuts held-out test loss by 47% against the base under matched evaluation and reaches 0.782 token accuracy, within a point of models twice its size trained on similar traces.

Usage

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "AnkitAI/Parable-Qwen3-4B-Claude-Fable-5"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype="auto", device_map="auto")

messages = [{"role": "user", "content": "Write a Python function that retries an HTTP request with exponential backoff."}]
inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
output = model.generate(inputs, max_new_tokens=3000, temperature=0.3, do_sample=True)
text = tokenizer.decode(output[0][inputs.shape[1]:], skip_special_tokens=True)

# reasoning model: final answer follows the </think> block
answer = text.split("</think>")[-1].strip()
print(answer)

GGUF quants for llama.cpp / Ollama / LM Studio: Parable-Qwen3-4B-Claude-Fable-5-GGUF

Note: these weights are the F16 merge of a QLoRA adapter trained on the 4-bit base; quality is equivalent to the Q8 GGUF, published here for server stacks and further fine-tuning.

This is a reasoning model: output opens with a <think>...</think> block before the final answer. Strip it before showing responses to end users (llama.cpp's --jinja chat mode separates it automatically).

Sampling: temperature 0.3–0.7. Budget max_tokens generously (≥ 2500): like other trace-trained reasoning models, it thinks at length before answering, and a short budget can cut it off mid-thought.

Training data

Glint-Research/Fable-5-traces: 4.4k real Claude Fable 5 coding-agent session traces with <think> reasoning and tool calls (AGPL-3.0)
Roman1111111/gpt5.5-terminal: terminal-agent task solutions (MIT)

Every example passed a quality gate (schema validation, secrets scrub, length filtering) before training. QLoRA fine-tune via mlx-lm, quantized with llama.cpp.

Evaluation

Held-out test split, identical evaluation code for base and fine-tune (base measured through a zero-effect adapter for exact comparability):

Metric	Base Qwen3-4B	Parable	Δ
Test loss	1.888	0.996	−47%
Token accuracy	0.683	0.782	+10 pts

Qualitative review (34 coding/terminal/debugging prompts, judged clean-and-correct): of the prompts that produced a final answer, 92% were correct. The remainder hit reasoning-budget cutoffs rather than wrong answers (23/34 overall with a 2,600-token budget; see guidance above).

Limitations

Like other trace-trained reasoning models, it invests heavily in thinking. With tight token budgets it can spend the whole budget reasoning; budget ≥ 2500 tokens or retry at lower temperature if a response comes back empty.
Tuned hard toward agentic coding behavior; that focus trades some general-knowledge breadth, as with any specialized fine-tune in this class.
Verify critical output. Small models over-commit to plausible specifics; treat generated commands and code as drafts to review.
Inherits Qwen3-4B's base limitations and knowledge cutoff.

Provenance & licensing

Model weights: Apache-2.0 (inherited from Qwen3-4B). Training data licenses: Fable-5-traces AGPL-3.0, gpt5.5-terminal MIT. Because those traces originate from third-party assistants, the providers' terms may apply to downstream training and distillation. If you plan to build on this model commercially, confirm your use aligns with those terms.

Get Parable

Platform	Command / Link
Ollama	`ollama run parable/qwen3-fable:4b`
Ollama (family flagship, best per size)	`ollama run parable/fable`
Hugging Face	GGUF quants, full weights, eval reports
LM Studio	`lms get parable/qwen3-fable` (parable on LM Studio Hub)