LFM3-1.7B on Ollama: One Command, and a Report Card That Splits in Two

At the time of writing, the Ollama page for lfm3 had been up for about an hour and had recorded 45 downloads. That is the whole of its public usage so far. The model behind it, LiquidAI/LFM3-1.7B, was announced one day earlier, on October 27, 2026, as the text member of the LFM3 family built from the LFM3-1.7B-Base backbone — alongside the vision, audio, omni and two decision models Liquid AI shipped in the same batch. What changed on October 28 is not the model. It is the delivery: ollama run lfm3 replaces hunting for an LFM3-compatible llama.cpp build, which was the launch-day route.

The reason that is worth more than a line of changelog is the benchmark table. LFM3-1.7B posts one of the most lopsided scoreboards in the small-model class: it beats Qwen3.5-9B — a model more than five times its size — on browser automation, tool calling and instruction following, and loses to it by double digits on general knowledge and long-context retrieval. Every figure in that table is Liquid AI's own. None of it has been independently reproduced yet.

What actually changed on October 28

Ollama lists five tags for lfm3, all stamped within the same hour, all carrying a 256K context line and text-only input. The default is the one most people will pull.

• lfm3:latest and lfm3:1.7b — 1.7 GB, the default Q4-class artifact, and the same digest under both names

• lfm3:1.7b-mlx-bf16 — 3.5 GB, full-precision MLX for Apple silicon

• lfm3:1.7b-mxfp8 — 2.1 GB, 8-bit MLX

• lfm3:1.7b-nvfp4 — 1.7 GB, and this is the one to read carefully

That last tag carries digest 2012d88e202f — the identical artifact behind :latest. Pulling lfm3:1.7b-nvfp4 through Ollama does not get you the NVFP4 checkpoint; the real one is a separate repository on Hugging Face, published for GPU serving rather than local pull. Whether the tag is a placeholder or a publishing slip is not something Ollama's page documents. The digests are checkable, and they are identical, which is the part that matters if you were counting on FP4 memory savings on a laptop.

The Ollama page itself is not a community upload. Liquid AI's model card names Ollama as one of the supported GGUF engines, next to llama.cpp and LM Studio, so this is the vendor-specified path arriving late rather than a stranger's build. The model card text on the page is Liquid's own: "LFM3-1.7B is a tri-hybrid model for local agents and specialized applications."

The architecture, in the terms that decide whether it fits

LFM3-1.7B is 1.73B parameters across 24 layers, and only six of those layers do full attention. Thirteen are gated short convolutions with a kernel size of seven, up from three in the previous generation, and five are sliding-window attention with a 256-token window. Most tokens in a long prompt never reach a global attention matrix at all, which is where the memory story comes from.

Liquid puts a 128K-token KV cache at 1.6 GB. The same figure for Qwen3.5-4B is 4.3 GB and for MiniCPM5-2B it is 5.6 GB. That gap, not the parameter count, is the reason a 1.7B model can hold a long context on hardware where a 4B model cannot. Two other numbers are worth holding onto: 22T pre-training tokens, and a final 3.5T-token mid-training stage weighted toward agentic traces and tool calls. That last stage is the clearest explanation for everything in the next two sections.

The card also lists 16 languages, a 128K vocabulary shared with LFM2.5-8B-A1B, and thinking switched on by default — Ollama surfaces it as a capability tag, not a hidden flag. The 256K context is real in the configuration sense, but the card publishes the KV figure at 128K only; at the full 256K the cache scales with the window, so treat the top of that range as a datacentre setting rather than a laptop one.

Where the scores are strong

The pattern is consistent across every task that rewards doing something with a tool rather than knowing something about the world. These are vendor-reported figures, and the comparators are the ones Liquid AI chose.

• WebArena-Verified — 38.42 for LFM3-1.7B, 3.02 for LFM2.5-2.6B and 28.94 for Qwen3.5-9B

• AutomationBench — 41.29, against 0.94 for LFM2.5-2.6B and 15.10 for Qwen3.5-9B

• BFCL V4 tool calling — 71.39, against 55.89 and 62.83 for the same two

• IFBench — 73.03, against 48.84 for Qwen3.5-9B

• IFEval — 96.66, the highest in Liquid's table

• LiveCodeBench v6 — 73.46, ahead of Qwen3.5-9B's 69.86

The most interesting row is not the biggest one. AA-Omniscience is a benchmark scored partly on whether a model declines to answer rather than guessing, and LFM3-1.7B records 92.93 on non-hallucination against 52.59 for Qwen3.5-9B. Its accuracy on the same set is 7.07. Read together, those two numbers describe a model that mostly says it does not know — which is an underrated property in an agent that is about to take an action, and a bad one in an assistant expected to answer questions.

Where it loses, sometimes badly

The same table, read the other way.

• GPQA Diamond — 63.37, against 80.40 for Qwen3.5-9B and 65.15 for MiniCPM5-2B, a 2B model that beats it

• Humanity's Last Exam, no tools — 7.17, against 16.41 for Qwen3.5-9B

• RULER 128K — 65.56, against 84.63 for Qwen3.5-4B and 87.11 for Qwen3.5-9B

• AA-LCR long-context reasoning — 52.83, against 62.00 for Qwen3.5-9B

• MCP-Atlas — 32.57, against 41.37 for Qwen3.5-4B and 42.67 for Qwen3.5-9B

• SWE-bench Verified — 43.40, against 51.20 for Qwen3.5-9B

• Terminal-Bench 2.1 — 12.92, against 17.98 for Qwen3.5-9B

The RULER row deserves its own sentence: the model whose headline spec is a 256K window is the weakest long-context retriever in its own comparison table, beaten by models advertising a quarter of that. A long window and the ability to find something in it are separate skills, and LFM3-1.7B has bought the first without the second. Anyone planning to point it at a large repository or a long contract should test that row before trusting the spec sheet.

MCP-Atlas and the SWE-bench pair are the same lesson in a different register. LFM3-1.7B is good at driving a single tool with a clear contract. It is behind on the multi-step, multi-tool work that agent frameworks are actually built for, and further behind when the work requires knowing what a codebase does.

What these numbers are, and what they are not

Every figure above comes from Liquid AI's own evaluation run, published alongside the launch. The methodology is not in the announcement: no per-test harness configuration, no statement of how many attempts were averaged, no indication of whether the comparator models were run by Liquid or quoted from their own cards. A 27-row table with a single owner is an argument, not a measurement.

There is no LFM3-1.7B entry on Artificial Analysis as of October 28, so there is no third-party number to set against the vendor's. That will change, and when it does the most informative comparison will be the agentic rows, where the vendor margins are widest and therefore most in need of a second opinion.

One detail cuts the other way and is worth crediting. Liquid trained a quantization-aware distillation checkpoint specifically to recover the accuracy that Q4_0 quantization costs, and ships it as a separate GGUF file. Publishing the small-model numbers at the precision people will actually run is more than most vendors do, and it makes the 4-bit figures slightly more trustworthy than a post-hoc quantisation would.

Running it, and the settings that matter

The one-liner is ollama run lfm3, and the 1.7 GB default is the right starting point on a 16 GB machine. The page also carries four one-line launchers that wire the model into an existing agent harness — ollama launch claude --model lfm3, and the same pattern for OpenCode, Hermes Agent and OpenClaw. That is the most useful thing on the page: it means the model can be dropped into an agent loop you already run without writing a client, which is a lower bar than most local-model launches clear.

Two sampling profiles are on the card and they are not interchangeable: temperature 0.1 with top_k 50 and repetition penalty 1.1 for chat, tool use, agents and coding; temperature 1.0 with top_p 0.95 and top_k 20 for maths and science. Running the agent profile on a maths problem is the most common way to make this model look worse than it is.

If you are pulling GGUF directly rather than through Ollama, the file sizes arrange themselves usefully. The QAD Q4_0 checkpoint is 1.05 GB, marginally smaller than Q4_K_M at 1.1 GB, and it is the one trained to survive quantisation. Q6_K is 1.43 GB and Q8_0 is 1.85 GB if the headroom exists; BF16 is 3.47 GB and rarely worth it at this size.

The licence is the LFM Open License v1.0 — Apache 2.0 in substance, with one addition: commercial use is free below $10 million in annual revenue and requires a paid licence at or above it. The threshold is aggregated across a corporate group and it travels with fine-tunes, so a renamed derivative does not escape it. Non-profits and research users are exempt regardless of revenue. If you are near that line, read the licence text rather than a summary, including this one.

What the split profile means for how you deploy it

A model that is strong on instruction following and tool contracts, weak on parametric knowledge and long-context retrieval, and cheap enough to run on a laptop is not a general-purpose assistant. It is an executor. The architecture that fits it is a local loop — the model decides which tool to call, formats the arguments, follows the schema — with the knowledge-heavy and genuinely long-context steps handed to something larger.

That split is the case where a router earns its place, and it is worth being precise about what OrcaRouter does and does not cover here. LFM3-1.7B is open-weight and runs on your own hardware; it is not on our catalogue, and nothing in this piece is an API pitch for it. What we provide is the other half of the split: one key across 200-plus hosted models for the escalation step, with 0% markup on provider list prices, automatic failover when a provider degrades, and a routing DSL that composes several models into a single call. The practical version is that the local model stays the default for the loop, and the calls that need actual knowledge go out through one endpoint instead of a second SDK and a second contract.

If you are evaluating the model rather than deploying it, failover is the cheaper way to find out whether it holds up: route a slice of traffic to it, keep the fallback configured, and compare on your own tasks instead of Liquid AI's table.

Questions the launch leaves open

Is the Ollama build the same thing as the Hugging Face GGUF?

Not exactly. Ollama's 1.7 GB default is Q4-class and matches the generic GGUF rather than the quantisation-aware checkpoint, which is a separate 1.05 GB file on Hugging Face trained to recover Q4_0 accuracy. The nvfp4 tag resolves to the same digest as :latest, so it is not the NVFP4 build despite the name. If quantisation quality matters to your task, pull the QAD file and run it through llama.cpp directly.

Can a laptop use the full 256K window?

Rarely. The 1.6 GB cache figure Liquid publishes is for 128K, and cache memory scales with the window, so the full 256K needs roughly double that before the weights and the runtime are counted. On a 16 GB machine a working context in the 32K to 64K range is the realistic ceiling; the larger window is better read as a headroom claim for server deployments than as a laptop capability.

Why do the agent scores and the knowledge scores disagree so much?

Because they are measuring different things, and the training run favoured one. The final 3.5T-token mid-training stage emphasised agentic traces and tool calls, then post-training added supervised fine-tuning on 1.75T tokens and reinforcement learning across tool use and structured output. Parametric knowledge is what a 1.7B model has the least room to store, and the AA-Omniscience split — 7.07 accuracy against 92.93 non-hallucination — suggests it was trained to decline rather than guess. That is a design choice, and it is the right one for an agent.

The verdict

LFM3-1.7B is the first model in this weight class where the agentic benchmark rows are the reason to download it rather than a footnote. If you are building a local agent that needs to call tools reliably, follow a schema and abstain instead of inventing an answer, it is now one command away and the profile fits the job. If you need a model that knows things, retrieves from a long document accurately or works through a multi-step engineering task, the table says plainly that you should look elsewhere — and the 256K spec is the least trustworthy line on it.

The number to watch is not the average of 49.37. It is whether an independent run reproduces the agentic margins, because those are the rows where a 1.7B model claims to beat a 9B one and where a vendor's own harness has the most room to flatter.