CanItRun Logocanitrun.

LFM3 1.7B

LFM3 1.7B needs roughly 1.3 GB VRAM at Q4_K_M quantization (4.0 GB at FP16). 117 GPUs we track can run it fully in VRAM at 8k context.

117 GPUs run this natively · 1 with CPU offload

Liquid AI1.73B params256k contextLFM Open License v1.0Commercial use ok
Q4_K_M total
1.3 GB
at 8k context
Smallest GPU
4 GB
Intel Arc A310 4GB, at Q4_K_M
KV cache, full context
3.2 GB
6 of 24 layers grow with context, 5 capped at 256 tokens
Inputs
Text
LFM Open License v1.0, released October 2026
Layer mix
13 : 5 : 6
conv : window : global, of 24 layers
KV cache at 128K
1.6 GB
Liquid states the same figure

LFM3 1.7B is a 1.73B parameter dense model developed by Liquid AI. Released on 27 October 2026 by Liquid AI as the text model of its LFM3 family (Hugging Face repo LiquidAI/LFM3-1.7B), post-trained from LFM3-1.7B-Base for local agents, tool calling and structured output. It has 1.73B parameters, all active on every token. The stack is what Liquid calls a tri-hybrid: of its 24 layers, 13 are gated short convolutions that keep a small constant-size state, 5 are sliding-window attention over the last 256 tokens, and 6 are global attention. Only the 11 attention layers keep a KV cache, and just the 6 global ones grow with context, across a 262,144-token window. It reasons before it answers by default, calls tools in an XML format, supports deferred tool loading for harnesses that search a large tool catalog, and covers 16 languages. It is text only; Liquid ships the vision, audio and omni members of the family as separate models. The license is the custom LFM Open License v1.0, which allows commercial use only below $10 million in annual revenue.

To run LFM3 1.7B locally: Memory is not the constraint. Q4_K_M weights come to 1.05 GB by this site's estimate (Liquid's own Q4_K_M file is 1.10 GB), and 1.30 GB in total with an 8k context, so it fits even a 4 GB Intel Arc A310. The full 262,144-token window adds only 3.2 GB of KV cache, against 12.9 GB if all 24 layers cached the whole context, which puts the full-window total at 4.79 GB at Q4_K_M: that fits a 6 GB card and spills on a 4 GB one. Decode speed is bandwidth-bound, and this site estimates 159.4 tokens per second at Q4_K_M on an 8 GB RTX 4060, 83.0 on a 16 GB M4 and 460.1 on an RTX 5090, at an 8k context. Liquid reports that at 32K context in llama.cpp (Q4_0 files) it prefills at least 2.5 times faster and decodes at least 1.8 times faster than the other models in its table on an AMD Ryzen AI Max+ 395, an Apple M5 Max and an iPhone 17 Pro, which is Liquid's own measurement. GGUF support needs llama.cpp b11960 or newer.

Liquid's card is built around agent and tool-use scores, run in BF16 at full context with vLLM: BFCL V4 71.39, IFEval 96.66, LiveCodeBench v6 73.46, GPQA Diamond 63.37, SWE-bench Verified 43.40 and Terminal-Bench 2.1 12.92 (the last two with the OpenCode agent). Against Qwen3.5 9B in Liquid's own table it leads on BFCL V4 (71.39 against 62.83), WebArena-Verified (38.42 against 28.94) and LiveCodeBench v6 (73.46 against 69.86), and its table average is 49.37 against 47.24. It trails that larger model on knowledge, long context and agentic coding: GPQA Diamond 63.37 against 80.40, RULER 128K 65.56 against 87.11, SWE-bench Verified 43.40 against 51.20 and MCP-Atlas 32.57 against 42.67. The card itself says to use retrieval for knowledge-heavy tasks and does not recommend the model for agentic coding or complex multi-step reasoning. Every score is Liquid's own, and no independent reproduction had appeared when this page was written.

What a full 262,144-token context actually costs

For a model this small, the context is the bill: a long session can need more memory than the weights. LFM3 keeps it low three ways. Thirteen of its 24 layers are convolutions with a constant-size state and no KV cache at all, 5 more look back only 256 tokens, and only the remaining 6 global-attention layers keep a cache that grows with every token.

04711148k64k128k256k256-token window3.2 GBLFM3 1.7B12.9 GBall full
LFM3 1.7B: 6 of 24 layers grow with contextThe same 1.7B if all 24 layers used full, uncapped attention

KV cache only, at FP16. Weights and activation overhead sit on top of these figures.

Filling the whole 262,144-token window costs 3.2 GB of KV cache instead of 12.9 GB, and at 128K tokens it is 1.6 GB against 6.4 GB; Liquid's own figure for 128K is 1.6 GB. Add 1.05 GB of Q4_K_M weights and this site's full-window total is 4.79 GB, which a 6 GB card holds. The same model with every layer caching the whole context would need 15.6 GB, more than an 8 GB or 12 GB card.

VRAM at each quantization

Numbers here are computed at 8k context. This model's hybrid attention stack means KV cache grows much more slowly than context length, unlike a conventional full-attention model.

QuantWeightsKV cacheTotal
FP326.9 GB0.10 GB7.9 GB
BF163.5 GB0.10 GB4.0 GB
FP163.5 GB0.10 GB4.0 GB
Q8_01.8 GB0.10 GB2.2 GB
Q6_K1.4 GB0.10 GB1.7 GB
Q5_K_M1.2 GB0.10 GB1.5 GB
Q4_K_Mrec1.1 GB0.10 GB1.3 GB
Q3_K_M0.8 GB0.10 GB1.1 GB
Q2_K0.7 GB0.10 GB0.8 GB
NVFP4cuda1.8 GB0.10 GB2.1 GB

KV cache is calculated at 8k context (FP16). Note that NVFP4 only runs on CUDA GPUs. Turn on TurboQuant in the calculator above for lower KV cache estimates.

Benchmarks

GPQA Diamond
63.4
IFEval
96.7
LiveCodeBench
73.5
SWE-bench Verified
43.4
Terminal-Bench 2.1
12.9

GPUs that run LFM3 1.7B natively (117)

Show 112 more
Plus 1 GPU that runs it with CPU offload (slower)

No GPU? Rent an RTX 3080 10GB from $0.17/hr ↗

Prices as of Oct 17, 2026. Rates change; check RunPod for current pricing. Affiliate link: CanItRun may earn a commission. Doesn't affect the fit calculation above.

Notes

Released 27 October 2026 by Liquid AI as the text model of the LFM3 family, post-trained from LFM3-1.7B-Base (22T pre-training tokens) for local agents, tool calling and structured output. It is a "tri-hybrid": 24 layers of which 13 are gated short convolutions, 5 are sliding-window attention (256-token window) and 6 are global attention, so only 11 layers keep a KV cache and just 6 of those grow with context. That keeps the cache small: the full 262,144-token window adds 3.2 GB, and Liquid states 1.6 GB at 128K. Liquid's card reports GPQA Diamond 63.4, IFEval 96.7, LiveCodeBench v6 73.5, BFCL V4 71.4, SWE-bench Verified 43.4 and Terminal-Bench 2.1 12.9 (the last two with the OpenCode agent), and compares it with LFM2.5 2.6B, MiniCPM5 2B, Gemma 4 E4B and Qwen3.5 4B and 9B. Every score is Liquid's own, run in BF16 at full context; RULER 128K (65.6 against 84.6 for Qwen3.5 4B) and knowledge benchmarks are its weak side, and the card says to use retrieval for knowledge-heavy tasks and not to use it for agentic coding or complex multi-step reasoning. Reasoning is on by default and the card gives sampling settings for general use (temperature 0.1, top-k 50, repetition penalty 1.1) and for math and science (temperature 1.0, top-p 0.95, top-k 20). Liquid's GGUF repo needs llama.cpp b11960 or newer and includes a Q4_0 file (1.05 GB) trained with quantization-aware distillation to recover the accuracy plain Q4_0 loses. Licensed under the LFM Open License v1.0, which allows commercial use only for organizations under $10 million in annual revenue. Text only, 16 languages.

Hugging Face ↗Ollama ↗Released 2026-10-27

How to run LFM3 1.7B locally

8244880160320

Q4_K_M needs 1.3 GB: fits a single high-end consumer GPU (24 GB).

llama.cpp b11960 or newer (the oldest build Liquid's GGUF card lists), or Ollama, LM Studio, MLX, vLLM and SGLang

./llama-server \
  -hf LiquidAI/LFM3-1.7B-GGUF:Q4_K_M \
  -c 32768 -ngl 99 --jinja \
  --temp 0.1 --top-k 50 --repeat-penalty 1.1

Ollama

ollama run lfm3:1.7b

llama.cpp

# Liquid's quantization-aware-distilled Q4_0 file (1.05 GB), trained to recover the accuracy plain Q4_0 loses
llama-cli -hf LiquidAI/LFM3-1.7B-GGUF \
  --hf-file LFM3-1.7B-QAD-Q4_0.gguf \
  --temp 0.1 --top-k 50 --repeat-penalty 1.1

# Math and science: Liquid's second sampling profile
#   --temp 1.0 --top-p 0.95 --top-k 20

# Older llama.cpp builds fail to load the architecture; update to b11960 (v0.8.0) or newer

LM Studio: Search for 'LFM3-1.7B' and take the Q4_K_M build from LiquidAI (1.10 GB), or Q8_0 (1.85 GB) if you have the memory; the model is small enough that the step up costs little. LM Studio can only load it once its bundled llama.cpp runtime is b11960 or newer, so update the runtime first if the load fails. Use temperature 0.1, top-k 50 and a repetition penalty of 1.1 for chat, tool use and agents, and temperature 1.0, top-p 0.95 and top-k 20 for math and science (Liquid's two profiles). The model reasons before it answers by default; Liquid says switching thinking off can be inconsistent, especially on reasoning-heavy tasks.

Why this quantization? Q4_K_M puts the weights at 1.05 GB by this site's estimate, close to the 1.10 GB file in Liquid's GGUF repo and to Liquid's own "about 1 GB at 4-bit" figure, and the total is 1.30 GB at an 8k context. At this size the quant is not what decides the hardware: Q8_0 is 1.84 GB and BF16 is 3.46 GB, so any card that holds Q4_K_M holds a higher quant too, so go up a step if you can spare it. Context is the second bill and it is small, because only 6 of the 24 layers cache the whole window: the full 262,144 tokens add 3.2 GB of KV cache, for 4.79 GB in total at Q4_K_M. Liquid also ships a quantization-aware-distilled Q4_0 file (1.05 GB), which is the 4-bit build to try first on a phone or a small laptop.

Who is LFM3 1.7B for?

Developers building a local agent, a tool-calling backend or a structured-output service on hardware with very little memory to spare: a 4 to 8 GB GPU, a 16 GB laptop or a phone. All 1.73B parameters are read for every token, but at about 1 GB of weights that is still fast, and this site estimates 159.4 tokens per second at Q4_K_M on an 8 GB RTX 4060 and 83.0 on a 16 GB M4. Liquid also pitches it for fine-tuning to one domain or format with TRL on a single GPU, with notebooks for JSON extraction, retrieval-grounded answers, tool calling and learning a new language.

Best for

  • Local agents and tool calling in harnesses such as Hermes Agent, Pi and OpenClaw, where Liquid post-trained it and reports BFCL V4 71.39
  • Structured output and instruction following: Liquid reports IFEval 96.66 and IFBench 73.03
  • Long-document work on a small card: the 262,144-token window needs only 4.79 GB in total at Q4_K_M, though Liquid's own RULER 128K score is 65.56, so test retrieval quality on your documents
  • A base for domain fine-tuning on one GPU, starting from LFM3-1.7B-Base

Not ideal for

  • Knowledge-heavy questions without retrieval, Liquid's card says to pair it with search or retrieval, and its GPQA Diamond is 63.37 against 80.40 for Qwen3.5 9B in the same table
  • Agentic coding and complex multi-step reasoning, which the card says it is not recommended for (SWE-bench Verified 43.40 and Terminal-Bench 2.1 12.92 with the OpenCode agent)
  • Companies with more than $10 million in annual revenue, the LFM Open License v1.0 does not license their commercial use
  • Image, audio or video input, this is the text model; Liquid ships LFM3-VL, LFM3-Audio and LFM3-Omni separately
  • Anyone who needs the benchmark claims independently verified before adopting a model, it was released on 27 October 2026 and every score is Liquid's own

Which card do you need?

Almost any. Q4_K_M is 1.05 GB of weights and the full 262,144-token window adds 3.2 GB, for 4.79 GB in total, so a 6 GB card holds the whole window and a 4 GB card such as the Intel Arc A310 runs it at a short context. This site estimates 159.4 tokens per second at Q4_K_M on an 8 GB RTX 4060, 83.0 on a 16 GB M4 and 47.0 on a 16 GB M1. The question is not whether it fits but whether it is the right model: Liquid's card says to use retrieval for knowledge-heavy tasks and does not recommend it for agentic coding or complex multi-step reasoning, and in Liquid's own table it trails Qwen3.5 9B on GPQA Diamond (63.37 against 80.40), long context (RULER 128K 65.56 against 87.11) and SWE-bench Verified (43.40 against 51.20) while leading it on tool calling (BFCL V4 71.39 against 62.83). Every score is Liquid's own and the model was a day old when this page was written, so test it on your own tool schemas before relying on it. Companies above $10 million in annual revenue are not licensed to use it commercially.

Explore

Browse all guides →Browse all models →Browse all GPUs →

Frequently asked questions

What are the VRAM requirements for LFM3 1.7B?
LFM3 1.7B requires approximately 1.3 GB of VRAM at Q4_K_M quantization, 2.2 GB at Q8, and 4.0 GB at FP16. These numbers assume 8k context window; its hybrid attention stack caches far fewer than all layers, so VRAM grows much slower than linearly with context.
How many parameters does LFM3 1.7B have?
LFM3 1.7B has 1.73 billion parameters.
Can LFM3 1.7B run on a 16 GB GPU?
Yes. LFM3 1.7B needs 1.3 GB at Q4_K_M, which fits in a 16 GB GPU like the RTX 4080 or RTX 5070 Ti.
What is the smallest quantization for LFM3 1.7B that fits in 24 GB of VRAM?
At BF16, LFM3 1.7B needs 4.0 GB, the highest-quality quantization that fits in 24 GB of VRAM.
What GPU do I need to run LFM3 1.7B locally?
A 16 GB GPU is enough. At Q4_K_M, LFM3 1.7B needs 1.3 GB VRAM. Good options: RTX 4080 (16 GB), RTX 5070 Ti (16 GB).
Can I run LFM3 1.7B in the cloud?
Yes. The cheapest RunPod setup we found that holds LFM3 1.7B entirely in GPU memory at 8k context is 1× RTX 3080 10GB at BF16, at roughly 147.8 tokens per second and from $0.17 per hour for the whole pod. Prices as of Oct 17, 2026; RunPod rates change, so check their pricing page for the current figure.
How much VRAM does LFM3 1.7B need?
The Q4_K_M weights are 1.05 GB by this site's estimate, close to the 1.10 GB file in Liquid's GGUF repo, and 1.30 GB in total at an 8k context. Q8_0 is 1.84 GB and BF16 is 3.46 GB. The full 262,144-token window adds 3.2 GB of KV cache, for 4.79 GB in total at Q4_K_M: a 6 GB card holds it, and a 4 GB card such as the Intel Arc A310 holds the model at a short context but spills at the full window.
Why is LFM3 1.7B's KV cache so small?
Only 6 of its 24 layers are global attention that cache every token. Thirteen layers are gated short convolutions that keep a small constant-size state, and 5 are sliding-window attention that cache at most 256 tokens. That holds the full 262,144-token window to 3.2 GB of KV cache; if all 24 layers cached everything it would be 12.9 GB. At 128K tokens this site's figure is 1.6 GB, matching the 1.6 GB Liquid states.
Is LFM3 1.7B good for coding agents?
Not by Liquid's own account. The card says it is not recommended for agentic coding or complex multi-step reasoning because of its size. Its reported scores with the OpenCode agent are SWE-bench Verified 43.40 and Terminal-Bench 2.1 12.92, behind Qwen3.5 9B (51.20 and 17.98) in the same table. Where it does lead is tool calling and web tasks: BFCL V4 71.39 and WebArena-Verified 38.42, against 62.83 and 28.94 for Qwen3.5 9B.
Which llama.cpp version runs LFM3 1.7B?
Liquid's GGUF card lists support in llama.cpp b11960 (v0.8.0) and newer; older builds do not know the architecture. Ollama has a library tag, ollama run lfm3:1.7b, which is 1.7 GB, though its page does not state the quantization. For tool use with llama.cpp, load a GGUF with the current chat template or pass --chat-template-file, as Liquid's card says.
Can I use LFM3 1.7B commercially?
Only if your organization is under $10 million in annual revenue. The LFM Open License v1.0 licenses commercial use below that threshold and does not license it above, and it exempts qualified non-profits using the model for non-commercial or research purposes. It is a custom license rather than Apache 2.0 or MIT, so read the LICENSE file in the repository before building a product on it.