Instructions to use tablinum/lfm2.5-1.2b-litebeam with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Notebooks
Google Colab
Kaggle
Local Apps Settings

How to use tablinum/lfm2.5-1.2b-litebeam with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf tablinum/lfm2.5-1.2b-litebeam
# Run inference directly in the terminal:
llama cli -hf tablinum/lfm2.5-1.2b-litebeam

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf tablinum/lfm2.5-1.2b-litebeam
# Run inference directly in the terminal:
llama cli -hf tablinum/lfm2.5-1.2b-litebeam

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf tablinum/lfm2.5-1.2b-litebeam
# Run inference directly in the terminal:
./llama-cli -hf tablinum/lfm2.5-1.2b-litebeam

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf tablinum/lfm2.5-1.2b-litebeam
# Run inference directly in the terminal:
./build/bin/llama-cli -hf tablinum/lfm2.5-1.2b-litebeam

Use Docker

docker model run hf.co/tablinum/lfm2.5-1.2b-litebeam

LM Studio
Jan

vLLM

How to use tablinum/lfm2.5-1.2b-litebeam with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/tablinum/lfm2.5-1.2b-litebeam

Ollama
How to use tablinum/lfm2.5-1.2b-litebeam with Ollama:
```
ollama run hf.co/tablinum/lfm2.5-1.2b-litebeam
```
Unsloth Desktop

How to use tablinum/lfm2.5-1.2b-litebeam with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf tablinum/lfm2.5-1.2b-litebeam

Configure the model in Pi

# Install Pi:
npm install -g @earendil-works/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "tablinum/lfm2.5-1.2b-litebeam"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Docker Model Runner
How to use tablinum/lfm2.5-1.2b-litebeam with Docker Model Runner:
```
docker model run hf.co/tablinum/lfm2.5-1.2b-litebeam
```

Lemonade

How to use tablinum/lfm2.5-1.2b-litebeam with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull tablinum/lfm2.5-1.2b-litebeam

Run and chat with the model

lemonade run user.lfm2.5-1.2b-litebeam-{{QUANT_TAG}}

List all available models

lemonade list

Hermes Agent

How to use tablinum/lfm2.5-1.2b-litebeam with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf tablinum/lfm2.5-1.2b-litebeam

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default tablinum/lfm2.5-1.2b-litebeam

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use tablinum/lfm2.5-1.2b-litebeam with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf tablinum/lfm2.5-1.2b-litebeam

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "tablinum/lfm2.5-1.2b-litebeam" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

Tablinum

LFM2.5 1.2B LiteBeam

half a gigabyte, full-size answers

A 1.2B chat model in 542 MiB · scores level with the stock 4.1 bpw quant · measured on 2,500 questions with confidence intervals

LFM2.5 1.2B LiteBeam

LiteBeam is a hand-built tensor map for LiquidAI/LFM2.5-1.2B-Instruct, not a one-flag quantize. Every sensitive tensor gets a floor; everything else gets the smallest safe rung. The result is a 542 MiB chat model that answers as well as the stock 4.1 bpw quant — which is 5.3% larger — on a 2,500-question multiple-choice benchmark.

If you want a capable, fully offline chat model that costs half a gigabyte of disk, ~660 MiB of VRAM, and runs at 217 tokens/second on a six-gigabyte laptop GPU, this is the file.

Why LiteBeam

1. It is smaller than the stock quant it matches. On 2,500 letter-answerable questions, LiteBeam 3.89 bpw scores 641/2500 and stock llama.cpp Q3_K_M scores 630/2500. Paired, that gap is +0.0044 accuracy, p = 0.60 — a statistical tie — for 5.3% fewer bytes (0.529 GiB vs 0.559 GiB).

2. Sensitive tensors are protected by design. Attention V is pinned at Q5_K on every layer, embeddings at Q4_K or better, and the first and last blocks get a full rung up. That is not what a uniform rule does — it is a deliberate quality floor, applied before the file was measured.

3. Two rungs, both measured end to end. Take 3.89 bpw for the smallest footprint, or 4.80 bpw when you want generation quality that is statistically indistinguishable from the F16 base (p = 0.081). Same model, same prompt format, swap the file.

4. Everything is reproducible. The exact tensor map ships in this repo with its hash, alongside the benchmark's per-item results. Rebuild the file byte-for-byte with the command in Reproduce.

5. It fits beside your other work. Peak VRAM at 2,048 context is 0.659 GiB (3.89 bpw) and 0.783 GiB (4.80 bpw) on a 6 GiB laptop card. On CPU it runs 153 tokens/s prefill, 48 tokens/s decode (3.89 bpw) on a 12-thread laptop.

The scoreboard

Frozen instrument: 2,500 letter-answerable multiple-choice items drawn from MMLU-Pro, GPQA, and BBH. Protocol: llama-server -ngl 99, 2,048 context, 12 threads, forced answer prefix, argmax over single-token letters A–J. Retention is measured against the same-model F16 run on the identical items, and is reported with a bootstrap confidence interval.

rung	bpw	size	correct / 2500	retention	95% CI	in-dist PPL ratio	VRAM peak
LiteBeam 3.89	3.885	0.529 GiB	641 (25.6%)	0.929	[0.876, 0.985]	1.051	0.659 GiB
LiteBeam 4.80	4.803	0.654 GiB	663 (26.5%)	0.961	[0.920, 1.003]	0.965	0.783 GiB
F16 reference	16.018	2.182 GiB	690 (27.6%)	1.000	—	1.000	2.752 GiB

Both rungs clear the 0.85 retention bar with the lower bound of the interval, not just the point estimate. The 4.80 rung's in-distribution perplexity is slightly below the F16 base (ratio 0.965) — a measured, reproducible effect of low-bit quantization, not an error.

Head-to-head with stock llama.cpp quants

Same base GGUF, same importance matrix, same benchmark and protocol. Stock quants are built with llama-quantize's built-in recipes; LiteBeam uses the tensor map in this repo.

file	bpw	size	correct / 2500	retention	vs LiteBeam 3.89
stock Q2_K	3.304	0.450 GiB	526 (21.0%)	0.762	LiteBeam +4.6 points
LiteBeam 3.89	3.885	0.529 GiB	641 (25.6%)	0.929	—
stock Q3_K_M	4.104	0.559 GiB	630 (25.2%)	0.913	tied (p = 0.60), LiteBeam 5.3% smaller
LiteBeam 4.80	4.803	0.654 GiB	663 (26.5%)	0.961	—
stock Q4_K_M	4.996	0.681 GiB	658 (26.3%)	0.954	tied (p = 0.77), LiteBeam 3.9% smaller

At the low end the padding is the story: stock Q2_K collapses to 21.0% while LiteBeam 3.89 holds 25.6% for 0.6 more bits per weight. At the top end LiteBeam delivers the same accuracy in a smaller file.

Pick your rung

you want	take	why
Smallest footprint	3.89 bpw	542 MiB, 0.659 GiB VRAM, 217 tok/s decode on GPU
Highest fidelity	4.80 bpw	statistically indistinguishable from F16 (p = 0.081)
Long-form writing	4.80 bpw	no repetition loops in the 50-prompt generation check
Classification, extraction, short answers	3.89 bpw	higher decode throughput, same measured accuracy as Q3_K_M
CPU-only host	3.89 bpw	153 tok/s prefill, 48 tok/s decode at 12 threads

In a 50-prompt generation sanity check (40 held-out instruction/QA prompts plus 10 chat prompts, greedy, 512-token budget), both rungs produced 50/50 non-empty responses and zero role/token leaks. The 4.80 rung produced no repetition loops and no malformed output; the 3.89 rung showed one repetition loop on a single long-form instruction, which is why long-form work is routed to 4.80.

Speed

Measured on the exact files in this repo.

GPU — RTX 4050 Laptop (6 GiB), Vulkan, -ngl 99, 12 threads:

rung	prefill (pp512)	decode (tg64)
3.89 bpw	7,498 ± 85 tok/s	217.3 ± 1.0 tok/s
4.80 bpw	8,873 ± 12 tok/s	210.3 ± 1.2 tok/s

CPU — Intel Core i7-12650H, 12 threads, Vulkan device hidden so the measurement is genuinely CPU-only:

rung	prefill (pp512)	decode (tg64)
3.89 bpw	152.8 ± 0.5 tok/s	47.9 ± 0.3 tok/s
4.80 bpw	228.8 ± 1.9 tok/s	39.6 ± 1.0 tok/s

Quick start

llama.cpp

llama-server -m LFM2.5-1.2B-LiteBeam-3.89bpw.gguf -c 4096 --port 8080

Ollama (ollama create litebeam-1b2 -f Modelfile):

FROM ./LFM2.5-1.2B-LiteBeam-3.89bpw.gguf
PARAMETER temperature 0.7
PARAMETER num_ctx 4096

LM Studio — drop the GGUF in your models directory and load it. Any OpenAI-compatible client — point at http://127.0.0.1:8080/v1.

LFM2.5 uses the LFM chat template. With llama-server, pass --jinja to have the template read from the GGUF metadata automatically:

llama-server -m LFM2.5-1.2B-LiteBeam-3.89bpw.gguf --jinja -c 4096

What is inside

16 layers, hidden size 2,048, 32 attention heads / 8 KV heads, 65,536-token vocabulary, 128k native context.

tensor group	3.89 bpw	4.80 bpw
`attn_v` (all layers)	Q5_K	Q5_K
`attn_q` / `attn_k` / `attn_output`	Q4_K	Q5_K
FFN gate/down/up (bulk)	Q3_K	Q4_K
FFN first + last block	Q4_K	Q5_K
`shortconv` in/out	Q4_K	Q4_K
`token_embd`	Q4_K	Q5_K

The full maps are in maps/ as plain text — 21 override lines each, the same input llama-quantize --tensor-type-file consumes.

Verification

file	bytes	sha256
`LFM2.5-1.2B-LiteBeam-3.89bpw.gguf`	568,353,152	`231b6e36cdb5480db0bd30b0a7b07188635ed1622c41efb3b73dce8a8611517d`
`LFM2.5-1.2B-LiteBeam-4.80bpw.gguf`	702,570,880	`a84f57b5fdaa431df8f6862f74c82aaca13c569e5adaedf7afe1f552bf0e1bf8`
`maps/LiteBeam-1.2B-3.89bpw.map`	—	`c1ea955efd81eade9d8921a5a96c4821a9e86aeb039e94467ff82f014d525f07`
`maps/LiteBeam-1.2B-4.80bpw.map`	—	`c9c9ff3b6edda7b7b0170288ba71de484f0f66d65f38985fd57bfdfc7125839e`

Tensor types were read back from the GGUF files on disk: attention V is exactly Q5_K on all 6 V tensors in both rungs, and token_embd is Q4_K (3.89) / Q5_K (4.80). The benchmark artifacts behind every number above are pinned in INSTRUMENTS.sha256.

Reproduce

# 1. Quantize with the published map
llama-quantize --imatrix imatrix.gguf \
  --tensor-type-file maps/LiteBeam-1.2B-3.89bpw.map \
  LFM2.5-1.2B-Instruct-F16.gguf \
  LFM2.5-1.2B-LiteBeam-3.89bpw.gguf Q4_K 12

# 2. Check the hash against the table above
sha256sum LFM2.5-1.2B-LiteBeam-3.89bpw.gguf

# 3. Re-run the benchmark
python eval_mc.py --model LFM2.5-1.2B-LiteBeam-3.89bpw.gguf \
  --items eval_mc2500.jsonl --out mc2500_12b_389.json \
  --tag mc2500_12b_389 --ctx 2048 --threads 12 --ngl 99

# 4. In-distribution perplexity
llama-perplexity -m LFM2.5-1.2B-LiteBeam-3.89bpw.gguf \
  -f ppl_indist.txt -c 512 -b 512 -ub 512 --chunks 20 -t 12

The importance matrix was computed on 100 chunks of in-distribution text with llama-imatrix (92 entries), and is specific to this base model.

Best fit

Offline chat and assistants on laptops, mini-PCs, and single-board hosts.
Latency-sensitive tooling — extraction, classification, routing, short answers — where 217 tok/s decode on a 6 GiB GPU removes the queue.
Multi-model hosts — at 0.66 GiB of VRAM you can keep it resident next to a larger model.
Distribution — a 542 MiB file ships inside an app installer or a container image without a separate download step.
Reproducible pipelines — the map and hashes let you pin the exact bytes.

For workloads that need the last few points of fidelity, use the 4.80 rung; for anything that needs the model to read source material and stay grounded, give it the material in the prompt — that is a prompt-design question, not a quantization one. When you need more reasoning headroom, step up to the sibling LFM2.5 2.6B LiteBeam (1.19 GiB, 29.4% on the same 2,500-item instrument).

License

Base weights are LiquidAI LFM2.5-1.2B-Instruct, distributed under the LFM Open License v1.0 (see LICENSE). Redistribution is permitted with attribution and the license text; commercial use is licensed for parties below the US$10M annual-revenue threshold. Quantized derivatives must carry a notice that the tensor data was modified. No endorsement by Liquid AI is implied.

LFM2.5-1.2B-Instruct is a model by Liquid AI, Inc., distributed under the LFM Open License v1.0. This GGUF is a quantized derivative work produced by Tablinum; the tensor data was modified by quantization. The LFM Open License v1.0 text must accompany any redistribution.

Built and measured by Tablinum. Benchmark instrument: 2,500 items, 0 exact 50-token overlap with the calibration corpus or the perplexity corpus.