Playbooks · Coding tasks
Run Liquid's LFM3-1.7B privately on your own machine: what runs, on what, and what it is not for
Written October 31, 2026
For a builder who wants a private on-device agent model: Liquid AI's LFM3-1.7B does run on an ordinary Linux box through Ollama, at a few tokens per second on a processor alone, inside about 1.15 GB of memory. It is a small model for local agents and tool calls — not a coding model, by its own model card's caution.
What changed
Liquid AI released the LFM3 family on 27 October 2026: six models in the 2-billion-parameter range built on one shared 1.7-billion-parameter backbone. The text model, LFM3-1.7B, is a post-trained, text-only language model with 1.73 billion parameters, a 256,000-token context window, and a 128,000-token vocabulary. The family also includes vision, audio, omni, and decision models on the same backbone, but this page covers the text model only: the other family members were not run for it, and their runtime support differs. The text model is post-trained for agentic harnesses such as Hermes Agent, Pi, and OpenClaw, according to the model card, and it ships in several formats, including a GGUF build for local inference on processors and graphics cards.
This is a different model from the LFM2.5 family. The 2.6-billion-parameter LFM2.5 model is a predecessor, and nothing here carries over a claim about it. The numbers below are for LFM3-1.7B only, measured on one machine, as described under "Measured on one machine".
What the model card claims, with its caveats
Liquid AI's own evaluation table, on the model card, reports LFM3-1.7B scoring 38.42 on WebArena-Verified against 3.02 for LFM2.5-2.6B, 41.29 on AutomationBench against 0.94, and 71.39 on BFCL V4 against 55.89, with an unweighted average of 49.37 across 29 benchmarks against 47.24 for Qwen3.5-9B. Those are vendor-reported figures: the evaluation details state that all models were served with vLLM in BF16 at full context length, and the card's own table shows the model behind larger rivals on several rows, including knowledge tests (GPQA Diamond 63.37 against 80.40 for Qwen3.5-9B) and long-context RULER at 128K (65.56 against 87.11). Treat the table as Liquid AI's comparison under its own conditions, not as an independent result.
The card states two limits that matter more than any benchmark row. First, LFM3-1.7B is designed for local agents, tool calling, structured outputs, and domain-specific fine-tuning, and the card instructs users to use retrieval or search for knowledge-heavy tasks. Second, it states plainly that the model "is not recommended for agentic coding or complex multi-step reasoning due to its small size." The card's table does include coding scores — 43.40 on SWE-bench Verified and 12.92 on Terminal-Bench 2.1, both measured with the OpenCode agent — but the card's own recommendation governs: a benchmark row does not override the author's caution about the job the model is not for.
Measured on one machine
The Ollama route below was run on a Linux box with 4 processor cores, 8 GB of memory, and no graphics card, using Ollama 0.40.13. The pull fetched the lfm3:1.7b tag: a 1.1 GB model file (Q4_K_M quantization, digest 3793e1e6e226). Generation ran through Ollama's local API with thinking disabled and a 1,024-token context. Four short prompts produced coherent answers at 4.1 to 5.6 tokens per second of generation time. The inference process used about 1.15 GB of resident memory during generation at that context length. The first load took about 19 seconds; later prompts loaded in a fraction of a second because the model stayed loaded. These figures describe that one box at a 1,024-token context. A longer context needs more memory for the conversation cache, and a different processor will answer at a different speed. No speed or memory figure from another machine is quoted here, and no figure for the 256,000-token context was measured.
One behaviour showed up in the first run and is worth knowing before building on the model. With thinking left at its default (enabled), an 80-token generation budget was consumed entirely by the model's thinking trace, and the returned answer text was empty — the thinking was present, the answer was not. With thinking disabled for the same prompt, the model returned a coherent one-sentence answer in 44 tokens. If a short answer comes back empty, check whether thinking consumed the token budget before assuming the model failed. The model card notes that reasoning is enabled by default and that disabling it can behave inconsistently, especially for reasoning-heavy tasks, so test the setting on your own task rather than assuming it.
Before you start
Check the licence before building anything commercial on this model. LFM3-1.7B is released under the LFM Open License v1.0, as the model card states. That licence is not an unrestricted open-source licence: its commercial terms include a revenue limit of $10 million in annual revenue, above which the free commercial use does not apply. Read the licence text itself for the entity and use you have in mind; a download does not settle commercial eligibility. Check your Ollama version before the pull: the lfm3 tag requires Ollama 0.40.13 on this platform, and an older Ollama refuses the pull or fails to load the model. This page covers the Linux Ollama route only. The GGUF build documents other routes — llama.cpp (supported in b11960 / v0.8.0 and newer), LM Studio, and Llama.app — but those routes were not run for this page, and no speed or memory claim is made for them.
Steps
- Install Ollama 0.40.13 or newer and confirm the version. Install from Ollama's own download page for your platform, then run
ollama --version. If the version is below 0.40.13, update before pulling: the model requires that version or newer, as its model record states. - Pull the model. Run:
The download is about 1.1 GB. Plan for it on a slow connection, and do not start agent work that depends on the model until the pull completes and the model appears inollama pull lfm3:1.7bollama list. - Run one short prompt before any agent wiring. Start a chat with
ollama run lfm3and ask something small with a checkable answer. Read the whole reply, including any thinking trace. If the reply is empty, the thinking trace may have consumed the token budget, as described above — try again with thinking disabled or a larger token limit before concluding the model does not work. - Measure speed and memory on your own machine. Time a fixed prompt at a fixed token limit, and watch the inference process's memory while it runs. The figures above — a few tokens per second on a processor alone, about 1.15 GB at a short context — are one box's numbers. Your box decides whether the model is fast enough for the job, and a longer context or a longer session changes the memory figure.
- Wire an agent program to the local model, not to a cloud key. Point the agent program at Ollama's local API (
http://127.0.0.1:11434by default) with modellfm3:1.7b. The model card states that generated tool calls use an XML format and that the calling program must parse the call, run the named function, and return the result as atoolmessage, keeping the tool schemas on every request. Test one real tool call before building a workflow on it: a program that only understands JSON tool calls will not understand this model's default output unless the system prompt asks for JSON function calls instead, as the card allows. - Give the model tools that fetch. The card instructs users to use retrieval or search for knowledge-heavy tasks. An agent that leans on this 1.7-billion-parameter model alone for facts will get confident answers no source backs. Give it tools that fetch, and treat unsupported statements as drafts.
What it is not for
- Agentic coding. The model card says so directly, and the measured speed — a few tokens per second on a processor — makes long coding sessions slow. Use a larger model for coding work, or a hosted model, and keep this model to the local-agent and tool-calling jobs the card names.
- Complex multi-step reasoning. The card's caution covers this explicitly. A task that needs long chains of reasoning, or knowledge the model does not have, is the wrong job for a 1.7-billion-parameter model, however private the run is.
- Long-context work at the card's maximum. The 256,000-token context is a card specification, not a measured configuration here. Memory for the conversation cache grows with context, and no figure for a long context was measured on the test box. Confirm memory at the context you actually plan to use before trusting a long session.
- Commercial use above the licence limit. The LFM Open License v1.0 revenue limit applies to the entity using the model commercially. A private experiment and a shipped product are different uses under the licence; read the text before shipping.
What can go wrong
- An old Ollama refuses the pull. The model record requires Ollama 0.40.13. Update Ollama first; a failed pull on an older version is a version problem, not a model problem.
- An empty reply with thinking enabled. A small token budget can be consumed by the thinking trace, leaving no tokens for the answer. Disable thinking for short answers, or raise the token limit, and test the combination on your task.
- Speed that is too slow for the job. A few tokens per second is enough for short classification, extraction, and tool-calling replies. It is not enough for long-form generation under time pressure. Measure on your machine before committing a feature to it.
- Tool calls the program cannot parse. The default XML tool-call format needs a program that implements it. Test one call end to end before building an agent around the model.
Limits
- Only the Linux Ollama route was run for this page, on one 4-core, 8 GB box with no graphics card. No claim is made about Windows, macOS, llama.cpp, LM Studio, or graphics-card runs, and no claim is made about the vision, audio, omni, or decision models in the LFM3 family.
- Benchmark figures are Liquid AI's own, carried with the evaluation conditions the card states. No benchmark was re-run for this page, and no independent capability claim is made.
- Speed and memory figures were measured at a 1,024-token context with short prompts. Longer contexts, longer sessions, and different hardware change both figures.
Related playbooks
- Run Liquid AI's large 24-billion-parameter agent model on your own computer — if your memory fits it
- Run Copilot as the agent in JetBrains Air
- Run a reasoning task on a schedule with GitHub Agentic Workflows: one Markdown file, one reviewed pull request
- Run an open-weight agent with egress denied: what the Qwen sandbox incident does and does not prove
Sources
- https://huggingface.co/LiquidAI/LFM3-1.7B
- https://huggingface.co/LiquidAI/LFM3-1.7B-GGUF
- https://huggingface.co/blog/LiquidAI/lfm3
Back to: Coding playbooks hub · Also: Run Liquid AI's large 24-billion-parameter agent model on your own computer — if your memory fits it