LFM3 vs Qwen3.8-27B: A 16× Size Gap That Narrows to 9% on Instruction Following

LFM3-1.7B carries 1.73 billion parameters. Qwen3.8-27B carries 27.78 billion, plus a vision encoder — 16.1 times as much weight. Put them on the same benchmark line and the arithmetic refuses to behave. On IFBench, which tests whether a model obeys constraints it was never fine-tuned on, the gap between them is under nine percent. On Terminal-Bench 2.1, it is 5.6 times. Two models, one fixed size difference, and a result that swings from "why would you ever pay for the big one" to "the small one cannot do this at all" depending on the row you read.

That swing is the whole decision. This is not a story about a small model catching up to a large one, and it is not a story about a large model being wasted on small jobs. It is a story about a task boundary that runs, very consistently, between following an instruction and executing a plan — and about a licence term that quietly reorders the price comparison for anyone working at a company above a certain revenue line.

What each of these actually is

Liquid AI announced the LFM3 family on 2026-10-27 — the day before this was written — as six roughly 2B-class open-weight models branched from a shared LFM3-1.7B-Base backbone. LFM3-1.7B is the text member: a tri-hybrid architecture of 24 layers (13 gated short convolutions, 5 sliding-window attention layers with a 256-token window, and 6 full-attention layers), pre-trained on 22 trillion tokens with a final 3.5-trillion-token mid-training pass that included agent traces and tool calls. The weights are on Hugging Face, Ollama ships it as lfm3:latest at a 1.7 GB download, and the vendor's own model card advises against agentic coding or complex multi-step reasoning. That last sentence matters more than anything else on the card, and we will come back to it.

Qwen3.8-27B is not new. Alibaba published its weights in mid-August 2026 under Apache 2.0, and it has had ten weeks to accumulate downloads, quantizations and real user reports that a one-day-old release simply does not have. It is a 27.78B dense model built on a repeating block of Gated DeltaNet and Gated Attention layers, 64 layers deep, with native vision and video input and a 262,144-token context that extends to 1M with YaRN. Thinking is on by default and tunable through a reasoning-effort setting.

So the honest framing of this pairing is asymmetric in a way that matters: one model has a vendor benchmark table and no field reports, the other has both. Treat anything below about LFM3-1.7B as a claim about Liquid AI's test suite, not about your workload.

The spec line where the small model does not lose

Start with the dimensions where 16× the parameters buys nothing at all, because there are more of them than the size difference suggests.

• Context window — 262,144 tokens native on both. LFM3-1.7B reaches it during mid-training; Qwen3.8-27B ships it natively and extends to 1M with YaRN.

• Languages — 16 declared for LFM3-1.7B (including English, Chinese, Japanese, Korean, Arabic and Hindi); Qwen3.8-27B is trained broadly across languages with no headline count.

• Modality — text in, text out for LFM3-1.7B; text, image and video in, text out for Qwen3.8-27B. This is the one place the 27B is doing a categorically different job rather than a bigger version of the same job.

• Memory at 4-bit — roughly 1 GB for LFM3-1.7B against roughly 14–16 GB for Qwen3.8-27B.

• Memory at BF16 — 3.46 GB against roughly 56 GB, which is the difference between a laptop and a multi-GPU box.

• Licence — LFM Open License v1.0 against Apache 2.0. Hold that thought.

A 256K context window on both sides is the genuinely surprising line. Context length has historically tracked parameter count, and here a model you can run in about a gigabyte offers the same nominal window as one that wants a workstation. Nominal is doing real work in that sentence — a 256K window on a 1.7B model is only useful if the model can find things in it, which is exactly what the long-context rows below test.

Where 16× the parameters buys nine percent

Liquid ran a 27-row suite and published the full table, including the columns where a competitor wins. Both models report IFBench, which is the cleanest apples-to-apples row in the whole comparison because it is a single benchmark version reported by both vendors.

LFM3-1.7B scores 73.03. Qwen3.8-27B scores 79.5. That is 6.5 points, under nine percent of the larger model's score — on a model 16.1 times smaller. For a workload that is mostly "take this messy input, emit this exact JSON shape, never break the schema," that gap is close to noise, and the deployment difference is a gigabyte versus sixteen.

Liquid's own table makes the same point against a nearer competitor. Against Qwen3.5-9B — a model five times LFM3-1.7B's size — the small model wins IFBench by 24 points (73.03 to 48.84), IFStruct by 4.5 (93.72 to 89.20) and Multi-IF by 4.7 (89.10 to 84.44). Whatever else is true, instruction adherence is not a capability that scales smoothly with parameter count, and a well-trained 1.7B can beat a mediocre 9B at it.

The long-context rows are more equivocal and worth stating plainly rather than rounding in Liquid's favour. On AA-LCR, LFM3-1.7B posts 52.83 — a real score for its size, and roughly level with Qwen3.5-4B's 52.67. On RULER 128K it scores 65.56, well ahead of MiniCPM5-2B's 37.96 but far behind Qwen3.5-9B's 87.11. So the 256K window is not decorative, but it is also not the equal of a larger model's. Qwen3.8-27B does not appear in that table at all, which means there is no like-for-like long-context number for this specific pairing — only a strong prior that a 27B with native 262K will beat a 1.7B with the same nominal window.

Where 16× the parameters buys five and a half times

Now the rows the model card warned about. Every one of these is a benchmark version both vendors report, so no subtraction across versions is happening.

• Terminal-Bench 2.1 — 12.92 for LFM3-1.7B against 73.0 for Qwen3.8-27B. A 5.6× gap.

• Humanity's Last Exam, no tools — 7.17 against 30.8. A 4.3× gap.

• GPQA Diamond — 63.37 against 89.2. A 1.4× gap.

• LiveCodeBench v6 — 73.46 against 90.3. A 1.2× gap.

The ordering of that list is the finding. The gap is smallest on single-shot code generation, where LFM3-1.7B lands about 19% below a model sixteen times its size. It is largest on Terminal-Bench, where the task is not "write code" but "operate a machine across many steps, recover from your own errors, and stop when the job is done." That is precisely the capability Liquid's own card says the model lacks, and the numbers agree with the card. On GPQA and HLE the gap is knowledge, which is the least surprising result here — a 1.7B model trained on 22T tokens has simply seen less than a 27B model trained on more, and no amount of architecture compensates.

There is one row that points the other way, and it is the most interesting number on either card. On the public split of AA-Omniscience, LFM3-1.7B records 7.07 accuracy and 92.93 non-hallucination. That pair means the model mostly declines to answer rather than answering wrongly. It is the highest non-hallucination figure in Liquid's own comparison table, ahead of every larger model listed. Qwen3.8-27B's 30.8 on HLE is the opposite posture: it knows more and commits to it.

If your pipeline's failure mode is a confident wrong value landing in a database, a model that abstains 93% of the time is a feature and the accuracy ceiling is the price. If your pipeline's failure mode is a null where a value should be, that same behaviour is the bug. This is the single sharpest thing this matchup turns on, and no aggregate score captures it.

Three numbers you must not subtract

Head-to-head pages on this pairing will be tempted to line up every benchmark the two vendors publish. Three of those lines do not survive contact with the methodology.

SWE-bench. Liquid reports LFM3-1.7B at 43.40 on SWE-bench Verified with the OpenCode harness. Alibaba reports Qwen3.8-27B at 61.7 on SWE-bench Pro. Different benchmark, different harness, different task distribution. The 18-point difference between those two numbers is not a measurement of anything. If you want the rough shape of the gap, use Terminal-Bench 2.1, where both report the same version.

Any aggregate index. Artificial Analysis scores Qwen3.8-27B at 33.7 on its Intelligence Index at the xhigh reasoning setting. There is, as of 2026-10-28, no LFM3 entry on Artificial Analysis at all. A one-day-old release has not been through independent evaluation, and the honest statement is that LFM3-1.7B has zero independently reproduced numbers. Every figure attributed to it in this article — and everywhere else this week — originates in Liquid AI's own test suite on Liquid AI's chosen benchmarks.

Reasoning-effort settings. Qwen3.8-27B's published scores move substantially between low, medium, xhigh and non-reasoning modes; the 33.7 index is the xhigh number, and the non-reasoning figure is materially lower. Any comparison that pairs a Qwen number with an LFM3 number without naming the effort setting is comparing a deliberating model to a fast one and calling the difference architecture.

What would settle this is straightforward: an independent run of LFM3-1.7B on the same harnesses, at a stated effort setting, ideally after the community has had a few weeks with the weights. Until then, the fair summary is that the vendor-reported gap on instruction following is small and the vendor-reported gap on multi-step execution is large, and both claims come from the same interested party.

The licence is the actual price tag

Here is the part that reverses the usual conclusion of a small-versus-large comparison.

LFM3-1.7B ships under the LFM Open License v1.0. The weights are free to download and free to run, and commercial use is excluded for entities with annual revenue of $10 million or more. Qwen3.8-27B ships under Apache 2.0 with no revenue trigger, no field-of-use restriction and no separate agreement.

So for a two-person startup, the arithmetic is obvious: a model that fits in a gigabyte, costs nothing per token, and runs on hardware you already own is close to a free lunch. For a company past $10 million in revenue — which is to say, most companies with a production inference budget worth optimising — the cheap model is not free, and the expensive one is unambiguously licensed. The model that looks like the budget option is the one with the legal conversation attached.

That is not an argument against LFM3-1.7B. It is an argument for reading the licence before you read the benchmark table, because the licence determines whether the benchmark table is even available to you.

What it takes to actually run each one

LFM3-1.7B is a one-line install. It is in the Ollama library as lfm3:latest and lfm3:1.7b, both a 1.7 GB download with a 256K context window declared, and it runs in Transformers with single-GPU fine-tuning. The Hugging Face release includes notebooks for SFT, DPO and GRPO, including a worked example of training the model to pick the right tool out of 108 in a phone app. If your goal is a small, specialised, fine-tuned extractor that lives on the same machine as the data, this is a genuinely short path from download to deployed.

Qwen3.8-27B is a different kind of project. At roughly 56 GB in BF16 it wants a multi-GPU box or aggressive quantization; at 4-bit it fits in 14–16 GB, which is a high-end single GPU or a well-specced laptop, with KV cache pushing real memory use higher still. It runs in Transformers, vLLM, SGLang and TokenSpeed. If you do not want to own that hardware, it is available hosted — on OrcaRouter it is served by two upstream providers, at $0.33 per million input and $2.40 per million output tokens from the first and $0.40 / $4.21 from the second.

That two-provider spread is worth pausing on, because it is the kind of thing that only shows up when you look at a live catalogue rather than a press release. Same weights, same context window, roughly 75% more expensive on output from the second provider. OrcaRouter passes provider list price through at 0% markup, so both prices are visible side by side, and automatic failover means a provider hiccup routes around itself instead of surfacing to your users. If you are evaluating Qwen3.8-27B as the escalation path for a pipeline that starts on a small model, that is the leg you would put behind one key.

To be explicit about the other half: OrcaRouter does not serve LFM3-1.7B. It is a weights download, and running it is your own endpoint on your own hardware. The reason to mention us in this article at all is the escalation leg, not the small model.

Who should pick which

The decision does not really turn on the benchmark table. It turns on two questions you can answer before you run anything.

Pick LFM3-1.7B if the work is single-turn and schema-bound — extraction, classification, routing, structured output, on-device tool selection — and the data cannot leave the device. It is also the right pick if you intend to fine-tune, because a 1.7B model with an included SFT/DPO/GRPO path and a single-GPU budget is a weekend project rather than a quarter. The 256K window, the 16 languages and the abstention behaviour all point at the same use case: a narrow, high-volume, privacy-sensitive component where a wrong answer is worse than no answer, and where your company is under the revenue line.

Pick Qwen3.8-27B if the model has to plan. Multi-step agents, terminal work, long-horizon coding, anything where the model must recover from its own mistakes across a dozen tool calls — the 5.6× Terminal-Bench gap is not a tuning problem, it is the model card telling you the truth. It is also the right pick when you need knowledge rather than format, when you need vision or video input, and when Apache 2.0 is a requirement rather than a preference.

And pick both if the honest answer is that your pipeline has two halves. The pattern that fits this pairing is a cheap, local, schema-bound first pass with an escalation path to the 27B when the first pass declines — which is exactly what a model that abstains 93% of the time is built to signal. That architecture uses each model's best row and neither model's worst.

What would change this answer

Two things, and both are worth watching rather than guessing at.

The first is an independent evaluation of LFM3-1.7B. Every capability claim above rests on Liquid AI's own suite, and the Base checkpoint in this family shipped with no benchmark table at all — which tells you the family's numbers are a post-training story, not an architecture story. A neutral run on IFBench and Terminal-Bench would either confirm the split this article describes or dissolve it.

The second is whether Liquid ships a larger text model on this backbone. The entire comparison is framed by a 16× parameter gap, and the instruction-following result suggests the training recipe is doing more work than the parameter count. If a mid-size LFM3 lands, the interesting question stops being "can a 1.7B follow instructions" — it already can — and becomes "what does this recipe do with four billion parameters."

Until one of those happens, the useful summary is narrower than a scoreboard: LFM3-1.7B is a genuinely good instruction-follower that cannot plan, and Qwen3.8-27B is a genuinely good planner with a licence you can build a company on. Choosing between them is not a benchmark question. It is a question about which of those two sentences describes your workload.