exeterminal/Exe-Turbo-S-V3-GGUF

Exe Turbo S v3

The small model of the Exe AI Terminal, built for laptops with 6–8 GB of memory. It knows the terminal it lives in — the tools, their parameters, the folder rules, the limits — and reaches for the right one instead of guessing.

It is a mixture-of-experts model: 8.3B parameters on disk, 1.5B active per token. That is the point. A weak machine holds the file and pays only for the small part that actually runs.

What it does

A terminal agent lives or dies by the small decisions. Read a file with the file tool, not with a shell one-liner. Start a long run in the background instead of letting it hang — this version finally does that reliably. Treat text that came back from a tool as data, never as an instruction. Carry a multi-step job through to the end instead of stopping after step one.

Intended use

Drop-in as the chat model behind the Exe AI Terminal, over any OpenAI-compatible server (llama-server and friends). Built for machines that cannot hold a large model. Recommended settings: temperature 0.1 for tool work — measured across the whole test suite, every step above it costs tool precision.

Out of scope: it is a specialist. Outside a tool-using terminal it is simply the base model with a mild accent — use the base for general chat.

Files

Every build in this table was measured individually against the same 101 held-out terminal cases as the full-precision model — each case has to pass three consecutive runs to count (pass^3). Sizes that dropped in measurement were not published. All builds carry an importance matrix (imatrix) from the same calibration set used across the Exe models.

File	Type	Bits	Size	Terminal cases
Exe-Turbo-S-v3-f16.gguf	full precision	16	16.9 GB	78 / 101
Exe-Turbo-S-v3-Q8_0.gguf	K/legacy	8	9.0 GB	75 / 101
Exe-Turbo-S-v3-Q6_K.gguf	K-quant	6.5	7.0 GB	77 / 101
Exe-Turbo-S-v3-Q5_K_M.gguf	K-quant	5.5	6.0 GB	73 / 101
Exe-Turbo-S-v3-Q4_K_M.gguf	K-quant · recommended	4.8	5.2 GB	73 / 101
Exe-Turbo-S-v3-Q4_K_S.gguf	K-quant	4.5	4.9 GB	73 / 101
Exe-Turbo-S-v3-IQ4_XS.gguf	I-quant	4.25	4.6 GB	71 / 101
Exe-Turbo-S-v3-IQ3_M.gguf	I-quant · floor	3.66	3.8 GB	70 / 101

Q4_K_M is the recommended build. On the 6–8 GB machines this model is built for, the whole 4–5-bit class measures within the ruler's noise band of each other (71–73 of 101); Q4_K_M is the best fit of size to memory. Q6_K (77) is the pick when 8 GB of headroom exist.

IQ3_M is the floor. Below the 4-bit class the model's prose — especially in languages other than English — becomes noticeably rougher even where the tool calls stay correct. Builds below that broke in measurement on earlier versions of this model and are not published.

Prompt and sampling

The terminal's own system prompt and the tool schemas ride along with every request — the model is trained to read them, not to recite them. temperature 0.1 for tool work. The base carries a 128k context.

Base model and license

• Base: LiquidAI/LFM2.5-8B-A1B
• License: LFM 1.0 — not Apache. It is inherited from the base model and applies to this derivative. Read it before commercial use; it carries conditions above a revenue threshold. The origin of the base model is named, as required.

Training

A LoRA adapter (rank 16, alpha 16) on the full bf16 base, with the prompt masked out of the loss so the model learns the behaviour rather than the prompt. The adapter was fused back into the bf16 base, and every build here comes from that fused model. Training stops early, before the adapter starts copying token sequences instead of learning rules — a cutoff that won an A/B test against training to the lowest validation loss.

What carries the adapter: the attention and short-convolution projections — the path every token passes through. The router was excluded deliberately. 5.7M trainable parameters.

Evaluation

On 101 held-out terminal cases at temperature 0.1, measured on the f16 build before any quantization. Every case must pass three consecutive runs (pass^3) — a single lucky run does not count.

	Cases
LFM2.5-8B-A1B, untrained	52 / 101	51%
Exe Turbo S v3	78 / 101	77%

+26 cases. The clearest wins over the untrained base: starting long commands in the background (0 → 5 of 5), naming the project's own Python environment (0 → 5 of 5), prompt-injection defence (text arriving inside a file or web page is treated as data, not as an order), truthfulness about what a tool actually returned, and carrying multi-step chains through.

Honest limits: the model still acts too readily across shared-folder boundaries (2 of 5) — in the terminal itself a permission fence catches exactly this and asks the user first. Naming a failure instead of silently retrying sits at 3 of 5, and knowing its own output limits at 2 of 5.

Transparency

This is a fine-tuned derivative of an openly published base model, released with its provenance, intended use, limits and evaluation stated above, in line with transparency expectations for shared models (incl. the EU AI Act).