---
license: apache-2.0
base_model: Qwen/Qwen2.5-Coder-1.5B-Instruct
library_name: gguf
pipeline_tag: text-generation
language:
- en
tags:
- linux
- bash
- shell
- command-line
- gguf
- llama.cpp
- lora
---

# lxask: Linux commands from plain English, offline

`lxask` turns a plain-English request ("find files bigger than 100 MB in /var, newest first")
into a Linux command, with each part explained, and checks it against the man pages and
tldr before showing it. It runs on your machine: no network, account or API key after
install. The program is a single Rust binary; this repository holds the model files it uses.

- Code, install script and docs: https://github.com/arxhr007/lxask
- Docs site: https://arxhr007.github.io/lxask/
- Version of these files: lxask v1.0.0 (the model files are unchanged since v0.11.0)

## Files

| file | size | what it is |
|---|---|---|
| `lxask-round4-Q4_K_M.gguf` | 986 MB | the chat model: Qwen2.5-Coder-1.5B-Instruct, fine-tuned, 4-bit (Q4_K_M) |
| `restrict-round4.gguf` | 37 MB | LoRA adapter, switched on only for requests that rule a program out ("without lsof") or mention a proxy |

sha256:

```
023ee206403c7fc96a9be13e1aec761dd798d73c6d2f876a6c09c392dbf9cbc5  lxask-round4-Q4_K_M.gguf
e77b3d86aab83aedf1a464993599c4b503d59d80b3fa7147b420221c214c8549  restrict-round4.gguf
```

These are not a standalone chat model. The accuracy comes from lxask's pipeline around the
model: retrieval from man pages and tldr, a validator that checks every program and option,
retries, and fixed rules. Used raw, the model alone is weaker (see the benchmark below).

## Use

Install lxask (it downloads these files):

```
curl -fsSLO https://github.com/arxhr007/lxask/releases/latest/download/install.sh
sh install.sh
lxask "show the 5 biggest files in this folder"
```

The model alone runs in llama.cpp (`llama-cli -m lxask-round4-Q4_K_M.gguf`), but without
the pipeline you lose the checks.

## Training

Base: Qwen2.5-Coder-1.5B-Instruct (Apache 2.0). Two stages, then a small add-on:

1. Supervised fine-tuning (LoRA, about 39,000 examples, one epoch).
2. Reinforcement learning (GRPO) on about 1,550 file and text tasks, rewarded when the
   command actually ran in a sandbox and did the job. Held-out execution success rose from
   52% to 78% (raw, before the pipeline's checks).
3. The 37 MB adapter, trained on requests that rule out a program and on proxy settings.

Data: tldr-pages (CC BY 4.0), NL2Bash (GPL-3.0, with macOS-only commands removed), and
questions and answers written by language models, every command checked by a validator and
the answers reviewed by a stronger model. The model-written data is published in the repository, since 2026-10-21. Every
training round, including the ones that were dropped:
https://github.com/arxhr007/lxask/blob/main/docs/results.md

## Limits

- 1.5B parameters. It misses by a detail (a flag, a field number) more often than a large
  model would, which is why every answer is explained and anything unconfirmed is flagged.
- English requests; Linux only (macOS and BSD flags differ).
- It never runs commands for you. Read a command before you run it.
- Licence lineage: Qwen2.5-Coder (Apache 2.0); tldr-pages CC BY 4.0; NL2Bash GPL-3.0.
  Details: https://github.com/arxhr007/lxask/blob/main/NOTICE

## Benchmark

The public [NL2SH-ALFA](https://huggingface.co/datasets/westenfelder/NL2SH-ALFA) test
set: 300 shell tasks, each answer executed in Docker by the InterCode-ALFA harness and
scored by its embedding judge (local model, threshold 0.75).

| | solved | 95% CI |
|---|---|---|
| **lxask (model + pipeline)** | **187/300 (62%)** | 57-68% |
| this base model, untuned, given three worked examples | 162/300 (54%) | 48-60% |
| this base model, untuned, plain instruction (replies cleaned) | 153/300 (51%) | 45-57% |
| the set's own reference commands | 299/300 (99.7%) | |

Against the three-example baseline lxask solves 46 tasks the base misses and misses 21 it
solves (paired McNemar p = 0.003). 63 of the 300 tasks overlap the training sources; on
the 237 without overlap it is 61% against 54% (p = 0.024). Keeping the first answer (no
retries) or removing retrieval moves at most one task, so the gain is the fine-tune's, not
the pipeline's checks. The benchmark authors publish 73% for GPT-4o, a hosted model; that
number is theirs and was not re-run here.

**Correction (2026-10-23):** this card first reported 31% for the untuned model. That run
cleaned the model's replies badly (199 of 300 came wrapped in backticks, which fail when
run). The numbers above are the fixed re-run. The full record, the scripts to reproduce
it and the judge's context-error caveat:
https://github.com/arxhr007/lxask/blob/main/docs/accuracy.md#the-public-benchmark-nl2sh-alfa