How to Run Liquid AI LFM3 Locally: Setup, Hardware Requirements, and Benchmarks

Yes. You can run the text model, LFM3-1.7B, on your own computer. Liquid AI released the LFM3 family on October 27, 2026, and the text checkpoint is the simplest starting point for learning how to run Liquid AI LFM3 locally. Liquid says the model’s 4-bit weights take about 1 GB. That figure covers the weights only. The runtime also needs memory for activations, buffers, and the key-value cache, which grows with context length, so total memory use is higher.

This guide covers which checkpoint to choose, what hardware to check, how to install and run the model, how to measure speed and memory, and how to fix common errors. The technical details come from Liquid AI’s release post, the official model card, and runtime documentation. I have not executed the commands on a test machine, so treat the code as official documentation examples until you run them yourself.

Quick Summary: What You Need to Run LFM3 Locally

The shortest verified route is to install the latest Transformers library and load LiquidAI/LFM3-1.7B from Hugging Face with the official example. For lower memory use, download the GGUF build and run it with llama.cpp.

What Is Liquid AI LFM3?

LFM3 is Liquid AI’s new generation of Liquid Foundation Models. All six released models branch from one base model, LFM3-1.7B-Base, which was pre-trained on 22 trillion tokens. Liquid says the new architecture lets LFM3-1.7B outperform its predecessor, LFM2.5-2.6B, while using 35% fewer parameters. The model combines gated short convolutions, sliding-window attention, and global attention across 24 layers.

For local use, the important point is the size and memory profile. Liquid designed the family to run on phones, laptops, and edge hardware, and it publishes memory measurements for a few of those devices.

Which LFM3 Model Should You Choose?

These models are not interchangeable. The install commands differ too. Liquid’s Hugging Face tutorial lists Transformers 5.21.0 or newer for LFM3-VL-2B, and 5.20.2 or newer for LFM3-Omni-2B with its vision and audio dependencies. This guide uses the text model because its setup is the simplest.

Why Run LFM3 Locally?

Local inference gives you control over where your prompts and documents are processed. Once the weights are on disk, the runtimes described here do not need to send your prompts to a server. You also avoid a per-token API bill, although you still pay for hardware, electricity, and maintenance.

Local deployment does not make an application secure on its own. Logging, storage, access controls, and the rest of your application still need their own safeguards.

Liquid AI LFM3 Hardware Requirements

Minimum Hardware Considerations

Several components determine whether a setup works:

• CPU and system RAM: CPU-only runtimes load model weights into system memory, so RAM must be large enough for the file and the runtime.
• GPU and VRAM: GPU offload moves layers or weights onto the graphics card. Speed usually improves, but only if the model and cache fit.
• Storage: The model files and any tooling need disk space. The BF16 checkpoint is roughly 3.5 GB by simple arithmetic (1.73 billion parameters at 2 bytes each). This is my calculation, not an official figure.
• Quantization: A 4-bit build is far smaller. Liquid states the text model fits in about 1 GB at 4-bit precision, which matches the arithmetic (1.73 billion parameters at 0.5 bytes each is about 0.9 GB before overhead).
• Context and output length: Longer prompts and longer answers increase memory use and slow generation.
• Backend: CUDA, Metal, Vulkan, and CPU backends behave differently, even on the same machine.

Liquid’s release does not publish a minimum system configuration. Any specific RAM or VRAM target you see elsewhere should be treated as an estimate until you measure it.

Can You Run LFM3 on a Laptop?

Laptops can run LFM3-1.7B in a 4-bit GGUF build on CPU or GPU, according to the memory profile Liquid publishes. Liquid’s device tests cover three systems: an Apple M5 Max laptop using the Metal backend, an AMD Ryzen AI Max+ 395 system using its integrated Radeon 8060S GPU with Vulkan, and an iPhone 17 Pro. Those are the only consumer devices with published measurements in the sources I reviewed. I have not tested a typical laptop.

CPU-only inference works with llama.cpp and a GGUF file. GPU-accelerated inference through llama.cpp, MLX, or vLLM usually requires a compatible GPU driver and backend. Apple Silicon machines can use MLX with the 4-bit MLX checkpoint, or llama.cpp with Metal. Desktop NVIDIA GPUs are the natural target for vLLM and SGLang, which Liquid’s model card documents with BF16 weights.

How Much RAM or VRAM Does LFM3 Need?

Memory use has several parts: weights, runtime overhead, activations during computation, and the key-value (KV) cache that stores attention state for the context. The KV cache grows as the context gets longer.

Liquid’s published memory figures come from llama.cpp with Q4_0 weights at a 32K-token context. For a full 128K-token context, Liquid reports that the KV cache needs 1.6 GB, compared with 4.3 GB for Qwen3.5-4B and 5.6 GB for MiniCPM5-2B. The model supports a 256K-token context, but I found no published KV cache size for that length. Your actual use will differ with your runtime, quantization, and backend.

How to Run Liquid AI LFM3 Locally

This section follows the official Transformers path first, then covers GGUF, MLX, and server options.

Step 1: Download the Official LFM3 Model

The official text checkpoint is LiquidAI/LFM3-1.7B. The model card describes it as a post-trained, text-only language model with a 256K-token context window. Choose this checkpoint for chat, tool calling, and structured-output tests.

The base checkpoint, LFM3-1.7B-Base, is intended for further training. Use it only if you plan to run your own post-training. For a first run, the post-trained model is the right choice.

Step 2: Install the Required Dependencies

Create a clean Python environment:

bash

python -m venv lfm3-env

source lfm3-env/bin/activate        # Windows: lfm3-env\Scripts\activate

pip install -U transformers accelerate

The accelerate package supports device_map=”auto”, which the model card uses. Install PyTorch separately using the command generated by the official PyTorch site for your operating system and GPU. The correct PyTorch build differs between CUDA, CPU, and Apple Silicon systems, so avoid copying one PyTorch command to every machine.

Step 3: Load LFM3-1.7B with Transformers

The following example reproduces the Transformers quick start on the official model card:

python

from transformers import pipeline

generator = pipeline(

    “text-generation”,

    model=”LiquidAI/LFM3-1.7B”,

    trust_remote_code=True,

)

messages = [{“role”: “user”, “content”: “What is C. elegans?”}]

output = generator(

    messages,

    do_sample=True,

    temperature=0.1,

    top_k=50,

    repetition_penalty=1.1,

    max_new_tokens=2048,

)

print(output[0][“generated_text”][-1][“content”])

The settings follow Liquid’s recommended sampling values for general chat, tool use, and agent tasks: temperature 0.1, top-k 50, and repetition penalty 1.1. The trust_remote_code=True flag appears in the official card, so keep it. Reasoning is enabled by default in this model, so the reply may begin with reasoning text. The model card notes that enable_thinking=False can disable reasoning traces, but the behavior can be inconsistent on reasoning-heavy tasks.

I have not run this script. It is based on the official documentation.

Step 4: Run Your First Prompt

Use the prompt in the example above, or any short factual question. A successful run prints a coherent answer. If reasoning is enabled, the answer may include reasoning text before the final reply.

The first run takes longer because the weights must download and cache. The BF16 checkpoint is about 3.5 GB by arithmetic, so the download time depends on your connection. Later runs load the cached files. If the script fails while loading the model, check the error for missing dependencies, an outdated Transformers version, or insufficient memory. Upgrading with pip install -U transformers resolves outdated-library problems.

Step 5: Choose an Alternative Local Runtime

For llama.cpp, clone the project and build the binaries:

bash

git clone https://github.com/ggerganov/llama.cpp.git

cd llama.cpp

cmake -B build

cmake –build build -j –target llama-server llama-cli

./build/bin/llama-cli -hf LiquidAI/LFM3-1.7B-GGUF:Q4_K_M

Use llama-server instead of llama-cli to start a local OpenAI-compatible server with a web interface. For vLLM on a supported NVIDIA GPU, install vllm and run vllm serve “LiquidAI/LFM3-1.7B”. The model card then shows a curl request to the local endpoint on port 8000.

Ollama is the runtime I could not confirm for LFM3. Liquid’s Ollama documentation covers LFM2 and LFM2.5 GGUF models with the hf.co/<repository>:<quantization> pattern, but I did not find an official LFM3 example. Check the current Liquid and Ollama documentation before using it.

How to Test LFM3 Local Inference

A reliable test separates loading, prompt processing, and generation:

1. Load success: The model loads without an error and reports the expected architecture.
2. Time to first token: Measure how long the model takes to start producing output after you send a prompt.
3. Prefill speed: This is how fast the runtime processes your input prompt, measured in tokens per second.
4. Decode speed: This is how fast the model generates new tokens, also measured in tokens per second. It is the number most people mean by “speed.”
5. Peak memory: Watch nvidia-smi on NVIDIA GPUs, Activity Monitor on macOS, or Task Manager on Windows.
6. Output quality: Check instruction following and factual accuracy on a short fixed set of prompts.
7. Context behavior: Repeat the test with prompts of about 2K, 8K, and 32K tokens to see how speed and memory change.

Use the same prompt, the same output limit, and the same sampling settings for each run. A fixed max_new_tokens value, such as 256, makes results comparable. Recent llama.cpp builds print timing summaries, so check your build’s output for prompt and generation speed.

Liquid AI LFM3 Benchmarks: Speed, Memory, and Quality

Liquid’s benchmark numbers are vendor-reported. I did not find independent reproductions at the time of writing.

What Do the Official LFM3 Benchmarks Show?

Liquid’s model card compares LFM3-1.7B with LFM2.5-2.6B and several larger models. Selected results are below. Liquid states that most evaluations used vLLM in BF16 at full context, temperature 0.6, and top-p 0.95, with exceptions listed in the card.

The pattern is clear. LFM3-1.7B leads on tool use, instruction following, and browser-based agent tasks in this comparison. It trails the larger Qwen3.5-9B on coding, graduate-level knowledge, and long-context retrieval. Liquid’s own model card says the model is not recommended for agentic coding or complex multi-step reasoning because of its size.

For device speed, Liquid reports llama.cpp results at Q4_0 with a 32K context, batch size 1, 100 output tokens, and GPU offload on three devices. It states that LFM3-1.7B prefills at least 2.5 times faster and decodes at least 1.8 times faster than every compared model, while using the least memory. The absolute tokens-per-second values appear in a chart on the model card, which I could not read as text, so check that chart directly before quoting numbers.

On a single NVIDIA B300 running SGLang in BF16, Liquid reports that LFM3-1.7B can produce 3.6 billion tokens per day at 1,024 concurrent requests. This is a server throughput figure, not a measure of single-user speed on a laptop.

How to Measure LFM3 Tokens per Second

Record the following for every run:

Run each test at least three times and report the median. Close other memory-heavy applications first, and note whether the laptop was plugged in, because power modes can change results.

How Does LFM3 Compare with Other Small Models?

The only comparisons with clear conditions in the sources I reviewed come from Liquid’s own evaluation. Those results compare LFM3-1.7B with LFM2.5-2.6B, MiniCPM5 2B, Gemma 4 E4B, Qwen3.5 4B, and Qwen3.5 9B. An independent leaderboard entry for LFM3 was not available when I checked, so avoid declaring a winner from vendor numbers alone. For your own decision, run the same prompts and tasks on the models you are considering, using the same runtime and quantization.

Read More: ChatGPT vs Claude vs Gemini: Which AI Assistant Fits Your Workflow?

Common LFM3 Installation and Runtime Errors

When an error does not match this table, check the exact message against the Transformers, llama.cpp, or vLLM documentation for your version. Avoid applying fixes from LFM2 or LFM2.5 tutorials without checking that they apply to LFM3.

Practical LFM3 Use Cases and Limitations

LFM3-1.7B fits several workloads well. It is designed for local agents, tool calling, and structured outputs, and Liquid says it can be post-trained for agent harnesses such as Hermes Agent, Pi, and OpenClaw. It is a practical base for structured data extraction from documents, domain-specific assistants, and offline prototypes where the model should stay on the device.

Its limits matter as much as its strengths. The model card says to use retrieval or search for knowledge-heavy tasks. It is not recommended for agentic coding or complex multi-step reasoning. Benchmark scores on tool use do not guarantee reliability in your own workflow, so test with your actual tools, prompts, and failure cases before deploying it.

The license also matters. LFM3 uses the LFM Open License v1.0, which is based on Apache 2.0 with one key condition. Free commercial use is limited to companies with annual revenue below $10 million USD. Above that threshold, you need a commercial license from Liquid AI, and the license lists [email protected] as the contact. Qualified nonprofits can use the models for non-commercial or research purposes without the revenue threshold. Read the license text before building a product on it.

Final Verdict

LFM3 is worth testing if you want a small, open-weight text model for local agents, tool calling, or structured outputs, and if you can tolerate its limits on coding and complex reasoning. Beginners should start with the official Transformers example, because it matches Liquid’s documentation and requires the fewest moving parts. Users who want lower memory use or a graphical interface can evaluate the GGUF build with llama.cpp or LM Studio.

Your practical next step is to run the Transformers example with the prompt “What is C. elegans?”, record the load time and peak memory, then rerun the same prompt through llama.cpp with the Q4_K_M build. Compare the decode speed and answer quality on your own hardware before using LFM3 for a real workload.

Frequently Asked Questions

Can I run Liquid AI LFM3 on a laptop?

Yes, the text model LFM3-1.7B can run on a laptop in a 4-bit build, and Liquid publishes memory measurements for an Apple M5 Max and an AMD Ryzen AI Max+ 395 system. I have not measured a typical laptop, so test your own machine.

How much RAM does LFM3-1.7B need?

Liquid does not publish a minimum RAM figure. The 4-bit weights take about 1 GB, and total memory use also includes runtime overhead and the KV cache for your context length.

What are the LFM3 VRAM requirements?

Liquid publishes no official VRAM minimum. A quantized GGUF build with GPU offload uses far less VRAM than the BF16 checkpoint, which is roughly 3.5 GB by arithmetic before overhead.

Can I run LFM3 without a GPU?

Yes. A GGUF file runs through llama.cpp on the CPU. Speed depends on your processor and memory, so measure it with a fixed prompt.

How do I run LFM3 with Ollama?

I could not verify an official LFM3 Ollama command at the time of writing. Liquid’s documented Ollama pattern for other GGUF models uses hf.co/<repository>:<quantization>, but check the current Liquid and Ollama documentation before relying on it for LFM3.

How do I install LFM3 using Hugging Face Transformers?

Run pip install -U transformers accelerate, then load LiquidAI/LFM3-1.7B with trust_remote_code=True using the pipeline example from the model card. The first run downloads the weights.

Can LFM3 run offline?

Yes, after the weights are downloaded and cached. The runtimes in this guide run inference on your device without a server connection, but the first download requires internet access.

How fast is LFM3 on local hardware?

Liquid reports that LFM3-1.7B decodes at least 1.8 times faster than the compared models on its three test devices at a 32K context. The exact tokens-per-second values are in a chart on the model card, and your results depend on your hardware and runtime.

Is Liquid AI LFM3 free to use locally?

The weights are available under the LFM Open License v1.0. Companies with annual revenue below $10 million USD can use the model commercially at no cost under the license. Larger companies need a commercial license from Liquid AI.

What is the difference between LFM3-1.7B and the other LFM3 models?

LFM3-1.7B is the text-only model. LFM3-VL-2B adds image and video understanding, LFM3-Audio-2B handles speech input and output, LFM3-Omni-2B combines vision, audio, and text, and the d1 models return structured decisions from text, images, or audio.