Instructions to use tablinum/lfm2.5-2.6b-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-2.6b-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-2.6b-litebeam
# Run inference directly in the terminal:
llama cli -hf tablinum/lfm2.5-2.6b-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-2.6b-litebeam
# Run inference directly in the terminal:
llama cli -hf tablinum/lfm2.5-2.6b-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-2.6b-litebeam
# Run inference directly in the terminal:
./llama-cli -hf tablinum/lfm2.5-2.6b-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-2.6b-litebeam
# Run inference directly in the terminal:
./build/bin/llama-cli -hf tablinum/lfm2.5-2.6b-litebeam

Use Docker

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

LM Studio
Jan

vLLM

How to use tablinum/lfm2.5-2.6b-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-2.6b-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-2.6b-litebeam",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

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

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

How to use tablinum/lfm2.5-2.6b-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-2.6b-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-2.6b-litebeam"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

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

Lemonade

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

Pull the model

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

Run and chat with the model

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

List all available models

lemonade list

Hermes Agent

How to use tablinum/lfm2.5-2.6b-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-2.6b-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-2.6b-litebeam

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use tablinum/lfm2.5-2.6b-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-2.6b-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-2.6b-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 2.6B LiteBeam

the quality tier — 1.2 GiB, and F16-class answers at 1.5 GiB

A 2.6B chat model in 1.19 GiB · scores level with the stock 4.1 bpw quant · V-protected map · measured on 2,500 questions with confidence intervals

LFM2.5 2.6B LiteBeam

LiteBeam is a hand-built tensor map for LiquidAI/LFM2.5-2.6B-Instruct, not a one-flag quantize. Attention V gets a hard floor at Q5_K on all eight attention layers; embeddings and the first and last blocks get a full rung up; the FFN bulk takes the smallest safe rung.

The result is a 1.19 GiB chat model that matches the stock 4.1 bpw quant — 6.2% larger — on a 2,500-question benchmark, with a 1.48 GiB rung whose accuracy is statistically indistinguishable from the F16 base.

This is the tier to pick when 2.6B-level reasoning matters and you still want the whole model inside a couple of gigabytes.

Why LiteBeam

1. It is smaller than the stock quant it matches. LiteBeam 3.80 bpw scores 734/2500; stock llama.cpp Q3_K_M scores 740/2500. Paired, that is −0.0024 accuracy, p = 0.81 — a statistical tie — in 6.2% fewer bytes (1.194 GiB vs 1.273 GiB).

2. The high-fidelity rung is genuinely F16-class. LiteBeam 4.72 bpw scores 767/2500 against the F16 base's 779/2500: p = 0.45. That is a 1.48 GiB file answering within noise of a 5.03 GiB source, and it also beats stock Q4_K_M on size (5.0% smaller) at the same accuracy (p = 0.40).

3. Sensitive tensors are protected by design. Attention V is pinned at Q5_K on all 8 attention layers, token_embd at Q4_K, and the first and last of the 30 blocks get a full rung up. A uniform quantize does not do this; this map does, and the tensor types are verified on disk.

4. Two rungs, both measured end to end. 3.80 bpw for the smallest footprint, 4.72 bpw for maximum fidelity. Same model, same template, swap the file.

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

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, with a bootstrap confidence interval.

rung	bpw	size	correct / 2500	retention	95% CI	in-dist PPL ratio	VRAM peak
LiteBeam 3.80	3.802	1.194 GiB	734 (29.4%)	0.942	[0.891, 0.995]	0.852	1.356 GiB
LiteBeam 4.72	4.717	1.481 GiB	767 (30.7%)	0.985	[0.948, 1.022]	0.906	1.638 GiB
F16 reference	16.026	5.032 GiB	779 (31.2%)	1.000	—	1.000	5.610 GiB

Both rungs clear the 0.85 retention bar with the lower bound of the interval, not just the point estimate. In-distribution perplexity is below the F16 base on both rungs (ratios 0.852 and 0.906) — 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 use llama-quantize's built-in recipes; LiteBeam uses the tensor map in this repo.

file	bpw	size	correct / 2500	retention	vs LiteBeam 3.80
stock Q2_K	3.247	1.019 GiB	572 (22.9%)	0.734	LiteBeam +6.5 points
LiteBeam 3.80	3.802	1.194 GiB	734 (29.4%)	0.942	—
stock Q3_K_M	4.054	1.273 GiB	740 (29.6%)	0.950	tied (p = 0.81), LiteBeam 6.2% smaller
LiteBeam 4.72	4.717	1.481 GiB	767 (30.7%)	0.985	—
stock Q4_K_M	4.966	1.559 GiB	780 (31.2%)	1.001	tied (p = 0.40), LiteBeam 5.0% smaller

Stock Q2_K gives up 6.5 accuracy points to save 0.55 bits per weight. LiteBeam 3.80 recovers all of that while staying well under a fifth of the F16 size.

Pick your rung

you want	take	why
Smallest footprint	3.80 bpw	1.19 GiB, 1.36 GiB VRAM, 102 tok/s decode on GPU
Highest fidelity	4.72 bpw	p = 0.45 against F16, and 0.985 retention
Long-form writing	4.72 bpw	no repetition loops or hedges in the 50-prompt generation check
Classification, extraction, summarisation	3.80 bpw	22% smaller than 4.72 with the same measured retention class
CPU-only host	3.80 bpw	62 tok/s prefill, 20 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.72 rung produced no repetition loops and no hedged answers; the 3.80 rung showed one repetition loop and two hedges, which is why long-form work is routed to 4.72.

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.80 bpw	3,395 ± 123 tok/s	101.7 ± 2.5 tok/s
4.72 bpw	3,924 ± 71 tok/s	97.9 ± 0.6 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.80 bpw	62.5 ± 0.2 tok/s	20.5 ± 0.4 tok/s
4.72 bpw	97.4 ± 1.4 tok/s	17.2 ± 0.9 tok/s

Quick start

llama.cpp

llama-server -m LFM2.5-2.6B-LiteBeam-3.80bpw.gguf --jinja -c 4096 --port 8080

Ollama (ollama create litebeam-2b6 -f Modelfile):

FROM ./LFM2.5-2.6B-LiteBeam-3.80bpw.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.

--jinja lets llama-server read LFM2.5's chat template straight from the GGUF metadata, so the prompt format always matches the base model.

What is inside

30 layers (22 short-convolution, 8 full-attention), hidden size 2,048, 32 attention heads / 8 KV heads, 128,000-token vocabulary, 131k native context, tied embeddings.

tensor group	3.80 bpw	4.72 bpw
`attn_v` (all 8 attention 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-2.6B-LiteBeam-3.80bpw.gguf`	1,281,697,536	`ce948c842610d8869f543ae89ded1f909e025925e2eac94c46efb78b9030f6df`
`LFM2.5-2.6B-LiteBeam-4.72bpw.gguf`	1,590,273,792	`e214cfbca974d1974412a71327e5758c3468799c3b779e58584fbceca02ade69`
`maps/LiteBeam-2.6B-3.80bpw.map`	—	`f3a62257f249751766f02c85e906b050130a2c91de824303afbc7729cbdde3f7`
`maps/LiteBeam-2.6B-4.72bpw.map`	—	`dbbac1274b3c43fbe35c7e8f515f58b2635b01470a3f3e5fd8f278eacfcd9ead`

Tensor types were read back from the GGUF files on disk: attention V is exactly Q5_K on all 8 V tensors in both rungs, and token_embd is Q4_K (3.80) / Q5_K (4.72). 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-2.6B-3.80bpw.map \
  LFM2.5-2.6B-F16.gguf \
  LFM2.5-2.6B-LiteBeam-3.80bpw.gguf Q4_K 12

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

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

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

The importance matrix was computed on this base model with llama-imatrix (166 entries) over the same in-distribution text.

Best fit

Reasoning-heavy local assistants — the 2.6B tier where the extra 3.8 accuracy points over the 1.2B are worth 630 MiB.
Document work — summaries, rewrites, extraction, and structured answers, with the 4.72 rung for long-form generation.
On-premise deployment — 1.19 GiB fits a 2 GiB container limit with room for the runtime.
Multi-tenant hosts — at 1.36 GiB of VRAM you can run several instances on a single mid-range GPU.
Reproducible pipelines — the map and hashes pin the exact bytes.

For the smallest possible footprint, use the sibling LFM2.5 1.2B LiteBeam at 542 MiB.

License

Base weights are LiquidAI LFM2.5-2.6B-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-2.6B-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.

Downloads last month: -

GGUF

Model size

3B params

Architecture

lfm2

Hardware compatibility

We're not able to determine the quantization variants.

View all variants

Collection including tablinum/lfm2.5-2.6b-litebeam

LiteBeam

Collection

Tensor-mapped LFM2.5 quants that match the stock GGUF they undercut in size — measured on 2,500 items. • 2 items • Updated about 7 hours ago