LFM3-1.7B vs Qwen3.8-Flash: When There Is No Scoreboard to Compare

Ten million tokens a month, split 70/30 between input and output, costs $2.46 on Qwen3.8-Flash at Alibaba's list price of $0.15 and $0.47 per million. The same volume on LFM3-1.7B costs roughly $1.16, if the reported hosted rate of $0.08 and $0.20 holds — and nothing at all per token if you self-host it, because the weights are open and the LFM Open License asks for no royalty below $10 million in revenue. That is a 2× spread on the meter between two models whose relative quality nobody can currently establish. Which makes this comparison less about benchmarks than most vs pages are, and more about what shape of deployment you are buying.

The two models could hardly be less alike. LFM3-1.7B is a 1.73B dense tri-hybrid that Liquid AI released on 27 October 2026 to run a specialised job on the hardware in front of you. Qwen3.8-Flash is Alibaba's sparse mixture-of-experts, about 6B parameters active per token out of a much larger pool, shipping in August 2026 as a hosted tier with a 1M-token window and image and video input. Comparing them on an intelligence score is like comparing a delivery van to a freight train: the useful question is what you are moving and how far.

Two architectures optimised for opposite constraints

LFM3-1.7B's 24 layers mix 13 gated short convolutions, 5 sliding-window attention layers with a 256-token window, and 6 global attention layers. Convolutions are cheap and parallel; a thin band of global attention keeps the whole 256K context reachable. The result is a 128K KV cache of 1.6 GB and a model that fits in about 1 GB at 4-bit. Liquid trained it on 22 trillion pre-training tokens, then 3.5 trillion of mid-training heavy on agentic traces and tool calls.

Qwen3.8-Flash makes the other trade. Sparse activation means a large parameter pool is reachable per token without paying for all of it, which is how Alibaba gets a 262K native context extendable to 1M on a model priced in the same bracket as much smaller dense ones. It takes text, image and video in and returns text, supports tool calls and JSON output, and is explicitly positioned as an architectural preview of the Qwen4 line.

• Active parameters — LFM3-1.7B 1.73B dense vs Qwen3.8-Flash roughly 6B per token in a sparse MoE.

• Context — 256K open weights, 128K on Liquid's hosted API vs 262K native, 1M on the hosted tier.

• Max output — not separately specified for LFM3 vs 131K for Qwen3.8-Flash.

• Modalities in — text only vs text, image and video.

• Where it runs — your device, with a 1 GB 4-bit footprint vs Alibaba's servers.

• Weights — open under LFM Open License v1.0 vs hosted only, no open checkpoint for this SKU.

That last row is the one that reframes everything else. Qwen3.8-Flash is not a model you own. There is an open-weight sibling, Qwen3.8-Flash-Next, under a community licence, but it is a different checkpoint with different scores and it is not what the $0.15 rate buys. LFM3-1.7B is a file you download. One of these can be air-gapped, audited and fine-tuned on your own data; the other cannot.

The scoreboard that is missing on one side and contradictory on the other

Here is the uncomfortable part. As of 28 October 2026, LFM3-1.7B has no Artificial Analysis entry — no Intelligence Index, no independently measured output speed, no neutral latency figure. Every performance number attached to it comes from Liquid's own 27-benchmark table, where it averages 49.37 and beats Liquid's own LFM2.5-2.6B by a wide margin. Vendor-reported, unreproduced.

Qwen3.8-Flash does have an Artificial Analysis entry, and reading it is instructive for the wrong reason. The live comparison pages show it at an Index of 40. Multiple secondary write-ups, including reviews and regional press, report the same model at 56. The output-speed figures disagree too: figures in the low 50s to low 80s tokens per second appear across sources. We are not going to pick one and present it as fact, because the two numbers cannot both describe the same evaluation run and the difference is large enough to change a procurement decision.

The practical consequence is that neither model can be ranked against the other on quality with any confidence at all. One side has a number that moves by sixteen points depending on where you read it; the other has no independent number to move. Anyone who hands you a verdict on "which is smarter" from these inputs is inventing it. What can be compared is everything else: what the model costs, where it runs, how fast it answers, and what happens when it fails.

The meter, worked

Cost is the axis where both sides are actually measurable, so it deserves more than a per-token list.

• Qwen3.8-Flash list price — $0.15 per million input, $0.47 per million output, cache read $0.018, cache write $0.230.

• LFM3-1.7B hosted — reported at $0.08 input and $0.20 output per million, not published on Liquid's own rate card.

• LFM3-1.7B self-hosted — no per-token cost; the LFM Open License is royalty-free below $10 million annual revenue.

At 10 million tokens a month on a 70/30 split, Qwen3.8-Flash bills $2.46. Enable prompt caching on a stable system prompt and that falls toward $2.00, because cached reads cost roughly an eighth of fresh input. LFM3-1.7B at the reported rate bills about $1.16 for the same volume, and self-hosting bills zero per token with a fixed machine cost on top.

Now scale it. At a billion tokens a month the gap is $246 against $116 — still small in absolute terms, which is the point that usually gets lost in these comparisons. The per-token difference between a cheap hosted tier and a cheap self-hosted model is noise for most teams. The cost that actually dominates is engineering time: a hosted model is an HTTP call, and a self-hosted one is a deployment, a quantisation choice, a serving stack and an on-call rotation. LFM3's 2× price advantage has to be worth that. For a 2B model on a phone or an edge box, it obviously is — there is no hosted alternative that runs on the device at all. For a backend service handling classification calls, it usually is not.

How fast each one answers, with real numbers on one side

This is where our own data is better than the vendor's. OrcaRouter routes Qwen3.8-Flash, and over the last seven days our telemetry across the providers serving it shows a p50 time to first token of 4.82 seconds, p95 of 10.00 seconds, an output speed of 155 tokens per second and a 3.3% error rate across 883.7 million tokens. Those are aggregate figures from a routing layer rather than a single-endpoint lab test, which is why the throughput reads higher than the low-50s figures published elsewhere: the request lands wherever capacity exists.

The p50 of 4.82 seconds is the number to sit with. For a chat interface that is fine. For an agent making fifteen sequential calls it is a minute of waiting before any work happens, and no amount of tokens-per-second fixes it. High first-token latency on a large sparse model is the hidden cost of the cheap tier, and it is the reason some teams route short, latency-critical turns to something smaller.

LFM3-1.7B has no equivalent measurement. Liquid's speed claim is that at Q4_0 and 32K context it was 1.8× to 2.8× faster than the next model on three test devices with the lowest memory use, and that a single NVIDIA B300 running SGLang in BF16 served 3.6 billion tokens per day at 1,024 concurrent requests. Those are on-device and single-node figures respectively; neither maps onto "what will my p50 be from Frankfurt". Speed is the axis where LFM3's case is strongest in principle and least verifiable in practice.

Where each one actually wins

LFM3-1.7B wins on control and on cost at the edge. Open weights mean you can fine-tune it on a single GPU, freeze the version, run it with no network, and keep the data on the device. Its instruction-following numbers are the standout part of Liquid's table — IFEval 96.66, IFStruct 93.72, Multi-IF 89.10 — and its tool-calling rows are respectable for the size, BFCL V4 at 71.39 and ToolSandbox at 80.36. Its weak rows are equally clear: Terminal-Bench 2.1 at 12.92 and SWE-bench Multilingual at 23.00 say this is not an autonomous coding model, and Liquid's own model card says as much.

Qwen3.8-Flash wins on reach. A 1M-token window with image and video input is a capability LFM3 does not have in any form: the text model takes no images at all, the vision variant publishes no context window, and the omni variant's window is undocumented. For a workload that ingests a long contract, a set of screenshots, or an hour of frames, the comparison ends immediately. It also wins on operational simplicity: one endpoint, no GPU, no deployment.

Routing both, which is the point

Qwen3.8-Flash is in the OrcaRouter catalogue and LFM3-1.7B is not. That sentence is the whole honest version of this section. We route the hosted model at provider list price with 0% markup, so Alibaba's $0.15 and $0.47 are what you pay and a vendor price change reaches you the same day rather than at the next contract renewal. LFM3 you run yourself or call on Liquid's own API; we are not going to imply a hosting relationship that does not exist.

The reason routing matters in this specific matchup is that the two models occupy different failure modes. Qwen3.8-Flash fails by being slow and expensive on the turns that did not need 1M tokens of context. LFM3 fails by running out of reasoning depth on the turns that did. A pipeline that sends every request to either one is wrong in a predictable direction. With the routing DSL you can send extraction, classification and short tool-calling turns to the small local model, keep long-document and multimodal work on the hosted tier, and let automatic failover cover the case where the small model returns something malformed — which, on an unverified 1.7B, is the realistic worry.

That is also the cheapest way to find out whether LFM3 deserves the trust its launch table asks for. Run it on the traffic you already understand, behind a fallback, and compare its decisions against the hosted model's on the same inputs. The disagreement rate is a better quality signal than any vendor benchmark, because it is measured on your data.

The decision, without a fake verdict

Choose Qwen3.8-Flash if the work involves long documents, images or video, if you need one endpoint and no infrastructure, or if a p50 first token near five seconds is acceptable. Its quality is uncertain but at least measurable by someone other than its maker, and its 1M context is not something a 1.7B model can substitute for.

Choose LFM3-1.7B if the model has to live on a device, if the data cannot leave your network, if you intend to fine-tune, or if your workload is short instruction-following and tool-calling turns where a 2B model at 1 GB is genuinely sufficient. Accept that you are taking Liquid's benchmark table on faith and that the first month will involve more measurement than a hosted model would demand.

What you should not do is pick between them on intelligence. One has no independent score, the other has a score that reads 40 or 56 depending on which page you open, and the sixteen-point gap between those two readings is larger than the entire quality difference either vendor is trying to sell you. Cost, context, modality and locality are settled facts. Quality is not, and a comparison that pretends otherwise is just a launch table with the vendor's name filed off.