---

license: other

license_name: lfm1.0

license_link: https://huggingface.co/LiquidAI/LFM2.5-8B-A1B/blob/main/LICENSE

base_model: LiquidAI/LFM2.5-8B-A1B

library_name: gguf

pipeline_tag: text-generation

language:

- en

tags:

- gguf

- exe-ai-terminal

- agent

- tool-use

- terminal

- moe

- llama.cpp

---

<div align="center">

<picture>

<source media="(prefers-color-scheme: dark)" srcset="https://huggingface.co/exeterminal/Exe-Turbo-S-V1-GGUF/resolve/main/exe-chevron-dark.png">

<img src="https://huggingface.co/exeterminal/Exe-Turbo-S-V1-GGUF/resolve/main/exe-chevron-light.png" alt="Exe AI" width="72">

</picture>

<h1>Exe AI</h1>

<a href="https://exe-hq.net"><b>exe-hq.net</b></a>

</div>

---

<div align="center">

<img src="exe-turbo-s-hero.png" alt="Exe Turbo S v1 — the small model of the Exe AI Terminal" width="100%">

</div>

Exe Turbo S v1

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.

The version ladder

Every version is measured on the same 101 held-out terminal cases, and every

case has to pass three consecutive runs to count (pass^3). No version is

scored against a different ruler.

<div align="center">

<img src="exe-turbo-s-leiter.png" alt="Bar chart: untrained base 52 of 101, version 1 66, version 2 76, version 3 78" width="100%">

</div>

This card describes v1, the first rung of that ladder.

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. Treat text that came back from a tool as data, never as an

instruction. Ask one short question when a request is genuinely ambiguous.

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.

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 72

held-out terminal cases as the full-precision model. Sizes that dropped in

that measurement were not published. All builds carry an importance matrix

(imatrix) computed from the same calibration set used across the Exe models.

| File | Type | Bits | Size | Terminal cases |

|---|---|---|---|---:|

| Exe-Turbo-S-v1-f16.gguf | full precision | 16 | 16.9 GB | 67 / 72 |

| Exe-Turbo-S-v1-Q8_0.gguf | K/legacy | 8 | 9.0 GB | 65 / 72 |

| Exe-Turbo-S-v1-Q6_K.gguf | K-quant | 6.5 | 7.0 GB | 66 / 72 |

| Exe-Turbo-S-v1-Q5_K_M.gguf | K-quant | 5.5 | 6.0 GB | 67 / 72 |

| Exe-Turbo-S-v1-Q4_K_M.gguf | K-quant · recommended | 4.8 | 5.2 GB | 67 / 72 |

| Exe-Turbo-S-v1-Q4_K_S.gguf | K-quant | 4.5 | 4.9 GB | 64 / 72 |

| Exe-Turbo-S-v1-IQ4_XS.gguf | I-quant | 4.25 | 4.6 GB | 63 / 72 |

| Exe-Turbo-S-v1-IQ3_M.gguf | I-quant · floor | 3.66 | 3.8 GB | 66 / 72 |

Q4_K_M is the recommended build. Measured, it matches the

full-precision file exactly — 67 / 72, with the same few misses — at less

than a third of the size. On the 6–8 GB machines this model is built for,

that is the file to take.

IQ3_M is the floor. Tool calls hold up (66 / 72), but 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 IQ3_M broke in measurement (48–50 / 72, with failures in the

prompt-injection group) and were removed.

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.

What carries the adapter: the attention and short-convolution projections —

the path every token passes through. The expert layers do not: in this

architecture the 32 experts per layer are one fused block of stacked matrices, not

separate linear layers, and standard LoRA tooling cannot wrap them. The router was

excluded deliberately. 5.7M trainable parameters proved to be enough.

Training stopped itself at 1.1 of 3 planned epochs when the training loss fell

below 0.2 — past that point the model is memorising, not learning. Held-out

validation loss at that point: 0.2538, its best.

Evaluation

On 72 held-out terminal cases at temperature 0.1, measured on the f16 build

before any quantization, so that a weak result could not be blamed on two

things at once:

| | Cases | |

|---|---:|---:|

| LFM2.5-8B-A1B, untrained | 38 / 72 | 53% |

| Exe Turbo S v1 | 67 / 72 | 93% |

+29 cases.

The clearest win is prompt-injection defence, which went from 0/4 to 4/4: text

that arrives inside a file or a web page is now treated as data, not as an order.

Naming the project's own Python environment went 0/4 → 4/4, and reporting a failure

honestly 0/4 → 4/4.

Honest limits: two groups stayed weak — reading a document before rewriting it

(2/4) and re-reading a preview it already has (0/2). Both are the same habit: it

inspects when it should act.

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).