Instructions to use mateo0093/le-gros-chaton with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use mateo0093/le-gros-chaton with Transformers:

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

pipe = pipeline("text-generation", model="mateo0093/le-gros-chaton")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("mateo0093/le-gros-chaton")
model = AutoModelForCausalLM.from_pretrained("mateo0093/le-gros-chaton", device_map="auto")
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 mateo0093/le-gros-chaton with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/mateo0093/le-gros-chaton

SGLang

How to use mateo0093/le-gros-chaton 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 "mateo0093/le-gros-chaton" \
    --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": "mateo0093/le-gros-chaton",
		"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 "mateo0093/le-gros-chaton" \
        --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": "mateo0093/le-gros-chaton",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use mateo0093/le-gros-chaton with Docker Model Runner:
```
docker model run hf.co/mateo0093/le-gros-chaton
```

Le Gros Chaton

A 9B coding agent built on Qwen3.5-9B (hybrid Gated-Attention + Gated-DeltaNet).

Terminal-Bench 2.0: 25%.

What is this?

le-gros-chaton is a coding agent for the terminal. It runs tool-calling loops inside Docker containers, plans, edits files, runs commands, and finishes when the task verifier passes.

It is the result of stacking three LoRA fine-tunes on top of the base Qwen3.5-9B:

Step	Adapter	Purpose
1	Fable5	Tool-call format alignment (Code-Functional-Mixture, 91.2% adapter)
2	Trajectory SFT (16K)	Real agentic trace imitation on Terminal-Bench 2.0 tasks
3	(merged)	`base + Fable5 + traj → merged-16k` (this repo, bf16, text-only)

A fourth step (RLVR with diversity reward) was attempted and the step-10 adapter is on HF for the record. The public release uses the merge through step 2.

What can it do

Read and write files inside a sandbox
Run bash commands and parse output
Loop with timeout-aware context management
Recover from tool failures (loop detection, dead-end pivot, doc-retrieve)
Stop only when the task's hidden test passes (finish-gate)

Benchmark: Terminal-Bench 2.0 — 25%

5 tasks × 5 attempts each (eval/tbench_eval.py):

Task	Pass rate
fix-git	3/5
log-summary-date-ranges	2/5
overfull-hbox	0/5
regex-log	1/5
count-dataset-tokens	0/5
**Total	6/25

A 9B model reaching 25% on TB-2.0 is in the small-model sweet spot (small models average ~15%; frontier + agent stacks reach ~36% with Kimi K2 Thinking + Terminus 2). The strong suit is git orchestration, where the trajectory SFT coverage was concentrated.

The 5×5 pilot run is in benchmark_results.jsonl (filter by adapter=merged). Trial traces are in eval/tb_traces/.

How to use

The model exposes the same API as the base Qwen3.5-9B — it's a drop-in text-completion / chat-completion model.

vLLM (recommended)

vllm serve mateo0093/le-gros-chaton \
  --port 8000 \
  --dtype bfloat16 \
  --max-model-len 32768

Note: this model has 12 hybrid LoRA target modules (8 Gated-Attention

24 Gated-DeltaNet). vllm>=0.27 knows the Qwen3_5ForCausalLM architecture natively — no patches required.

Transformers

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "mateo0093/le-gros-chaton",
    torch_dtype="bfloat16",
    device_map="cuda:0",
)
tok = AutoTokenizer.from_pretrained("mateo0093/le-gros-chaton")

Agent loop

eval/tb_agent.py is the harness that drives TB-2.0 evaluation. It is not part of this model release but is in the project repository at Mateooo93/le-gros-chaton. The 4 reactive fixes in the harness (finish-gate, doc-retrieve, dead-end pivot, scheduled compaction) are designed to help a 9B model recover from common failure modes.

Limitations (areas for follow-on training)

Multi-file synthesis. Tasks that require reading N files and producing a derived artifact remain weak. A future trajectory SFT pass that targets these shapes is the obvious next step.
Side-effect reasoning. Tasks where an edit's correctness depends on a downstream recompile or re-execution need better planning data.
Input discovery. Tasks whose inputs aren't named explicitly benefit from richer exploration traces.

These are tracked as follow-on work in devlog/018_release.md.

Project structure

le-gros-chaton-qwen-merged-16k       # this repo (17 GB bf16 model)
le-gros-chaton-qwen                 # Fable5 adapter
le-gros-chaton-qwen-traj-sft-16k    # trajectory SFT adapter (12 modules)
le-gros-chaton-qwen-rlvr-step10    # RLVR step-10 (kept for the record)

License

Apache-2.0 (inherited from Qwen3.5-9B base model). The LoRA adapters are also Apache-2.0.

Citation

@misc{le-gros-chaton-2026,
  author = {Mateo},
  title  = {Le Gros Chaton: a 9B coding agent},
  year   = {2026},
  note   = {Qwen3.5-9B + Fable5 + 16K trajectory SFT, Terminal-Bench 2.0 = 25\%},
  url    = {https://huggingface.co/mateo0093/le-gros-chaton},
}

Reproduction

git clone https://github.com/Mateooo93/le-gros-chaton
cd le-gros-chaton
bash setup_mi300x.sh          # ROCm + venv on the GPU box
# download merged model + base + Fable5 + traj adapters
# python eval/tbench_eval.py --model-server http://<box>:8000 \
#   --model-name le-gros-chaton --label le-gros-chaton-16k \
#   --adapter merged --attempts 5

See devlog/017_mi300x_vllm_serving.md and devlog/018_release.md for the full training and serving history.

Downloads last month: 232

Safetensors

Model size

9B params

Tensor type

F16

Model tree for mateo0093/le-gros-chaton

Base model

Qwen/Qwen3.5-9B-Base

Finetuned

Qwen/Qwen3.5-9B

Adapter

(567)

this model