dale-0.8b

The full-precision weights (BF16 safetensors) of dale-0.8b, a full fine-tune of Qwen/Qwen3.5-0.8B that turns a natural-language request, in Spanish or English, into one bash command for Linux, answered as a small JSON object. It is the model behind dale, an offline command-line tool that runs it on CPU through llama.cpp.

Looking for something to run? Use the GGUF: manuelgscom/dale-0.8b-GGUF (Q4_K_M, 529 MB, works with plain llama.cpp), or just install the dale CLI. This repository is the source checkpoint those files were made from: use it with transformers, to make your own quantizations, or to fine-tune further.

• Author: Manuel García
• Website: https://manuelgs.com/en/dale/
• Source code: https://github.com/manuelgscom/dale (the dale CLI)
• Format: safetensors, BF16 (the 36 linear_attn.A_log / linear_attn.norm tensors in F32, as in the base model) · 1,706,035,272 bytes
• Test v2 accuracy: 78.6 % (370/471) in BF16 with transformers; 79.4 % (374/471) for the published Q4_K_M GGUF, versus 62.8 % for Qwen3.5-9B and Gemma 4 E4B-it without fine-tuning
• The dale family: four sizes of the same model (0.8B, 2B, 4B, 9B), all in one collection

dale live with this model (as the Q4_K_M GGUF): ask in plain English; it proposes the command, explains it, rates the risk and only runs it once you confirm. Real, unedited recording on a desktop CPU.

Resumen en español

Pesos completos (BF16, safetensors) de dale-0.8b, un ajuste completo de Qwen3.5-0.8B que convierte una petición en castellano o en inglés en un único comando bash para Linux, con una explicación breve. Es el modelo de dale, una herramienta de línea de comandos que funciona sin conexión, en CPU. Para usarlo, lo normal es el GGUF (dale-0.8b-GGUF) o la propia CLI; este repositorio es el checkpoint de origen, para transformers, para hacer cuantizaciones propias o para seguir ajustándolo. En el test v2 (471 casos) acierta el 78,6 % en BF16 (370/471) y el 79,4 % con el GGUF Q4_K_M publicado (374/471). Puede equivocarse (aproximadamente 1 de cada 5 casos): revisa siempre el comando antes de ejecutarlo.

Model tree

Qwen/Qwen3.5-0.8B                    base model (Apache-2.0)
 └─ manuelgscom/dale-0.8b            full fine-tune, BF16 safetensors   ◄── this repository
     └─ manuelgscom/dale-0.8b-GGUF   Q4_K_M with imatrix, used by the dale CLI on CPU

The 2B, 4B and 9B siblings are published as GGUF only: dale-2b-GGUF, dale-4b-GGUF, dale-9b-GGUF.

Files

File	Size (bytes)	SHA-256
model.safetensors	1,706,035,272	6f18d1dbb7b8177fbbd508f49d25257768a02efd3c43ed0dbd0f2f781cec43c3
config.json		1b95056a1422008551da0ae09b6416d947edcd0fb7e742c1479dd594a9535335
generation_config.json		afa48c3c3f7a3e873e82b5e77af288143c5b400d5df39ae4405e40e8e92d9fcb
tokenizer.json, tokenizer_config.json, vocab.json, merges.txt, chat_template.jinja		identical to Qwen3.5-0.8B
preprocessor_config.json, video_preprocessor_config.json		identical to Qwen3.5-0.8B
LICENSE		Apache-2.0

What is inside the checkpoint:

• Language model: all weights fine-tuned (no LoRA, no adapters).
• Vision encoder: included so the checkpoint loads as the full Qwen3_5ForConditionalGeneration, but byte-identical to the base model: training was text-only, and vision was never used nor evaluated.
• No MTP head. The base model's multi-token-prediction layers (15 tensors) were not trained and are not included; dale does not use speculative decoding.
• Tokenizer and chat template: unchanged from Qwen3.5-0.8B.

Usage with transformers

The model follows one fixed contract (version 2): a two-line system prompt, a user message made of a context line and the request, thinking disabled, and a single JSON object as the answer. It was trained on this format and nothing else.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "manuelgscom/dale-0.8b"
SYSTEM = (
    "Turn the request into one bash command for the Linux system described in the first line of the user message.\n"
    'Reply with only JSON {"type":"command|refuse|unsure","command":"...","explanation":"..."}: '
    '"command" is "" unless type is command; "explanation" is one short sentence in the language of the request.'
)
context = "os=linux distro=ubuntu-24.04 pm=apt tools=curl,docker,fdfind,git,jq,python3,rg,rsync,ssh,systemctl"
request = "busca en este directorio los ficheros que contienen la palabra TODO"

tok = AutoTokenizer.from_pretrained(repo)
model = AutoModelForCausalLM.from_pretrained(repo, dtype=torch.bfloat16, device_map="auto")

messages = [{"role": "system", "content": SYSTEM}, {"role": "user", "content": f"{context}\n{request}"}]
inputs = tok.apply_chat_template(messages, add_generation_prompt=True, enable_thinking=False,
                                 return_dict=True, return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=200, do_sample=False)
print(tok.decode(out[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True))

Output (BF16):

{"type":"command","command":"rg -l TODO","explanation":"Lista los ficheros que contienen TODO"}

AutoModelForCausalLM loads the text model only (the vision encoder is skipped). Tested with transformers 5.17. For speed, install flash-linear-attention and causal-conv1d: without them transformers falls back to the much slower reference implementation of Qwen3.5's linear-attention layers (same results).

The full contract (context keys, the tools list, the answer format, refuse and unsure) is documented in the GGUF model card. In short:

• System prompt: exactly the two lines above, no trailing newline.
• User message: os=linux distro=… pm=… tools=…, a newline, then the request (whitespace collapsed, at most 1000 bytes).
• Prompt: Qwen3.5's chat template with enable_thinking=False, so the assistant turn starts with an empty <think> block. No few-shot examples.
• Answer: exactly {"type":"command|refuse|unsure","command":"...","explanation":"..."}; greedy decoding, at most 200 tokens.

Never run the command blindly. Outside dale there is no risk verifier: add your own review step.

Converting and quantizing

The published GGUF was made from this checkpoint with llama.cpp:

python convert_hf_to_gguf.py dale-0.8b/ --outtype f16 --outfile dale-0.8b-f16.gguf
llama-imatrix -m dale-0.8b-f16.gguf -f calibration.txt -o imatrix.gguf
llama-quantize --imatrix imatrix.gguf dale-0.8b-f16.gguf dale-0.8b-Q4_K_M.gguf Q4_K_M

The imatrix was computed on 500 examples of the training data (every 19th line), which is not published. For your own quantizations, any text in the contract format works best; the public test set is not a good calibration set if you also want to measure on it.

To compare a quantization against this checkpoint on the real task, use the public test set manuelgscom/dale-bash-test-v2 (471 cases) with the contract above and greedy decoding.

Evaluation

Test v2: 471 cases (339 command requests, 101 out-of-scope, 31 ambiguous; 257 in Spanish, 214 in English), written by an independent LLM from a specification, frozen and never seen in training. Each command is judged by two LLM judges from different providers; if they still disagree after one debate round, the answer counts as wrong.

Checkpoint	Engine	Correct	Accuracy
BF16 (this repository)	transformers, GPU, greedy	370	78.6 %
Q8_0 GGUF	llama.cpp, same run	370	78.6 %
Q4_K_M GGUF (published)	llama.cpp, final comparison	374	79.4 %

• BF16 vs Q8_0: they differ in 2 cases, one each way (McNemar b = 1, c = 1): quantization and engine do not change the result.
• The Q4_K_M figure comes from the final comparison against the base models (contract v1 with 8 few-shot examples for them), where Qwen3.5-9B and Gemma 4 E4B-it scored 62.8 %. Full tables, error breakdown, per-category results and methodology are in the GGUF model card.
• With 471 cases the 95 % interval is about ±3.7 points: differences of a few cases between BF16 and the quantizations are noise.

Training

Base	Qwen/Qwen3.5-0.8B (revision 2fc06364715b967f1860aea9cf38778875588b17)
Method	Full fine-tune of all language-model weights (no LoRA, no adapters)
Data	48,841 training examples, 2,578 validation
Hyperparameters	lr 1e-5 (cosine, 3 % warmup), effective batch 32 (16 × 2), 2 epochs (3,054 steps), max sequence length 640, fp32 master weights with bf16 autocast, 8-bit AdamW
Software	Unsloth 2026.10.3, transformers 5.17.0, PyTorch 2.11.0 (CUDA 12.8)
Hardware	1× RTX 5090, about 30 minutes

Data. Synthetic examples written with LLM assistance: natural-language requests in Spanish and English, each with a machine context line and the JSON answer, covering commands, refusals and ambiguous requests. Command examples from tldr-pages were used only as coverage seeds (which commands and options exist); no tldr description text was copied, and all explanations are original. Every example was validated (schema, language, bash -n, known binaries consistent with the context, shellcheck, duplicates) and decontaminated against the test sets. The training data is not published.

Attribution. Command example lines from tldr-pages were used as seeds: tldr-pages contributors, CC BY 4.0 — https://github.com/tldr-pages/tldr — https://creativecommons.org/licenses/by/4.0/. Changes: only the example command lines of pages/common and pages/linux (tag v2.3) were extracted as coverage seeds; no tldr text is copied into the explanations, which are original.

Limitations

• bash on Linux only. No zsh, fish, PowerShell or cmd; no macOS.
• It can be wrong: about 1 in 5 answers on the test. A wrong command may look plausible. Always review a command before running it.
• It is not a security tool. Safety in dale comes from a deterministic verifier and confirmations, not from the model. The model can propose a destructive command; it does not classify risk.
• Trained for one task with one fixed prompt. Other prompts, chat use, reasoning mode and image or video input are unsupported.
• Tool choice depends on the context line: with no or wrong context it may suggest tools that are not installed.

Changes from the base model

• All language-model weights fine-tuned for the contract above (natural language → one bash command as JSON, with refuse and unsure).
• Vision encoder, tokenizer and chat template unchanged; MTP head removed.
• config.json as saved by training, with the local path field removed and use_cache set to true.

License

Apache-2.0, the same license as the base model Qwen3.5-0.8B. See LICENSE. The training seeds from tldr-pages are CC BY 4.0, attributed above.