LFM3: Liquid AI's six small models for specialized intelligence on your own machine

Status: Active | Last tested: 2026-11-01 (LFM3-1.7B Q4_K_M, llama.cpp build b12032, Ubuntu x64 CPU) | Re-check: trigger-based (max 6 months)

Active: the tool is current and recommended.

For detailed explanations of the CI-First evaluation terms used in this review, including the Humics Protection Badge and the AI Imposture Risk levels, see the Glossary at the end of this post.

---

---

In this Tool Review

• Six models on one backbone, what each one is, and what this review scores

• Tool Snapshot

• The Problem

• The Outcome

• Who Should Use LFM3

• U365 Institutes Alignment

• How LFM3 Works

• Getting Started with LFM3

• Real Workflows

• Strengths, Limits, and AI Imposture Risk

• Section 7c: The scope Liquid's own documentation concedes, and the licence line a team has to read first

• U365 Co-Intelligence Rating

• What Users Say

• Comparison and Alternatives

• Verdict and Next Steps

• Status and Last Tested

• Migration Path

• U365's Recommendations to Learn More

• CI-First Evaluation Summary Card

• Glossary

• Sources

• Faculty Note on Evidence Quality

• Status and Re-check

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Six models on one backbone, what each one is, and what this review scores

LFM3 is not one model. It is a family of six open-weight models released on 2026-10-27, all branched from a single 1.73B-parameter base checkpoint, and a reader who buys the family name without reading the table will expect capabilities that belong to a sibling.

Model	Input	Output	Parameters	Context	Built on
LFM3-1.7B-Base	Text	Text	1.73B	256K	Pretrained on 22T tokens, for your own post-training
LFM3-1.7B	Text	Text	1.73B	256K	The post-trained text model this review scores
LFM3-VL-2B	Text, images, video	Text	1.92B	128K	LFM3 backbone plus a 164M vision encoder and a 25M projector
LFM3-Audio-2B	Text, audio	Text, speech	2B	32K	Backbone plus a causal audio encoder and the LiquidCodec tokenizer
LFM3-Omni-2B	Text, images, video, audio	Text, speech	2.17B	32K	Backbone plus the vision and audio stacks
d1-2B	Text, images, video, and named questions	Typed answers with probabilities	1.92B	128K	Fine-tuned from LFM3-VL-2B
d1-Omni-2B	Text, images, video, audio, and named questions	Typed answers with probabilities	2.17B	128K	Fine-tuned from LFM3-Omni-2B

Two facts in that table decide most of the deployment questions that follow. The context window is not uniform: it runs from 256K on the text model down to 32K on the audio and omni models, so the family name does not carry a single context figure. And the decision models are not chat models with a short answer style. They return typed answers with probabilities and generate no tokens, which is a different product with a different bill.

What this review is. It is a review of LFM3 as published on 2026-10-27 and read on 2026-11-01, scored against the U365 CI-First Evaluation Framework version 1.4.1. The primary artifact is LFM3-1.7B, the text model, because it is the checkpoint the others are built on and the one a reader is most likely to run. It was exercised hands-on for this review: downloaded as a Q4_K_M GGUF, served with llama.cpp build b12032, and probed for generation, reasoning behaviour, tool calling, arithmetic and factual accuracy.

What this review is not. It is not a review of Liquid AI the company, of the Liquid API as a service, or of LFM2.5, the generation this one replaces. It does not score the vision, audio, omni or decision models from hands-on use. Their benchmarks are read from their model cards and quoted as the vendor's measurement, and no sentence here claims otherwise. It is not a test of fine-tuning, because a single-GPU fine-tune is a project rather than a review step. And it does not treat the vendor's benchmark table as independent evidence, because this review found no independent benchmark of LFM3 at the time of scoring.

The single sentence a reader should carry. LFM3-1.7B is a genuinely capable small model for tool calling, structured extraction and local automation, it is weak on knowledge and coding in ways its own documentation admits, and the work it saves is real only when the task is narrow enough that you can check the output quickly.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Tool Snapshot

LFM3 is Liquid AI's third-generation family of open-weight models at roughly two billion parameters, built on one tri-hybrid backbone and split into text, vision, audio, omni and decision variants that run on a laptop, a phone or a single GPU.

Model facts, as published

Field	Value
Developer	Liquid AI
Released	2026-10-27
Text model reviewed	LFM3-1.7B, 1,728,801,536 parameters by the published safetensors index
Architecture	24 layers: 13 gated short convolutions, 5 sliding-window attention and 6 global attention
Context window	256K tokens, input and output combined, on the text model
Vocabulary	128,000 tokens
Languages	English, Arabic, Chinese, French, German, Italian, Japanese, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Russian and Polish
Licence	LFM Open License v1.0, Apache 2.0 based with a commercial revenue threshold
Weights	Hugging Face, GGUF, MLX, ONNX, FP8 and NVFP4 variants
Training	22 trillion pre-training tokens, with a final 3.5T-token mid-training stage on curated data and agentic traces that also extended the context to 256K

Pricing, read on 2026-11-01

Surface	Price
Open weights, organisation under $10M annual revenue	Free, including commercial use, with fine-tunes kept private
Open weights, organisation at or above $10M annual revenue	Paid enterprise licence from Liquid AI
LFM3-1.7B API	$0.08 per million input tokens, $0.20 per million output tokens, $0.02 cached input
LFM3-VL-2B API	$0.10 input, $0.50 output, $0.10 image input
LFM3-Audio-2B and LFM3-Omni-2B API	$0.10 text input, $1.00 text output, $2.00 audio input, $10.00 audio output
d1 and d1.1 decision models API	$0.02 input, $0.00 output
New organisation credit	$2

Official links

• Website: https://www.liquid.ai

• Release post: https://www.liquid.ai/blog/lfm3

• Documentation: https://docs.liquid.ai/lfm/models/lfm3-1.7b

• Model collection: https://huggingface.co/collections/LiquidAI/lfm3

• Cookbook and code: https://github.com/Liquid4All/cookbook

• Playground: https://playground.liquid.ai

• Licence: https://www.liquid.ai/lfm-license

Open-weight fields

Field	Value
Companion repository	Liquid4All/cookbook, 2,735 stars, 420 forks, 23 open issues, last push 2026-10-27
Fine-tuning repository	Liquid4All/liquid-finetune, 235 stars, MIT licence, last push 2026-10-30
Licence	LFM Open License v1.0
Maintained status	Active, with same-day support merged into llama.cpp on release day
Install method	Ollama one-line pull, llama.cpp, LM Studio, MLX, vLLM, SGLang, ONNX Runtime, Transformers

At a Glance Dashboard

Field	Value
Category	Applied AI / open-weight small language and multimodal models for on-device and edge deployment
CI-First Benefit Score	4.8 / 10 (CI-First Positive)
Sub-scores	Time 5 / Quantity 6 / Quality 4 / Skill 4
CI-First Profile	Primary: Co-Worker and Assistant (level 2). Secondary: Analyst and Tester (level 4)
Humics Protection	Humics-Neutral (0 / +3)
AI Imposture Risk	Medium overall, with all three traps Medium
Status	Active
Last tested	2026-11-01
Price	Free weights under the LFM Open License for organisations under $10M annual revenue; API $0.08 input / $0.20 output per 1M, cached input $0.02
Footprint	1,049 MB for the Q4_K_M GGUF, about 2.0 GB resident with a 16K context
Context	256K on the text model, 128K on the vision and decision models, 32K on the audio and omni models
Access	Hugging Face weights, Ollama, LM Studio, llama.cpp, MLX, vLLM, SGLang, ONNX Runtime, the Liquid API, OpenRouter and Vercel
Licence condition	Free commercial use below $10M annual revenue; paid enterprise licence at or above it

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

The Problem

Most useful AI work now runs against a remote model, and that arrangement carries three costs that have nothing to do with answer quality. Every request leaves your machine. Every token has a price, so an agent that runs continuously has a bill that grows with its ambition. And every workflow depends on a vendor staying available, keeping its rate card and keeping your data out of training.

The alternative that has been available until now is a small open model that is cheap to run and too weak to trust with anything that matters. A two-billion-parameter model from a year ago could draft a sentence and classify a support ticket. It could not reliably call a tool, hold a long context, or follow a structured instruction set, which is exactly what an agent needs. So the practical choice was a capable remote model that costs money and takes your data, or a local model that is free and unreliable.

Liquid AI's claim with LFM3 is that this trade has moved. The text model fits in about one gigabyte at four-bit precision, holds a 256K context, and was post-trained specifically to run inside agent runtimes. The vendor's own agentic benchmarks put it ahead of a 9B model on browser control and automation. If that holds for your task, a large class of routine work can move onto hardware you own, at a marginal token cost of zero, with the data never leaving the device.

The problem it does not solve is knowledge. A model at this size does not contain the world, and the vendor says so in its own documentation. That sentence is the boundary of this review, and it is why the score below is a cautious Positive rather than a Strong.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

The Outcome

The concrete outcome for a reader who adopts LFM3 is a working local workflow that costs nothing per call and produces a result you can check in under a minute. In the test for this review, a three-sentence explanation of a heat pump came back in 9.8 seconds from a cold start on eight CPU threads, at about 49 tokens per second of generation. A tool call with one function and one identifier returned the correct function and the correct JSON arguments in one pass. A structured extraction instruction was followed exactly.

For a student or a professional, that means a private assistant for the tasks where the model is strong and the check is cheap: pulling fields out of a form, routing a ticket, turning a transcript into action items, summarising a document you can reopen, or driving a browser step you can watch. Those tasks share a property that matters more than the benchmark: you can see whether the answer is right without redoing the work.

For a team, the outcome is an architecture decision rather than a subscription. The weights are yours, the fine-tunes stay private, and the same checkpoint runs on a laptop, a phone, a server with vLLM, or through the vendor's API at eight cents per million input tokens. That flexibility is the real product, and it is worth more than any single benchmark row.

The outcome a reader should not expect is a research assistant. Asked a factual question outside its training, the model answered with a fabricated officeholder and a fabricated year, in fluent prose, with no hedge. That is the failure mode this review weights most heavily, because it is the one that costs a reader who trusts it.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Who Should Use LFM3

LFM3 is for the reader who has a narrow, repeatable task and a reason to keep the data local. It is not for the reader who needs a model that knows things.

U365 Fellow categories

Learner type	Difficulty	Typical ROI	Career path
Students (Bachelor, Master)	Intermediate	A private model for reading, extraction and study notes, with no per-token cost and no data leaving the laptop. The limit is knowledge: it will invent a citation, so it is a reading aid rather than a source	UIT programmes where model deployment is assessed, and any programme with a research-methods component where handling data locally matters
Professionals (career upskilling)	Intermediate	A local agent for routing, extraction, transcription and browser steps, plus the option to fine-tune on the organisation's own terminology. The return is highest where the task repeats and the check is cheap	UIT AI Developer Specialist, nearest published anchor for model deployment; UIB for the cost and vendor-exit analysis
Everyone (lifelong learners)	Beginner for Ollama, Intermediate for fine-tuning	A capable assistant that runs offline, works on a modest laptop and costs nothing per message. Good for the tasks where a wrong answer is visible	No published U365 programme assesses local model deployment at beginner level, so this is a practice rather than a programme outcome

For teams and organisations. LFM3 is sold to organisations two ways, as open weights under a revenue-threshold licence and as a metered API, and the team decision rests on which of those two you are prepared to operate.

• Team deployment. There is no admin console for the weights: deployment is yours, through vLLM or SGLang on your own GPUs, llama.cpp on CPU, ONNX Runtime or Qualcomm AI Hub on devices, or the vendor's API if you prefer a hosted path. Liquid ships a fine-tuning stack for the same purpose, and llama.cpp support was merged on release day. The absence of an admin and permission layer is the practical gap: access control, audit logging and cost attribution are things your platform team builds.

• Cost at team scale. The API is metered per million tokens at $0.08 input and $0.20 output for the text model, with cached input at $0.02, and the rate card is the same through Liquid, OpenRouter and the Vercel AI Gateway. Self-hosting replaces that with hardware, electricity and staff time. The licence is free for organisations under $10 million in annual revenue, including commercial use, and requires a paid enterprise licence at or above that line, so the licence question is a legal review rather than a volume discount.

• Data and compliance. Local inference keeps data on the machine, and the licence lets you keep fine-tuned weights private with no copyleft. The vendor's API is a separate data path with its own terms, and this review did not read those terms. Attribute the privacy benefit to the deployment you run, not to the model file.

• U365 for companies. Professional learners can take the relevant programmes individually or through their organisation, employee groups can be trained under a customised training agreement, and corporate education can be built on demand.

Skill level required: Beginner to run it, Intermediate to deploy it well.

Prerequisites: Comfort with a terminal or with LM Studio for the local path. The fine-tuning path assumes Python, a GPU and familiarity with a training loop.

Typical time to first result: Under 15 minutes with Ollama or LM Studio.

Typical time to competence: About a week of daily use to learn where it is reliable, and two to four weeks to run a first fine-tune that you can evaluate.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

U365 Institutes Alignment

LFM3 aligns strongly with the institute that teaches deployment and measurement, and weakly with the two institutes whose work depends on craft the model does not exercise and knowledge it does not hold.

UIT (Technology, AI, Data Science)

• Rating. High (primary)

• Why. This is a deployment artifact before it is a chatbot. Quantisation levels, context limits, KV cache, tool-call schemas, single-GPU fine-tuning and runtime choice are all visible and all assessable, which makes it unusually good material for a course that has to grade engineering judgement rather than prompt style.

• The limit that holds the row. What the vendor publishes is a checkpoint and a fine-tuning stack, not a curriculum: there is no evaluation surface and no assessment, and the model card itself rules out agentic coding and complex multi-step reasoning. A technology cohort therefore works the configuration, measurement and appraisal of a runtime it chooses rather than application engineering on the model. A term search over all 81 published programme descriptions returns zero matches for quantisation, GGUF, KV cache and inference.

UIB (Business Management, Entrepreneurship)

• Rating. Medium

• Why. The decision models address real business pipeline steps, ticket routing, invoice extraction, moderation and reranking, at two cents per million input tokens. The medium rating reflects the analysis a business student should do around it: total cost of ownership against a hosted API, the licence threshold, and the vendor dependency that open weights remove.

• The limit that holds the row. The model teaches no management, finance or entrepreneurship content and produces nothing a business cohort can be assessed on. The total-cost-of-ownership comparison, the licence-threshold reading and the vendor-exit judgement all have to be built by the cohort from its own numbers, and nothing in the release supplies a management method or a return figure. A term search over all 81 published programme descriptions returns zero matches for local model, on-device and model weights.

UIC (Digital Communication, Marketing)

• Rating. Low to Medium

• Why. The audio model transcribes and speaks in 18 languages, which is useful for interview and podcast workflows, and the on-device path is a genuine privacy argument for handling source recordings. That is a real communication surface and not a communication strategy: no register, no audience analysis and no publication standard are taught, and the writing quality at this size is not why anyone would choose it.

• The limit that holds the row. Transcription and speech output are a handling capability, not a judged communication act: the model composes no campaign, carries no editorial workflow and evaluates no audience, which is what holds the row at Low to Medium rather than Medium. A term search over all 81 published programme descriptions returns zero matches for transcription, editorial, audience analysis and publication standard.

UID (Digital Design, UX/UI)

• Rating. Low

• Why. The vision model reads interface screens and localises objects, and its GUI understanding score is strong for the size, which makes it a plausible prototyping component for an interface agent. It is not a design tool, produces no visual output, and its own documentation rules out the multi-turn conversation a design critique would need.

• The limit that holds the row. The vision model reads an interface and localises objects; it designs nothing, produces no visual output and evaluates nothing against a brief, and its own documentation rules out the multi-turn conversation a design critique would need. That is a reading contact with one operational item, which is the family's Low for this row. A term search over all 81 published programme descriptions returns zero matches for design brief.

U365 methods, not an institute (UNOP, ULM, LIPS, CARE and the UP-Context-Engineering Method)

• Rating. Applicable

• Why. The methods layer fits the way a small local model works. UP-Context's order of context, role, task, constraints and output is what makes an extraction repeatable and what keeps the model from inventing a missing field. LIPS holds the task, the check and the result, because the model keeps nothing between calls. CARE's Review step is where the extracted field is compared with the page. The limit is that the model carries no method and no coaching surface of its own, and in an agent runtime the memory files are written by the agent rather than by the person.

• The limit that holds the row. The model carries no method and no coaching surface of its own: LIPS, CARE and UP-Context-Engineering supply the order, the check and the record, and in an agent runtime the memory files are written by the agent rather than by the person. A Fellow who does not keep the record in their own system has no account of what was run or what was checked.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

How LFM3 Works

Inputs: Text for the text model. The vision model adds images and video at native resolution, sampled at 2 frames per second with 4 to 768 frames by default. The audio model adds 16 kHz audio. The omni model accepts all of them, including video with its soundtrack. The decision models take a state, any number of named questions, and optionally an image, video or audio clip.

Outputs: Text for the text and vision models. Text, 24 kHz speech, or interleaved text and speech for the audio and omni models. Typed answers with calibrated probabilities and no generated tokens for the decision models.

Underlying technology:

• A tri-hybrid stack of 24 layers: 13 gated short convolutions, which handle nearby context cheaply, 5 sliding-window attention layers, and 6 global attention layers. The point of the mix is to keep the memory and compute of long context below what a pure transformer of the same width would need.

• In-house encoders for vision and audio, replacing the third-party components used in the previous generation. The vision encoder is 14 layers with 16 by 16 patches and 2D rotary embeddings; each 2 by 2 block of patches becomes one language token.

• A tool-call format that is a superset of the qwen3_coder schema, with function calls written between <tool_call> and </tool_call> tags and arguments in <function=> and <parameter=> tags. The format changed from LFM2, so an existing parser built for the previous generation will not read it.

• Deferred tool loading and tool search, for a tool list too large to place in the system prompt.

• Post-training for agentic runtimes, with Liquid naming Hermes Agent, Pi and OpenClaw in the model card.

Benchmark results, as published by Liquid AI

All rows are the vendor's measurement, served with vLLM in BF16 at full context. Lower-context competitors were run at 131,072 tokens. The average row is the unweighted mean of every score in the vendor's table.

Benchmark	LFM3-1.7B	LFM2.5-2.6B	Qwen3.5-9B	Gemma 4 E4B
LiveClaw	45.60	14.70	35.77	20.36
WebArena-Verified	38.42	3.02	28.94	17.06
AutomationBench (public)	41.29	0.94	15.10	1.92
BFCL V4	71.39	55.89	62.83	48.25
ToolSandbox	80.36	78.04	76.41	69.27
MCP-Atlas	32.57	16.45	42.67	6.19
SWE-bench Verified (OpenCode)	43.40	18.00	51.20	0.50
Terminal-Bench 2.1 (OpenCode)	12.92	0.00	17.98	0.00
IFEval	96.66	95.39	92.08	90.02
IFBench	73.03	60.48	48.84	44.56
GPQA Diamond	63.37	57.78	80.40	57.88
Humanity's Last Exam, no tools	7.17	5.88	16.41	4.77
AA-Omniscience non-hallucination	92.93	53.69	52.59	72.09
RULER 128K	65.56	1.15	87.11	18.82
Average across the vendor's table	49.37	31.55	47.24	31.74

Three readings of that table matter more than the average.

The agentic lead is large and comes from post-training, not from scale. WebArena-Verified at 38.42 against 28.94 for a model five times larger is the row Liquid leads with, and the predecessor at 3.02 shows how much of the gain is training rather than architecture.

The knowledge and long-context rows are where the size shows. GPQA Diamond at 63.37 against 80.40, Humanity's Last Exam at 7.17 against 16.41, and RULER at 128K at 65.56 against 87.11. The model is not a substitute for a larger one on questions that require knowing things or holding a long document in mind.

The non-hallucination row is the most interesting number in the table. AA-Omniscience non-hallucination at 92.93 against 52.59 for the 9B model means LFM3 declines to answer far more often than its larger rival. That is a designed trade: lower accuracy, much lower fabrication. It is also the reason the Quality score is not lower than it is, and the reason the fabricated-officeholder result in this review's own test is a real defect rather than a rounding error.

Platforms and runtimes: the vendor API, Hugging Face weights, Ollama (lfm3, lfm3-vl, lfm3-audio, lfm3-omni), LM Studio, llama.cpp, MLX, vLLM, SGLang, ONNX Runtime, Qualcomm AI Hub and GenieX, Intel through OpenVINO, AMD, Arm and Apple silicon. Day-one partners named in the release include Ambarella, AMD, Arm, Intel, NVIDIA, OpenRouter, Qualcomm and Vercel, with Mercedes-Benz and Shopify in pre-release testing.

Model variants: base, text, vision, audio, omni, and two decision models.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Getting Started with LFM3

Required accounts: None for the local path. An account on the Liquid console is needed only for the hosted API, and a new organisation receives $2 of credit.

Installation, in increasing order of control:

• Ollama, the fastest path. ollama run lfm3 pulls a quantised build and starts a chat. The vision, audio and omni variants are separate pulls: lfm3-vl, lfm3-audio, lfm3-omni.

• LM Studio, for a desktop interface. Search for LFM3-1.7B in the model browser, choose a quantisation, load and chat. Useful if you want to see tokens per second without reading a log.

• llama.cpp, for the server and the API shape. Download a build from the project's nightly releases, then llama-server -m LFM3-1.7B-Q4_K_M.gguf --jinja -c 16384 --port 8080. The --jinja flag is required for the tool-call template to be applied, and without it a tool call arrives as plain text.

• vLLM or SGLang, for a GPU you already operate. vllm serve LiquidAI/LFM3-1.7B exposes an OpenAI-compatible endpoint.

• Transformers, for fine-tuning and inspection. The model card requires trust_remote_code=True and a recent Transformers version.

Hardware, measured rather than estimated. The Q4_K_M GGUF file is 1,049 MB, which matches the vendor's "about 1 GB at 4-bit". The served process is larger: with a 16K context the llama-server resident set was about 2.0 GB, because the KV cache and buffers sit on top of the weights. Plan for 2 GB of free memory rather than 1 GB, and more if you raise the context.

First-time configuration:

• Install Ollama, or download a llama.cpp build and the Q4_K_M GGUF.

• Start the model and confirm the chat template loads. With llama.cpp, pass --jinja; with Transformers, pass the chat template with enable_thinking=False for a first answer.

• Decide the reasoning setting. Thinking is on by default and it consumes the output budget before the answer starts.

• If you plan tool calls, define the functions in the request rather than in prose, and confirm that finish_reason reports tool_calls.

First 15 minutes checklist

• ☐ Ask a question you already know the answer to, and time it. In this review a three-sentence answer took 9.8 seconds from a cold start on eight CPU threads.

• ☐ Turn thinking off and ask the same question. The difference in latency is the cost of the reasoning pass, and it is the first setting a reader should own.

• ☐ Run one tool call with a single function and a single required argument. Confirm the function name and the JSON are both correct.

• ☐ Run one extraction on a page you can check, and compare every field against the source.

• ☐ Ask one factual question at the edge of your own expertise, and check the answer against a source. This is the test the model failed in this review, and it is the one that tells you what it is for.

Result: After 15 minutes you should have a running local model, a measured generation speed on your own hardware, a working tool call, and a clear sense of whether its knowledge is good enough for the task you have in mind. If the last item is unclear, the answer is no.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Real Workflows

Workflow 1: The local triage agent that calls a tool and stops

Learner type: Professional CI-First benefit tags: Time, Quantity Connects to: UIT (Technology, AI, Data Science) Time estimate: 40 minutes to set up, about 30 seconds per item after that

This workflow is the one the vendor built the model for: a small agent that reads an incoming item, decides what it is, and calls one function with the right arguments. It is also the workflow where a small model's failure is cheapest, because the function call is either valid or it is not, and the runtime rejects an invalid one before anything happens.

Step	You do	The tool does
1	Define one function with one required argument and a clear description	Nothing
2	Paste the item and the tool schema into the request	Reads the item and selects the function
3	Check the function name and the arguments	Emits a tool call with JSON arguments
4	Let the runtime execute and return the result	Interprets the result and writes the reply
5	Read the reply before it is sent	Nothing

Sample prompt:

Role: AI as a triage assistant for a small operations team. I own the routing decision and the reply that leaves the machine. Profile: AI Co-Worker and Assistant. You decide nothing that has a consequence; you route and you draft. Task: Read the message below. Decide whether it needs the create_ticket function. If it does, call it with the required fields. If it does not, say why in one sentence. Constraints: Call the function at most once. Never invent an identifier that is not in the message. If a required field is missing, do not call the function; ask for it instead. Output: Either one tool call, or one sentence explaining why no call was made. Memory: None. Treat every message as new. UP-Context-Engineering verification: I will check the function name and every argument against the message before I let the runtime execute the call, and I will read the final reply before it is sent. Data safety: This runs on a local model, so the message stays on this machine. Do not copy it into a hosted service to double-check it.

Verification checklist:

• ☐ Multi-Model Check: run ten items through LFM3 and through a larger model, and compare the routing decision, not the wording

• ☐ External Source: open the message each ticket was created from and confirm every field

• ☐ Human Review: you read the final reply before it is sent, every time, for the first two weeks

• ☐ CI-First Test: can you explain why each item was routed the way it was without reopening the model? [Y/N]

Workflow 2: Structured extraction from a document you can reopen

Learner type: Everyone CI-First benefit tags: Time, Quality Connects to: AI Developer Specialist Time estimate: 15 minutes for a first pass on a five-page document, including the check

This is where a small model earns its place. The task is narrow, the source stays open in another window, and every extracted field can be compared with the page. It is also the task where the model's weak knowledge does not matter, because all the information is in the input. In this review, a three-field extraction from a short note returned the exact supplier, quantity and item, in JSON, with a planted distractor line ignored.

When the extraction repeats at volume and the schema is fixed, the decision model is the better instrument: d1-2B takes a state, an image or a video, and any number of named questions, and returns typed answers with probabilities instead of prose. Two cents per million input tokens and no generated tokens changes the economics of a document pipeline.

Sample prompt:

Role: AI as a careful extraction assistant who transcribes what is on the page and marks what is not. I own the field list and the sample check. Profile: AI Co-Worker and Assistant, working to a fixed schema. Task: Extract the fields in the schema below from each document. Return one row per document. Constraints: Do not infer a missing value; set it to null and add the field to a flags list. Do not correct totals. Do not use outside knowledge. If two documents disagree, keep both values. Output: A JSON array with one object per document, then a list of every field you flagged, with the reason. Memory: None. Do not carry a value from one document to the next. UP-Context-Engineering verification: I will compare every field with the page it came from, and I will treat any value that is not visible on the page as an error rather than as a helpful inference. Data safety: Run this locally on the document set. If you use the hosted API instead, read the vendor's data terms first, because the privacy benefit belongs to the local path.

Verification checklist:

• ☐ Multi-Model Check: extract the same five documents with a larger model and compare the field values, not the formatting

• ☐ External Source: open each document and confirm every field, with a 100% check on the first batch and a sample afterwards

• ☐ Human Review: a colleague who knows the document set checks the flagged list

• ☐ CI-First Test: can you reproduce the extraction by hand for one document? [Y/N]

Workflow 3: The narrow fine-tune on one GPU

Learner type: Student, Professional CI-First benefit tags: Quality, Skill Connects to: LIPS Time estimate: One day for a first run, one week to a result you can defend

This is the workflow the family is designed around and the one that separates LFM3 from a hosted model. The claim is that a single GPU and a short run are enough to adapt the model to your terminology, format or tool set. That claim is plausible from the architecture and the published fine-tuning stack, and it is not tested in this review.

What a reader can do with the workflow is real skill: building a dataset, choosing a split, measuring before and after on a held-out set, and deciding whether the fine-tune generalised or memorised. That is the Knowledge and Skill Benefit this review scores at 4 rather than 2, and it is available only to the reader who runs this workflow rather than the chat.

Sample prompt:

Role: AI as a fine-tuning assistant and a sceptical reviewer. I own the split, the evaluation questions and the decision to keep or discard the run. Profile: AI as Professor, Coach and Tutor. Explain each decision and then ask me to make it. Task: From the 300 labelled examples I will paste, propose a train, validation and test split, a target format, and three evaluation questions that would show whether the fine-tune generalised. Do not write the training script until I have chosen the split. Constraints: Do not invent labels. Do not use the test set to choose a checkpoint. If the dataset is too small for the task, say so and stop. Output: A plan with the split, the format, the three evaluation questions, and the failure mode you expect. Memory: Keep a running list of the decisions I make and the reason I gave. UP-Context-Engineering verification: I will run the held-out test myself and record the before and after scores, and I will keep the untuned model as the baseline. Data safety: The training data stays on the machine that runs the fine-tune. Do not send examples to a hosted service for labelling.

Verification checklist:

• ☐ Multi-Model Check: evaluate the fine-tuned model and the base model on the same held-out set

• ☐ External Source: check a sample of the training labels against the source documents

• ☐ Human Review: someone who knows the domain reads twenty outputs from the tuned model and twenty from the base

• ☐ CI-First Test: can you explain what the fine-tune changed and why, without reading the training log? [Y/N]

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Strengths, Limits, and AI Imposture Risk

Strengths

LFM3 delivers CI-First benefits in these areas:

CI-First Benefit	Strength	Evidence
Time	Fast first result on ordinary hardware, with a one-line install	9.8 seconds from a cold start for a three-sentence answer on eight CPU threads, 48.5 to 55.8 tokens per second generation, 97.9 to 166.1 tokens per second prompt processing, measured in this review
Quantity	No marginal token cost and a model built for many parallel agents	The weights run locally with no metering, and the vendor's pitch of dozens of agents running continuously is consistent with the measured speed and the 1 GB footprint
Quality	Strong instruction following and tool use for the size, with a low fabrication rate	IFEval 96.66, IFBench 73.03, BFCL V4 71.39, and AA-Omniscience non-hallucination 92.93, all vendor-reported; the tool call in this review returned the correct function and arguments in one pass
Skill	The fine-tuning path teaches real model work	A single-GPU fine-tune, a published fine-tuning stack, and a base checkpoint for your own post-training; the knowledge is in the doing, not in the chat

Limits

• Knowledge is thin and the failure is fluent. Asked who the Chancellor of Oxford is, the model answered "Professor Sir Tim Crouch, since 2009", with a title and a year, and no hedge. The University of Oxford's own page records Lord Hague of Richmond, in office since February 2025. A model that invents a name this confidently is not a source.

• Thinking is on by default and it eats the budget. In this review's first run, a 160-token output limit was consumed by the reasoning pass and the answer never arrived. With thinking switched off, a number-only instruction still returned the working before the answer, because the reasoning text was emitted into the content field rather than separated. A reader who copies a prompt from a blog post and sets max_tokens=200 will conclude the model is broken.

• Coding and long context are weak by the vendor's own numbers. SWE-bench Verified 43.40 against 51.20, Terminal-Bench 2.1 12.92 against 17.98, and RULER 128K 65.56 against 87.11. Liquid states in the model card that the model is not recommended for agentic coding or complex multi-step reasoning.

• The tool-call format changed from LFM2. A parser or prompt built for the previous generation does not read the new <tool_call> schema, and a silent parser failure looks like a model failure.

• The licence is not Apache 2.0. Organisations at or above $10 million in annual revenue need a paid licence to use the weights commercially. That is a legal review before it is an engineering decision.

• The context figure depends on the surface. The weights document 256K, and the hosted API is reported at 128,000. A pipeline designed on the model card can break on the API it is deployed against.

AI Imposture Risk

Time Illusion

• Rating. Medium

• Evidence. The measured speed is real: 49 tokens per second on CPU, and a one-line install through Ollama. The overhead is elsewhere. You choose a runtime, a quantisation, a reasoning setting and a context size, and the first run in this review returned nothing because the reasoning pass consumed the output budget. For a narrow task the net saving is genuine; for a knowledge task the verification takes longer than the generation, and the appearance of speed is a 1.7B model answering confidently rather than a correct answer arriving quickly.

Quantity Illusion

• Rating. Medium

• Evidence. The volume proposition is the product: free tokens, dozens of parallel agents, and decision models that answer many questions in one forward pass. The check does not scale with it. A fabricated officeholder and a fabricated year look exactly like a correct answer, and a reader running a hundred documents through a model that answers at 50 tokens per second will not read a hundred outputs. The mitigation is in the model's design, with non-hallucination at 92.93 on the vendor's table, and the mitigation is why this rating is Medium rather than High.

Skill Illusion

• Rating. Medium

• Evidence. The fine-tuning path builds real capability, and the chat path builds none. The model is explicitly post-trained to run inside agent runtimes, including Hermes Agent and OpenClaw, and those runtimes write skills, memory and standing instructions on the user's behalf. Framework clause 5.2.3-a sets a floor of Medium for any tool that writes procedural memory for the user, and the runtime surface is where that applies here.

Overall Imposture Risk: Medium

Framework v1.2 clause note

Clause 5.2.3-a, agent-authored procedural memory: APPLIES where LFM3 runs inside an agent runtime such as Hermes Agent, Pi or OpenClaw. The model file writes nothing. The runtime writes skills, memory and standing instructions on the user's behalf, and that artefact is what the clause governs: a documented capability the user did not write, reused in later sessions. The no-lower-than-Medium floor is met wherever that surface is used. The High threshold is not met here, because the write path and the approval gate belong to the runtime rather than to the model, and the runtime is where the per-write decision lives. An API-only deployment, or a chat in LM Studio, does not engage the clause at all.

Clause 4.2-a, agent-mediated conversation: NULL. The clause's two erosion conditions are agent-authored text presented as a person's own voice in a human-facing channel, and agent interaction substituted for human contact. A model that transcribes, extracts or calls a function meets neither. The speech output speaks in the loaded model's own voice with no voice-cloning path, so it does not present the user's voice at all.

Clause 7.5: NULL, recorded for completeness. The subsection was removed from the framework on 2026-10-13, and nothing in this family reaches its case.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Section 7c: The scope Liquid's own documentation concedes, and the licence line a team has to read first

Two documents in this release say more about the product than the launch post does, and both are worth reading before a pilot.

The model card rules out the two uses the release is most likely to be bought for. The LFM3-1.7B card states that the model "is not recommended for agentic coding or complex multi-step reasoning due to its small size", and the vision card goes further, ruling out "coding, multi-turn conversations, or complex reasoning". A reader who sees an agentic benchmark table and concludes that this is a coding agent has been led past the vendor's own boundary. The honest reading is narrower and more useful: this is a tool-calling and extraction model that runs where the data is.

The licence is a revenue test, not an open-source licence. LFM Open License v1.0 is Apache 2.0 based, with grants made subject to a commercial use limitation: free commercial use ends at $10 million in annual revenue, and the vendor's own documentation directs organisations above that line to a paid licence. Research, education and non-profit use carries no revenue limit. Fine-tunes stay private and there is no copyleft. For a university this is comfortable. For a company, it is a term sheet that a legal team should read before the engineering team builds on it.

One surface divergence belongs in the same note. Liquid's documentation gives the text model 256K tokens. VentureBeat reports that the hosted console lists 128,000 for the API version. Both can be true at once, because a hosted deployment may cap context for cost reasons, but a team that prototypes on the weights and ships on the API will meet the smaller number in production. Check the limit on the surface you deploy, not on the model card.

No sub-score changed on this note. The three findings bear on what a reader is licensed to do, on what the vendor's own documentation permits and on which context limit a deployment meets. None of them changes the measured time, the usable quantity, the quality of the output on the tasks this review tested, or the skill the workflow teaches, and those four dimensions are what the score is computed from.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

U365 Co-Intelligence Rating

CI-First Profile

Primary profile: Co-Worker and Assistant (level 2) Secondary profile(s): Analyst and Tester (level 4) on the decision models and on extraction, where the output is a typed judgement you interpret

CI-First Benefit Score

Time

• Score. 5

• Rationale. A one-line install and 49 tokens per second on CPU deliver a real first result in seconds, and the setup, quantisation, reasoning-setting and verification work around it are what hold the score at Moderate.

Quantity

• Score. 6

• Rationale. Free local tokens, parallel agents and one-pass decision models multiply output, and the usable multiple is lower than the produced one because a small model's output still needs a sample check.

Quality

• Score. 4

• Rationale. Instruction following and tool calling are strong for the size, but knowledge is thin and fluently wrong: the model fabricated an Oxford chancellor in this review's own test.

Skill

• Score. 4

• Rationale. The fine-tuning and deployment path teaches genuine model work, while the chat path teaches nothing and can mask a missing capability behind a fluent answer.

CI-First Benefit Score: 4.8 / 10 (CI-First Positive)

The arithmetic: (5 + 6 + 4 + 4) / 4 = 4.75, rounded to 4.8. The band is Positive, which is a real recommendation: the tool returns more than it costs for the workflow it is built for. It is not Strong, because the two dimensions that decide whether a reader can trust an answer, Quality and Skill, are the two that score lowest.

Humics Protection Badge

Creativity

• Rating. Neutral

• Rationale. The model generates and restructures under your direction, and it neither sparks nor replaces your own ideation. Its most creative use, a local agent you design, is your creativity expressed through a tool.

Critical Thinking

• Rating. Neutral

• Rationale. The model's abstention behaviour and its documented limits support verification discipline, and its fluent fabrication rewards the reader who does not check. The two cancel, and the discipline has to come from you.

Social Authenticity

• Rating. Neutral

• Rationale. The speech output speaks in the model's own voice with no voice-cloning path, and nothing in the family sends text in your name. Clause 4.2-a returns a null.

Humics Protection Score: 0 / +3 Badge: Humics-Neutral

Superhuman Usage Guidance

When to invite this tool:

• A narrow task with a checkable end state: extraction, routing, classification, transcription, a browser step you can watch.

• Any workflow where the data must stay on the machine, and a hosted model is not an option.

• A high-volume pipeline where the marginal token cost is the constraint, and a sample check is affordable.

• A fine-tuning project on your own terminology, where the doing is the learning.

When to keep this tool out:

• Any question that requires knowing a fact you cannot verify from a source you already have.

• Agentic coding, multi-step reasoning and long-document analysis, which the vendor's own documentation rules out.

• An unattended pipeline whose output ships to a customer without a human read.

• A multilingual deliverable at scale, where independent testers report broken scripts and untranslated passages.

U365 method integration:

• LIPS + CARE: LIPS holds the task, the check and the result, and CARE's Review step is where the extraction is compared with the page. The model keeps nothing between calls, so the record is yours.

• ULM + EVA: the decision about which work a free local model should take belongs in Career and Finance and in Quality of Life planning, and ULM is the six-domain frame that holds that decision. Cost per completed task is CI-First cost engineering and the independent evaluator's metric rather than a ULM method, and EVA's Explore, Visualize and Action Plan steps are where the chosen workflow is planned.

• UP-Context: the constraint line is what a small model needs most. A prompt that names the schema, the forbidden inferences and the output shape gets a usable answer; a vague prompt gets fluent filler.

• SL-OS: a local model is the privacy-preserving option for the personal-data workflows in SL-OS, and the one that keeps working when a subscription lapses.

• UNOP: weak. The model produces rather than teaches, and the teaching in this family is in the fine-tuning workflow rather than in the chat.

Over-delegation warning: The failure mode with LFM3 is subtle because the model is fast and free. A reader routes more and more checking to a model that answers in half a second, stops opening the source document, and keeps a pipeline running on output nobody has read. The bill does not warn you, because there is no bill. The warning sign is that you cannot say which of last week's items you actually checked. Keep one workflow entirely by hand, and keep the base model as the baseline for any fine-tune, because a model you tuned without a comparison is a model you cannot defend.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

What Users Say

Aggregate Rating Table

Platform	Rating	Number of reviews	Link
Hacker News	171 points and 67 comments on the launch thread, read 2026-11-01	Not a rating platform	https://news.ycombinator.com/item?id=50262229
Hugging Face, LFM3-1.7B	671 likes and 37,568 downloads in the last 30 days, read 2026-11-01	Not a rating platform	https://huggingface.co/LiquidAI/LFM3-1.7B
Hugging Face, LFM3-1.7B-GGUF	167 likes and 150,260 downloads in the last 30 days, read 2026-11-01	Not a rating platform	https://huggingface.co/LiquidAI/LFM3-1.7B-GGUF
Ollama library	31,000 downloads, updated three days before it was read	Not a rating platform	https://ollama.com/library/lfm3
GitHub, Liquid4All/cookbook	2,735 stars, 420 forks, 23 open issues, last push 2026-10-27	Not a rating platform	https://github.com/Liquid4All/cookbook
Reddit, r/LocalLLaMA	Mixed. The launch thread carried 513 in activity as summarised by Latent Space, and the thread itself was not readable as a page for this review, so no comment in it is quoted	One launch thread	https://www.reddit.com/r/LocalLLaMA/
G2	No model-level rating. G2 rates products, not individual open-weight checkpoints	Not applicable	https://www.g2.com
Capterra	No model-level rating found	Not applicable	https://www.capterra.com
Trustpilot	No model-level rating. Liquid AI is rated as a company, not as a model	Not applicable	https://www.trustpilot.com
Product Hunt	No separate LFM3 listing found	Not applicable	https://www.producthunt.com

Note on method, stated plainly because it affects how much this section is worth. No review platform rates an individual open-weight model. Every figure above is a download count, a like count or a discussion thread, and five days after launch the meaningful signals are the developer discussion and the practitioners who ran the model themselves. The Reddit entry links to the platform root because the thread itself could not be read, and it is reported rather than quoted for that reason.

What Users Praise

Three themes dominate the discussion.

Capability per parameter is the thing people did not expect. The launch thread's most repeated reaction was surprise that a 1.7B model posts WebArena-Verified numbers ahead of a 9B competitor, and the independent testers who ran it found the behaviour they were promised: one API tester asked for weather in two cities in a single message and got two tool calls with valid JSON arguments in one response.

The footprint is the point for practitioners. Testers ran it on a Raspberry Pi 5, a 64 GB Surface Laptop and a 32 GB Mac Mini, and reported 60 to 70 tokens per second through LM Studio and about the same inside an agent runtime with the context nearly half full. A model that runs on hardware people already own is the sentence that recurs.

Liquid's staff answered technical questions in the thread, and the answers were more useful than the launch post. The team confirmed that the single-modality models beat the omni model at their own modality, recommended the audio model for transcription and the text model for the reasoning pass, and pointed to fine-tuning notebooks and MLX exports. That is a support signal a reader should weigh positively.

What Users Complain About

Four complaints recur.

Latency on the default path, and the fix that requires a GPU. One tester found the latency high on CPU and much faster after switching to MLX on a Mac GPU. That matches this review's own measurement: usable on CPU, comfortable only on a machine with acceleration.

The thinking pass consumes the output budget. An independent tester's first API call came back empty because the reasoning pass used all 200 tokens, and this review's own first run returned a truncated answer for the same reason. It is a configuration problem with a one-line fix, and it is the first thing a new user hits, which makes it a documentation problem.

Model selection is confusing, and the smaller model is sometimes better at the same task. A user reported that the vision model gave better text-only answers than the text model in the playground, with the example that LFM3-1.7B said a cow says "Oink". Liquid's staff confirmed the general pattern: the specialised models are stronger at their own modality than the omni model, so the family invites a choice that the naming does not make obvious.

The licence is not open source in the sense many users mean. Testers noted the LFM Open License is not MIT or Apache 2.0 and flagged the revenue threshold. It is a fair complaint about vocabulary and a manageable condition in practice for a university.

Sentiment Summary

Overall sentiment: Predominantly positive on capability, footprint and the fine-tuning path, with reservations on knowledge, latency and the licence.

Key themes:

• A 1.7B model leading agentic benchmarks against a 9B competitor is the surprise of the release, and it reproduces in small independent tests.

• Running on a Raspberry Pi, a laptop or a Mac Mini is the feature that makes the family matter.

• The thinking default wastes a new user's first call.

• Knowledge and multilingual work are weak, and testers found both quickly.

• The licence threshold is understood as a commercial condition rather than a defect.

U365 Editorial Note

User sentiment and the CI-First evaluation agree on almost everything, and the one place they diverge is the place a reader most needs to hear.

They agree on capability, on footprint and on the fine-tuning path. They agree that the knowledge is thin, because the testers found it in an afternoon: a cow that says "Oink", broken scripts in a multilingual test, and a first call that returned nothing. Where the framework goes further is on what free and fast does to a reader's attention. Every complaint in the record is about a single query going wrong, and a single wrong answer is easy to catch. The framework's question is what happens at volume: a model that answers in half a second, at no marginal cost, inside an agent that runs continuously, produces decisions faster than a person can check them. The Quantity Illusion and the Skill Illusion are Medium for exactly that reason, and the mitigation is a sampling rule written down before the pipeline starts, not a better prompt.

The score of 4.8 credits the tool with the work it genuinely does. The badge describes the discipline the score assumes.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Comparison and Alternatives

LFM3 is one family competing with several, and the honest comparison is by task rather than by average score.

The family, on one page

Model	Price per 1M	Context	What it is for
LFM3-1.7B	$0.08 input, $0.20 output	256K	Local agents, tool calling, structured extraction
LFM3-VL-2B	$0.10 input, $0.50 output	128K	Documents, charts, app screens, video, spatial reasoning
LFM3-Audio-2B	$0.10 text, $2.00 audio in, $1.00 text, $10.00 audio out	32K	Transcription, speech understanding, speech output, tool calls from voice
LFM3-Omni-2B	Same as audio plus $0.10 image	32K	Spoken visual question answering, video with sound
d1-2B and d1-Omni-2B	$0.02 input, $0.00 output	128K	Routing, triage, moderation, extraction, reranking, with calibrated probabilities
LFM3-1.7B-Base	Free weights	256K	Your own post-training

Against the models a buyer is actually choosing between

Alternative	Choose it if	Choose LFM3 if
Qwen3.5-9B	You need knowledge, coding or long-context work: GPQA Diamond 80.40 against 63.37, SWE-bench 51.20 against 43.40, RULER 128K 87.11 against 65.56. It is the stronger model when your hardware can carry it	You need the work to run on a laptop or a phone, and the task is tool calling or extraction rather than knowing things
Gemma 4 E4B	You are already in the Google product range and want a larger multimodal model: it is 8B against 1.7B, and it leads LFM3-Audio-2B on spoken tool calling in the vendor's own table, 72.40 against 58.50	You want the smaller footprint, the documented fine-tuning stack, and a model that fits in about 1 GB at 4-bit
MiniCPM5-2B	You want a small general model with a broader knowledge base for its size: GPQA 65.15 against 63.37	You want the agentic and tool-use behaviour, where LFM3 leads by a wide margin: AutomationBench 41.29 against 4.71
LFM2.5-24B-A2B	You can run a 24B mixture-of-experts model and want the stronger sibling from the same vendor, at $0.05 input and $0.70 output through the API	You need the edge footprint, or the tool-call format that the newer generation brings
A hosted frontier model	The task is knowledge work, analysis or coding, and a wrong answer costs more than the tokens	The data must stay local, the task is narrow, or the volume makes per-token pricing the constraint

Where LFM3 is clearly better. Tool calling, instruction following and browser control at a two-billion-parameter footprint. The vendor's own table puts it ahead of a 9B model on every agentic row and ahead of its own predecessor by a factor of ten on WebArena-Verified. For a reader whose task is a local agent, this is the model class to beat.

Where LFM3 is clearly worse. Knowledge, coding and long context. The gaps are not marginal: 17 points of GPQA Diamond, 8 points of SWE-bench Verified, and 22 points of RULER at 128K. No amount of prompting closes a knowledge gap in a model this size, and a reader who needs those capabilities should choose the larger model and accept the footprint.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Verdict and Next Steps

Adopt LFM3 for the narrow local task with a checkable end state, keep a larger model for anything that requires knowing, and write the sampling rule before the pipeline runs.

LFM3-1.7B is the first small model in this series that a reader can hand a real agent task and expect a correct tool call. It installs in one line, runs in about two gigabytes of memory, answers at 49 tokens per second on eight CPU threads, and follows a structured instruction set well enough to build a document pipeline around. Those are the reasons the score is a Positive recommendation rather than a curiosity.

The reasons it is not higher are equally specific. It fabricates facts in fluent prose. Its coding and long-context numbers are weak by its own vendor's measurement. Its thinking default breaks the first prompt a new user tries. And the licence is a revenue test rather than an open-source grant. None of those is a reason to avoid it for the workflow it is built for, and every one of them is a reason to keep it away from the workflow it is not.

Next steps, in order:

• Run one narrow workflow for a week with a recorded sample check. Measure the error rate on the extracted fields, not the time saved. The error rate is the number that decides whether the workflow survives.

• Turn thinking off for latency-sensitive work, and raise the output limit for anything that needs the reasoning pass. Do this before you judge the model on speed.

• Pick the model by input modality, not by the family name. The text model for text, the vision model for images, the audio model for speech, and the decision model where you need a probability rather than a sentence.

• Read the licence against your organisation's revenue before the pilot, not after. Below $10 million the weights are free for commercial use; at or above it, a paid licence is required.

• Confirm the context limit on the surface you deploy. The weights document 256K and the hosted API is reported at 128,000, and a pipeline designed on one can fail on the other.

• Keep the base model as your baseline for any fine-tune. A tuned model without a comparison is a claim rather than a result.

UP-Context prompt pack

Prompt 1: The extraction with a flag list.

Context: [Describe the document set, the field list and the format you need, with one worked example.] Role: AI as a careful assistant who transcribes what is on the page and marks what is not. I own the field list, the sample and the error rate. Profile: Act as a Co-Worker and Assistant (level 2), the profile this task needs. Task: Extract the fields for each document and return one row per document in the format of the example. Constraints: Do not infer a missing value. Set it to null and add the field to a flags array. Do not correct totals. Do not use outside knowledge. If two documents disagree, keep both values. Output: A table with one row per document, then a list of every document you flagged, with the reason. Memory: this pack keeps no standing instruction on the model, so the field list, the flag log and the error rate go into my LIPS project record. UP-Context-Engineering verification: I will compare every field with the page, and I will treat a plausible value that is not on the page as an error. Data safety: Keep the documents on the local machine, and do not paste them into a hosted service for a second opinion.

Prompt 2: The tool call with a stop condition.

Context: [The item to triage, the one function you are allowing, and the schema.] Role: AI as a routing assistant working under supervision. I own the function list and the check on every argument. Profile: Act as a Co-Worker and Assistant (level 2), the profile this task needs. Task: Decide whether the function applies, and call it at most once with the required arguments. Constraints: Never invent an identifier. If a required field is missing, do not call the function; ask for it. Do not call a second function. Output: One tool call, or one sentence explaining why no call was made. Memory: this pack keeps no standing instruction on the model, so the function schema, the item and the call log go into my LIPS project record. UP-Context-Engineering verification: I will check the function name and every argument against the source before the runtime executes it. Data safety: The item stays local; the runtime logs the call, and I read the log.

Prompt 3: The fine-tune plan with a held-out test.

Context: [The task, the 300 labelled examples, and the format you need.] Role: AI as a fine-tuning coach who explains each decision and then asks me to make it. I own the split, the held-out test and the before-and-after scores. Profile: Act as a Professor, Coach and Tutor, the profile this task needs. Task: Propose a train, validation and test split, a target format, and three evaluation questions that would show whether the fine-tune generalised. Constraints: Do not invent labels. Do not use the test set to choose a checkpoint. If the dataset is too small, say so and stop. Output: A plan with the split, the format, the three questions and the failure mode you expect. Memory: this pack keeps no standing instruction on the model, so the split, the evaluation questions and the scores go into my LIPS project record. UP-Context-Engineering verification: I will run the held-out test myself and record the before and after scores against the untuned model. Data safety: The training data stays on the machine that runs the fine-tune.

Related U365 content

• The CI-First Evaluation Framework, for the scoring method and the bands used here: CI-First Evaluation Framework

• Published INSIDE Tools reviews, including the local-inference tools this model runs on, for calibration: INSIDE Tools reviews

• The U365 programmes where model deployment and measurement are assessed: University 365

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Status and Last Tested

Status: Active | Last tested: 2026-11-01 | Re-check: trigger-based (max 6 months)

The status is Active because the model is current, openly available, and recommended for the use cases this review names. It is not Risky. The knowledge weakness and the coding limit are not defects in the release: Liquid states both in the model card, and a buyer who reads them can plan around them. The version reviewed is LFM3-1.7B, released 2026-10-27, exercised as a Q4_K_M GGUF with llama.cpp build b12032 on Ubuntu x64.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Migration Path

Not applicable as a migration away from LFM3. The tool is Active and is not being retired or deprecated, so no reader needs a plan to leave it.

Two migrations onto it do need a plan, and they are the ones that break silently. The first is the tool-call format: LFM3 uses a superset of qwen3_coder, and a parser built for LFM2 or LFM2.5 will not read it, so the parser has to move before the model does. The second is the context assumption: a pipeline that relied on the hosted context should read the hosted limit rather than the model card, because the two numbers are not the same.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

U365's Recommendations to Learn More

These resources were curated to help you go deeper on LFM3. Every link and every video below was resolved on 2026-11-01.

Official learning resources

• Introducing LFM3: the vendor's launch post, with the family table, the architecture note, the training figures and the partner list. Read the model cards before the benchmark chart. https://www.liquid.ai/blog/lfm3

• LFM3-1.7B documentation: the specifications, the quick starts for Transformers, llama.cpp, vLLM and SGLang, the reasoning behaviour, deferred tool loading and the quantisation variants. https://docs.liquid.ai/lfm/models/lfm3-1.7b

• Tool use guide: the four-step tool-call workflow, the tag format, the complete example, tool search and the note that the format changed from LFM2. https://docs.liquid.ai/lfm/key-concepts/tool-use

• The LFM3-1.7B model card: the full benchmark table with its settings, the model details and the inference matrix. https://huggingface.co/LiquidAI/LFM3-1.7B

• The model licence in plain terms: the revenue threshold, what counts as commercial use, and the position on research, education and non-profit use. https://docs.liquid.ai/lfm/help/model-license

• The cookbook: notebooks for inference, tool calling and fine-tuning. https://github.com/Liquid4All/cookbook

Video tutorials and channels

• Introducing LFM3: Every Modality for Specialized Intelligence, by Liquid AI. The vendor's own launch video, including the flight-booking demo. Useful for the framing, and worth watching for exactly that reason. https://www.youtube.com/watch?v=6XedR2Feb6k

https://www.youtube.com/watch?v=6XedR2Feb6k

• Liquid LFM3 Is INSANE, Tiny Local AI That ANYONE Can Run, by Bijan Bowen. Runs the family on a Raspberry Pi 5 and a Surface Laptop, hooks the model into an agent runtime, and is honest about the licence. https://www.youtube.com/watch?v=SX5f8IIBriU

https://www.youtube.com/watch?v=SX5f8IIBriU

• Liquid AI's LFM3 Is CRAZY: 1.7B Model vs 9B, by Prompt Engineer 48. An independent API test that reports the empty first call caused by the reasoning pass and the two-city tool call that worked. https://www.youtube.com/watch?v=2Ybdvqt2J4Y

https://www.youtube.com/watch?v=2Ybdvqt2J4Y

• Run LFM3 1.7B Locally, by Fahd Mirza. A local install with structured output, instruction following, multilingual and hallucination tests, including the multilingual failure. https://www.youtube.com/watch?v=0w6LnKB36Es

https://www.youtube.com/watch?v=0w6LnKB36Es

Written tutorials and deep-dive articles

• VentureBeat, Liquid AI's new LFM3 models put browser agents, voice commands and image recognition onto enterprise-controlled devices: the independent coverage that carries the hosted context limit, the pricing table and the vendor's own limitation statement. https://venturebeat.com/technology/liquid-ais-new-lfm3-models-put-browser-agents-voice-commands-and-image-recognition-onto-enterprise-controlled-devices

• Hugging Face, Build specialized multimodal models with LFM3: the family table by input and output, and the fine-tuning entry points. https://huggingface.co/blog/LiquidAI/lfm3

• The LFM3 collection: all seven repositories, with the GGUF, MLX, ONNX, FP8 and NVFP4 variants. https://huggingface.co/collections/LiquidAI/lfm3

Community and social

• Hacker News launch thread: 171 points and 67 comments, including Liquid staff answering on model selection and latency. https://news.ycombinator.com/item?id=50262229

• r/LocalLLaMA: the community where the release was discussed and where local deployment problems get answered. https://www.reddit.com/r/LocalLLaMA/

• Ollama library entry: the one-line install and the variant list. https://ollama.com/library/lfm3

• Liquid AI on GitHub: the cookbook and the fine-tuning stack. https://github.com/Liquid4All

Resources on X

Dedicated X channels. The accounts below were resolved on 2026-11-01: @liquidai carries the launch announcement, the six-model thread and the video, and it is the account to follow for family releases and runtime support notes.

• @liquidai, the official account, which carried the launch thread: https://x.com/liquidai

• The launch post itself, which carried the six-model summary and the demo video: https://x.com/liquidai/status/2115128329003303107

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

CI-First Evaluation Summary Card

Field	Value
Tool	LFM3, an open-weight model family published by Liquid AI
Category	Applied AI / open-weight small language and multimodal models for on-device and edge deployment
Version reviewed	LFM3, released 2026-10-27; the text model LFM3-1.7B exercised as a Q4_K_M GGUF with llama.cpp build b12032
Status	Active
Last tested	2026-11-01
CI-First Profile	Primary: Co-Worker and Assistant (level 2). Secondary: Analyst and Tester (level 4) on the decision models and on extraction
CI-First Benefit Score	4.8 / 10 (CI-First Positive)
Time	5, a one-line install and 49 tokens per second on eight CPU threads against setup, quantisation, reasoning-setting and verification work, and a first run in this review that returned no answer because the reasoning pass used the budget
Quantity	6, free local tokens, parallel agents and one-pass decision models multiplying output, held at 6 because the usable multiple depends on a sample check
Quality	4, strong instruction following and tool calling for the size against thin knowledge, including a fabricated Oxford chancellor in this review's own test
Skill	4, a fine-tuning and deployment path that teaches real model work against a chat path that teaches nothing and can mask a missing capability
Humics Protection Badge	Humics-Neutral (0 / +3)
Creativity	0 Neutral: the model generates under direction and neither sparks nor replaces your ideation
Critical Thinking	0 Neutral: abstention behaviour supports checking while fluent fabrication rewards the reader who does not check
Social Authenticity	0 Neutral: speech output in the model's own voice with no cloning path, and no surface that sends text in your name
AI Imposture Risk	Medium overall
Time Illusion	Medium: real measured speed against runtime, quantisation and reasoning-setting overhead, and a first-call failure that looks like a broken model
Quantity Illusion	Medium: built for volume at zero marginal cost, with a 92.93 non-hallucination score as the mitigation and a fluent wrong answer as the risk
Skill Illusion	Medium: the fine-tuning path builds capability, the chat path builds none, and the agent runtimes the model was trained for write procedural memory on the user's behalf
Clause 5.2.3-a	APPLIES where LFM3 runs inside an agent runtime such as Hermes Agent, Pi or OpenClaw. The model file writes nothing; the runtime writes skills, memory and standing instructions, which is the artefact the clause governs. The floor of Medium is met, and the High threshold is not met here because the write path is the runtime's and not the model's
Clause 4.2-a	NULL. Nothing in the family sends text in the user's name, and the speech output speaks in the model's own voice with no voice-cloning path
Clause 7.5	NULL, recorded for completeness; the subsection was removed from the framework on 2026-10-13
Section 7c finding	The vendor's own model cards rule out agentic coding and complex multi-step reasoning, and the vision card also rules out multi-turn conversation, while the launch benchmark table still carries coding and agentic rows. The LFM Open License is Apache 2.0 based with a $10 million annual revenue threshold on free commercial use. The weights document a 256K context and the hosted API is reported at 128,000. No sub-score changed, for the reasons stated in the section
Superhuman usage	Invite for narrow local tasks with a checkable end state: extraction, routing, classification, transcription, a browser step you can watch, and any workflow where the data must stay on the machine. Keep out of knowledge work, agentic coding, multi-step reasoning, long-document analysis, unattended customer-facing output and multilingual deliverables at scale
Over-delegation warning	The failure mode is a reader who routes more checking to a model that answers in half a second, stops opening the source, and keeps a pipeline running on output nobody reads. The bill does not warn you, because there is no bill. If you cannot say which of last week's items you checked, the work has moved rather than been done. Keep one workflow by hand and keep the base model as the baseline for any fine-tune
Verification checklists	Per workflow, in Real Workflows: multi-model check, external source, human review and the CI-First test, plus the extraction-specific check that every field resolves against the page
U365 methods	LIPS holds the task, the check and the result, because the model keeps nothing between calls. CARE's Review step is where extraction is compared with the source. UP-Context writes the constraint and schema lines a small model needs. ULM is the six-domain frame that holds the decision about which work a free local model should take, and cost per completed task is CI-First cost engineering rather than a ULM method. UNOP is weak, because the model produces rather than teaches
Re-check triggers	A change to the hosted context limit; a licence or revenue-threshold change; a rate-card change; a new model in the family; an independent replication of the agentic lead; a change to the reasoning default; a breaking runtime change; and any revision of the vendor's own scope statement

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Glossary

CI-First

Co-Intelligence First: the U365 principle that the human is the ruler and the orchestrator and AI is the amplifier. The question this review answers with a score is whether the tool makes co-intelligence more profitable than human intelligence alone. LFM3 is a CI-First Positive tool: it amplifies a reader's capacity to run narrow work locally and privately, and it requires the reader to supply the knowledge and the checking the model cannot supply.

CI-First Benefit Score

The arithmetic mean of the four benefit dimensions, each scored 0 to 10, rounded to one decimal place. 0 to 2.0 is CI-First Negative, 2.1 to 4.0 is CI-First Neutral, 4.1 to 6.0 is CI-First Positive, 6.1 to 8.0 is CI-First Strong, and 8.1 to 10 is CI-First Transformative. LFM3 scores 4.8, which is Positive.

Time Benefit

Whether the tool returns more time than it costs, after the overhead of using it is subtracted. LFM3 is 5: a one-line install and 49 tokens per second on eight CPU threads, against the runtime, quantisation, reasoning-setting and verification work that surrounds it.

Quantity Benefit

Whether the same time produces more usable output. LFM3 is 6: tokens cost nothing on your own hardware and the decision models answer many questions in one pass, while the usable multiple is lower than the produced one because a small model's output still needs a sample check.

Quality Benefit

Whether the output is better, verified and durable. LFM3 is 4: instruction following and tool calling are strong for the size, and knowledge is thin enough that the model invented an officeholder in this review's own test.

Knowledge and Skill Benefit

Whether the user gains lasting capability. LFM3 is 4: the fine-tuning and deployment path teaches real model work, and the chat path teaches nothing.

CI-First Profile

The role the AI plays in your working relationship. (level 1) Co-Creator and Thought Partner, (level 2) Co-Worker and Assistant, (level 3) Coach and Tutor, (level 4) Analyst and Tester, (level 5) Challenger and Devil's Advocate. Lower level numbers indicate higher AI autonomy in the collaboration. LFM3 is primarily a Co-Worker and Assistant (level 2).

Humics

The set of capabilities that are uniquely human, as defined by Pascal Bornet: creativity, critical thinking and social authenticity. The framework asks whether a tool strengthens, leaves neutral or erodes each one.

Humics Protection Badge

A rating of whether a tool protects, leaves neutral or erodes the three human capabilities: Creativity, Critical Thinking and Social Authenticity. Each is scored +1, 0 or -1 and the sum gives the badge. +2 to +3 is Humics-Friendly, -1 to +1 is Humics-Neutral, -2 to -3 is Humics-Risky. LFM3 is Humics-Neutral at 0 / +3.

AI Imposture Risk

The likelihood that a tool traps you in one of three illusions. The Time Illusion is the appearance of saving time when net time is lost. The Quantity Illusion is high volume that does not survive inspection. The Skill Illusion is the appearance of competence while the underlying skill is absent or eroding. Each trap is rated Low, Medium or High with cited evidence, and the overall level is Medium when one, two or three traps are Medium, or when one trap is High with clear mitigations stated. LFM3 is Medium overall, with all three traps Medium.

User Sentiment

What the people who ran the model report, kept apart from the vendor's own benchmarks. For LFM3 the record is a launch thread, two Hugging Face repositories, the Ollama library and the GitHub cookbook, read on 2026-11-01: predominantly positive on capability, footprint and the fine-tuning path, with reservations on knowledge, latency and the licence. No review platform rates an individual open-weight model, so no aggregate score exists to quote.

Tri-hybrid architecture

The LFM3 layer mix of gated short convolutions, sliding-window attention and global attention. The convolutions handle nearby context cheaply, the sliding window covers a local span, and the global layers carry information across the sequence. The purpose is to hold a long context at a memory cost a pure transformer of the same width would not sustain.

Quantisation

Compressing a model's weights to fewer bits so it fits in less memory. LFM3 ships 4-bit and 8-bit variants and the Q4_K_M file used in this review is 1,049 MB. A lower-bit file is smaller and slightly less accurate, and the accuracy difference is the reason a fine-tune and an evaluation belong together.

Tool calling

A model emitting a structured request to run a named function with named arguments, instead of describing the action in prose. It is the capability that makes an agent possible, and it is the capability this model was post-trained for. LFM3 uses a superset of the qwen3_coder format.

Decision model

A model that returns typed answers with probabilities for a list of named questions, instead of generating text. LFM3 ships two, d1-2B and d1-Omni-2B, priced at $0.02 per million input tokens with no output tokens. The value is a judgement at a fixed cost, and the risk is a confident probability on a question the model cannot answer.

LFM Open License v1.0

Liquid AI's licence for its open-weight models. It is Apache 2.0 based, with copyright and patent grants made subject to a commercial use limitation: free commercial use is limited to organisations under $10 million in annual revenue. Research, education and non-profit use carries no revenue limit, and fine-tunes stay private with no copyleft.

Review Status

The badge at the top of this review. The vocabulary is: Active, the tool is current and recommended; Active (updated), recently re-checked and refreshed; Changed, a re-check trigger has fired and an update is pending; Risky, the tool has significant unresolved issues or has been clearly surpassed, so use it with caution; Stale, not re-checked in over six months, so pricing and features are unverified; Retired, the tool still works but is no longer recommended; Deprecated, the tool has been shut down or fundamentally changed.

Last tested and Re-check

The date this review's evidence was gathered and the condition that forces a new pass. LFM3 was tested on 2026-11-01 and re-checks on any of the eight triggers listed at the top of this document, and in any case within six months.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Sources

Vendor primary sources

• The launch post, for the family table, the architecture and training figures, the modality descriptions, the runtime and partner list and the open-weight statement: https://www.liquid.ai/blog/lfm3

• The LFM3-1.7B documentation, for the specifications, the quick starts, the reasoning behaviour, deferred tool loading and the quantisation variants: https://docs.liquid.ai/lfm/models/lfm3-1.7b

• The tool use guide, for the four-step workflow, the tag format, the complete example and the LFM2 format change: https://docs.liquid.ai/lfm/key-concepts/tool-use

• The LFM3-1.7B model card, for the full benchmark table and its settings, the model details and the inference matrix: https://huggingface.co/LiquidAI/LFM3-1.7B

• The LFM3-VL-2B model card, for the encoder composition, the 128K context, the 62-benchmark table and the scope statement: https://huggingface.co/LiquidAI/LFM3-VL-2B

• The LFM3-Audio-2B model card, for the 32K context, the speech locales, the ASR and TTS benchmarks and the codec description: https://huggingface.co/LiquidAI/LFM3-Audio-2B

• The LFM3-Omni-2B model card, for the 2.17B parameter count, the 32K context and the omni benchmark table: https://huggingface.co/LiquidAI/LFM3-Omni-2B

• The d1-2B model card, for the decision contract, the 128K context and the decision benchmark board: https://huggingface.co/LiquidAI/d1-2B

• The d1-Omni-2B model card, for the audio decision variant: https://huggingface.co/LiquidAI/d1-Omni-2B

• The pricing page, for the API rate card, the free credit and the licence tiers: https://www.liquid.ai/pricing

• The licence in plain terms, for the revenue threshold and the definition of commercial use: https://docs.liquid.ai/lfm/help/model-license

• The full LFM Open License: https://www.liquid.ai/lfm-license

• The model collection, for the seven repositories and the GGUF, MLX, ONNX, FP8 and NVFP4 variants: https://huggingface.co/collections/LiquidAI/lfm3

Independent and industry sources

• VentureBeat, Liquid AI's new LFM3 models put browser agents, voice commands and image recognition onto enterprise-controlled devices: the hosted context limit, the API pricing table, the vendor's limitation statement and the hardware notes: https://venturebeat.com/technology/liquid-ais-new-lfm3-models-put-browser-agents-voice-commands-and-image-recognition-onto-enterprise-controlled-devices

• Hugging Face, Build specialized multimodal models with LFM3: the input and output table by model and the fine-tuning entry points: https://huggingface.co/blog/LiquidAI/lfm3

• Latent Space, AI news roundup for 2026-10-28: the r/LocalLLaMA activity figure and the community summary quoted in this review: https://latent.space/p/ainews-anthropic-ends-coding-interviews-hunger-beats-tenure/

• The University of Oxford, Chancellor page: the record used to check the fabricated officeholder: https://ox.ac.uk/about/organisation/university-officers/chancellor

• Ollama library, lfm3: the one-line install, the download count and the variant list: https://ollama.com/library/lfm3

• GitHub, Liquid4All/cookbook: the star, fork and issue counts and the last push date: https://github.com/Liquid4All/cookbook

• GitHub, llama.cpp pull request 31252: the LFM3-1.7B and LFM3-VL-2B support merged on 2026-10-27: https://github.com/ggml-org/llama.cpp/pull/31252

• GitHub, llama.cpp pull request 31257: the LFM3-Audio-2B and LFM3-Omni-2B support merged on 2026-10-27: https://github.com/ggml-org/llama.cpp/pull/31257

Community and community-reported evidence

• Hacker News launch thread, 171 points and 67 comments, read on 2026-11-01: https://news.ycombinator.com/item?id=50262229

• r/LocalLLaMA, the community where the release was discussed: https://www.reddit.com/r/LocalLLaMA/

• Bijan Bowen, Liquid LFM3 Is INSANE, Tiny Local AI That ANYONE Can Run: the Raspberry Pi and Surface Laptop runs, and the licence comment: https://www.youtube.com/watch?v=SX5f8IIBriU

• Prompt Engineer 48, Liquid AI's LFM3 Is CRAZY: 1.7B Model vs 9B: the independent API test, the empty first call and the two-city tool call: https://www.youtube.com/watch?v=2Ybdvqt2J4Y

• Fahd Mirza, Run LFM3 1.7B Locally: the structured output pass, the multilingual failure and the hallucination test: https://www.youtube.com/watch?v=0w6LnKB36Es

• Execute Automation, Liquid AI LFM3: Tiny 1.7B Model, BIG Performance: the LM Studio and OpenClaw measurements on a 32 GB Mac Mini: https://www.youtube.com/watch?v=hRAcENmD25U

Review platform sources

• G2, checked and carrying no model-level rating: https://www.g2.com

• Capterra, checked and carrying no model-level rating: https://www.capterra.com

• Trustpilot, for the company-level rating that is not a model-level rating: https://www.trustpilot.com

• Product Hunt, checked and carrying no separate LFM3 listing: https://www.producthunt.com No platform rating an individual open-weight model was found on 2026-11-01. This review states that rather than inventing an aggregate.

Framework and method

• The U365 CI-First Evaluation Framework, version 1.4.1, which is the scoring method used here: CI-First Evaluation Framework

• The U365 INSIDE Tools review template, which sets the structure of this post and the LLM and open-source variants applied in it: INSIDE Tools review template

• Published U365 INSIDE Tools reviews read as calibration for this score, including llama.cpp, Ollama, llama.cpp's re-score and the local-inference tools this model runs on: INSIDE Tools reviews

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Faculty Note on Evidence Quality

Six things should be said plainly about the evidence behind this review, because they change how much weight a reader should put on each part of it.

First, the score is anchored on one model in a family of seven repositories. LFM3-1.7B was downloaded, served and probed for this review. The vision, audio, omni and decision models were read from their model cards and are quoted as the vendor's measurement. Their benchmark rows are strong, and none of them was exercised here. A reader choosing the audio model should treat this review as a guide to the family's architecture and licence, not as a test of that model.

Second, the benchmark table is the vendor's, and the vendor ran the comparison. Every row in How LFM3 Works comes from Liquid's own model card, with the settings Liquid chose, against models Liquid selected. The competitor figures may or may not reproduce under another runtime. The one number this review leans on hardest, the non-hallucination score of 92.93, is also Liquid's, and it is the number a sceptical reader should test first, because it is the claim that most changes the recommendation.

Third, the hands-on test is small and it is stated as small. One GGUF, one machine, one runtime, eight CPU threads, four prompts. It produced three findings worth publishing: a correct tool call, a correct arithmetic answer, and a fabricated officeholder checked against the university's own page. A larger test would produce more of the third finding or fewer, and either result would be evidence.

Fourth, the speed figures depend on the machine and the quantisation. 49 tokens per second on eight CPU threads at Q4_K_M is the number this review measured, not a promise about your laptop. An Apple silicon machine with MLX, a Qualcomm device through AI Hub and an NVIDIA GPU through vLLM will all differ, and the vendor's own hardware table gives ranges rather than a single figure for that reason.

Fifth, the hosted figures are reported rather than measured. The 128,000-token hosted context and the API rate card come from VentureBeat's reading of Liquid's console. This review did not read the console, and the pricing page it did read lists rates without a context figure. The distinction between the weights and the hosted surface is well attested, and the exact hosted number should be confirmed on the console before a deployment depends on it.

Sixth, one favourable finding is stated as prominently as the adverse ones. The tool-call behaviour is genuinely good for a model this size: correct function, correct arguments, one pass, and a finish_reason that says tool_calls rather than pretending. The instruction-following scores are high, and the abstention rate suggests the model was trained to decline rather than invent. Those are the reasons this review recommends it for narrow work rather than merely tolerating it, and they sit in the same document as the fabricated chancellor because a reader deciding what to put in a pipeline needs both halves at once.

LFM3: Liquid AI's six small models for specialized intelligence on your own machine

---

Status and Re-check

Status: Active | Last tested: 2026-11-01 (LFM3-1.7B Q4_K_M, llama.cpp build b12032, Ubuntu x64 CPU) | Re-check: trigger-based (max 6 months)

Active: the tool is current and recommended. It is recommended for the narrow local workflows this review names, and not for the knowledge work it rules out.

For detailed explanations of the CI-First evaluation terms used in this review, including the Humics Protection Badge and the AI Imposture Risk levels, see the Glossary at the end of this post.

Re-check triggers:

• A change to the hosted context limit. The downloadable text model documents 256K tokens. VentureBeat reports that Liquid's hosted console lists 128,000 tokens for the API version. If the hosted limit moves to match the weights, the deployment decision in this review changes.

• A change to the LFM Open License, in particular the $10 million revenue threshold. Every commercial sentence here is conditional on that number, and a licence revision would move the tool from free-at-your-scale to a negotiation for many readers.

• A change to the $0.08 input and $0.20 output rate card, or to the audio lines at $2.00 input and $10.00 output per million tokens.

• A new model in the LFM3 family, or a 2.5-generation successor. The score is anchored on the 1.7B text model, and a stronger text model in the same footprint would change the benefit dimensions rather than the family structure.

• An independent replication of the agentic benchmark lead. WebArena-Verified at 38.42 against 28.94 for Qwen3.5-9B is the strongest claim in the release and it is the vendor's own measurement.

• A change to the default reasoning behaviour. The text model reasons before it answers by default, and that default consumed a 160-token budget before the answer began in this review's own test.

• A breaking change to llama.cpp, Ollama or LM Studio support. Same-day runtime support is a large part of the Time Benefit, and it is maintained by third parties.

• Any change to the vendor's own "not recommended for agentic coding or complex multi-step reasoning" statement. That sentence sets the boundary of this review, and its removal would not make the model better, but its revision would change what a reader should expect.