A 1.7B Model That Claims to Replace a 9B One: LFM3 on Ollama

Liquid AI's LFM3 is a gigabyte-sized model claiming to do agentic work that needed 9B parameters. What its own benchmarks show, and the licence nobody quotes.

Flat illustration of a small dark square beside a larger pale square on a cream background
9 min read
1,841 words

The LFM3 local model is a download of between one and two gigabytes that its own model card says can power agentic applications which previously needed around nine billion parameters. That is either the most useful thing to happen to local AI this month or a benchmark artefact, and the publisher’s own numbers are enough to tell which — they just have to be read past the average.

It arrived in Ollama on 27 October with v0.40.12, Apple hardware only, and went cross-platform two days later in v0.40.13. One command gets it:

ollama run lfm3

What the LFM3 local model actually gives you

Nine tags, and the thing to notice is what they have in common.

Ollama tag listing for lfm3 showing nine entries from 1.0GB to 3.5GB, each with a 256K context window and Text as its only input
Ollama's lfm3 tags, captured 31 Oct 2026: nine tags, every one the 1.7B text model, 1.0GB to 3.5GB.

Every tag is the same 1.73B text model in a different quantisation or format. lfm3:1.7b-qad-q4_0 is the smallest at 1.0GB, q4_K_M is 1.1GB, q8_0 is 1.8GB, and the bf16 and MLX bf16 builds are 3.5GB. There are MLX variants for Apple Silicon and an nvfp4 at 1.7GB. All of them list 256K of context and Text as the only input.

That last column matters because the LFM3 family on Hugging Face includes vision, audio and omni members, and coverage elsewhere lists them together. They are not packaged for Ollama. If you pull lfm3 expecting to hand it an image, you will be handing an image to a text model.

The capability chips on the page say tools and thinking, which is the actual point of this model and the reason the benchmark split looks the way it does.

One more number from the card is worth knowing before you judge it on non-English text: the vocabulary is 128,000 tokens. That is large for a model this size, and it is what makes sixteen languages plausible rather than nominal — a small vocabulary forces unfamiliar scripts to be chopped into many more tokens, which burns context and degrades quality in exactly the languages that are already least well served.

Where its own numbers say it wins and loses

The model card publishes a comparison against Qwen3.5-9B. These are the publisher’s figures on the publisher’s choice of benchmarks, and they are also the only quality data anyone has published, so read them as a shape rather than a verdict.

On instruction following and tool use it genuinely beats a model five times its size. IFEval comes in at 96.66 against 92.08. BFCL V4, which measures function calling, is 71.39 against 62.83. ToolSandbox is 80.36 against 76.41. LiveCodeBench v6 is 73.46 against 69.86.

Then the other half. GPQA Diamond — graduate-level knowledge questions — is 63.37 against 80.40. SWE-bench Verified is 43.40 against 51.20. RULER at 128K, which tests whether a model can actually retrieve from a long context, is 65.56 against 87.11.

The card’s headline average is 49.37 against 47.24, which is how a model loses three benchmarks badly and still finishes ahead. The average is the least informative number on the page. The shape underneath it is unambiguous: this thing follows instructions and calls tools extremely well for its size, and it does not know very much.

That is not a criticism. A 1.7B model that knows things would be a surprising claim. The card itself draws the same line, warning that it is “not recommended for agentic coding or complex multi-step reasoning due to its small size” — which sits oddly beside the nine-billion-parameter claim in the same document, and the benchmark table is how you reconcile them. It replaces a 9B model at the jobs in the first group, not the second.

Why a 1.7B model can win at tool calling

The architecture explains the split, and it is unusual enough to be worth a paragraph. The card describes 24 layers made of three different things: 13 gated short convolution layers, 5 sliding-window attention layers, and 6 global attention layers. Ollama’s own page calls it a tri-hybrid model.

Models this size are usually built from attention layers throughout. Attention is what lets a model relate any token to any other token, and it is also the expensive part. Replacing more than half the stack with short convolutions — which only look at a narrow local window — buys a lot of parameters back, and it costs you precisely the thing convolutions cannot do: relate something at the start of a long document to something at the end. Six global attention layers are left to carry that work for the whole model.

Read the benchmark table again with that in mind and it stops looking like a mystery. Following an instruction, filling a function signature correctly, producing valid structured output: all local pattern work, all well served by convolution. Recalling a graduate-level fact or finding a needle at 128K: global work, and there are six layers of it. The architecture is at least consistent with the scores.

The 256K context is not what it looks like

Every tag advertises a 256K context window covering input and output together. The RULER 128K score is 65.56.

Those two facts belong next to each other. A context window is how much text the model will accept; a RULER score is how much of it the model can still find things in. Feeding this model a 200-page document because the window technically allows it will produce confident answers drawn from whichever part it managed to hold onto. The 9B model it is compared against scores 87.11 on the same test, so this is not a small-model limitation in general — it is this model’s particular trade.

Treat the window as headroom for a long conversation or a big tool-call transcript, not as a retrieval system. If the job is finding one clause in a long contract, that is a retrieval problem and the answer is to retrieve first and let the model read the excerpt.

Running it

Pull the default and you get a quantisation that fits anywhere:

ollama pull lfm3
ollama run lfm3 "List three things to check before deploying."

If you want the best quality the family offers locally and have the memory, lfm3:1.7b-q8_0 at 1.8GB is the sensible step up; bf16 at 3.5GB is for comparison work rather than daily use. On Apple Silicon the MLX builds exist for the same reason the MLX runner exists, and lfm3:1.7b-mxfp8 at 2.1GB is the middle option.

A worked example of the job it is good at, using the tool-calling support directly:

curl http://localhost:11434/api/chat -d '{
  "model": "lfm3",
  "messages": [{"role": "user", "content": "Push the Tuesday meeting with Dana to Thursday at 10"}],
  "tools": [{
    "type": "function",
    "function": {
      "name": "reschedule",
      "description": "Move an existing calendar event",
      "parameters": {
        "type": "object",
        "properties": {
          "attendee": {"type": "string"},
          "new_day": {"type": "string"},
          "new_time": {"type": "string"}
        },
        "required": ["attendee", "new_day", "new_time"]
      }
    }
  }],
  "stream": false
}'

That is the shape of task the benchmarks say it handles better than a 9B model: take an ordinary sentence, pick the right function, fill the arguments. Notice what it is not being asked to do — know who Dana is, work out which Tuesday, or decide whether the move is wise. Those belong to your code and your calendar API.

The card publishes sampling settings, which is rarer than it should be and worth using. For general chat, tool use and agents: temperature 0.1, top_k 50, repetition penalty 1.1. For maths and STEM: temperature 1.0, top_p 0.95, top_k 20. The low default temperature tells you what the model is tuned for — predictable structured output rather than interesting prose.

It supports tools and thinking, so it slots into the same local tool-calling loop as anything else in the library; the mechanics are the ones in building a first AI agent with Ollama. The sixteen supported languages are English, Arabic, Chinese, French, German, Italian, Japanese, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Russian and Polish.

The licence has a revenue ceiling

This is the part every other page about LFM3 leaves out, and it is one file away from the model card.

The LFM Open License v1.0 defines a Threshold in section 1 as “annual revenue of 10 million United States dollars ($10,000,000) or more”. Section 5(a) conditions the commercial-use grant on not exceeding it. Section 5(b) is blunter: any commercial use of the work or a derivative by a legal entity that exceeds the Threshold is not licensed under the agreement. Section 5(c) carves out qualified non-profits for non-commercial and research use.

So this is open weights with a size test attached. A freelancer, a startup or a small agency is inside the grant. A company over $10 million in revenue needs a separate agreement with Liquid AI before it puts this model in anything commercial — and “open weights” in a search result will not tell them that.

The rest of the obligations are conventional but real if you redistribute: section 4 requires passing the licence on to recipients, marking any files you changed with prominent notices, retaining copyright, patent, trademark and attribution notices, and reproducing any NOTICE file. Section 7 grants no trademark rights. Section 11 terminates the licence automatically if you fail to comply.

Whether a fine-tuned model counts as a derivative work is the question the licence does not answer directly — it defines derivative works as those based on or derived from the work and never mentions fine-tuning. If you are planning to fine-tune this and ship the result, that is a question for someone qualified rather than a blog. It is the third licence trap this site has found in a month, after Phonon’s non-commercial speech checkpoints and an open-source Mac search tool whose code and model weights carry different terms.

What it is actually for

Not as your assistant. As a component.

The jobs it fits are the bounded, repetitive, structured ones: turning a messy request into a function call, extracting fields, routing something, deciding which of five things a message is. Work where you supply the knowledge and the model supplies the structure. For that it is remarkable value at a gigabyte, and it runs on hardware you already own without a fan spinning up.

The jobs it does not fit are the ones where the model needs to know something you did not tell it, reason through several steps, or hold a long document in mind. Its own card says so. The honest summary of LFM3 is not that a 1.7B model is now as good as a 9B one, but that the gap between them has collapsed in exactly one dimension — following instructions and calling tools — and stayed wide everywhere else. For a lot of local automation, that one dimension is the whole job.

Sources

Every figure in this article traces to one of these. Dates are when the page was read.

  1. LFM3-1.7B model card
    Liquid AIAccessed Oct 31, 2026Official docs
  2. LFM Open License v1.0
    Liquid AIAccessed Oct 31, 2026Official docs
  3. lfm3 tags
    OllamaAccessed Oct 31, 2026Official docs
  4. Releases
    OllamaAccessed Oct 31, 2026Official docs

Written by

Kai Devlin AI Automation Engineer

Full-stack developer who builds and runs AI automation systems in production. Runs local LLMs on personal hardware, builds N8N pipelines that actually ship, and deploys on Cloudflare Pages. Every guide on Pipeline Monk is tested on real consumer hardware — a Ryzen 7 5800HS with 16GB RAM and a GTX 1650. If it works on that, it works.