Agent Upstart

Cool things people are building with agents — and practical help getting the most out of them.

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

  1. 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.
  2. Pull the model. Run:
    ollama pull lfm3:1.7b
    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 in ollama list.
  3. Run one short prompt before any agent wiring. Start a chat with ollama run lfm3 and 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.
  4. 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.
  5. 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:11434 by default) with model lfm3: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 a tool message, 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.
  6. 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

What can go wrong

Limits

Related playbooks

Sources

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