LiquidAI’s 1.7B Model Makes 9B-Parameter Agents Look Embarrassingly Overweight

There’s a particular kind of schadenfreude when a 1.7B parameter model shows up to a knife fight with models five times its size and walks away with fewer scratches. LiquidAI just dropped LFM3-1.7B, and the benchmarks are making bigger models look like they’ve been skipping leg day.

The pitch is simple: a text model that runs in about 1GB of memory at 4-bit precision, fits on any phone or laptop, and was specifically post-trained for agentic harnesses like Hermes Agent, Pi, and OpenClaw. The 256K-token context window is just the cherry on top. But the real story isn’t the specs, it’s what this does to the economics of running AI agents.

The Architecture That Makes 1.7B Feel Like 9B

LFM3-1.7B isn’t just a smaller version of a bigger model. It’s built on what LiquidAI calls a “tri-hybrid” architecture, and the design choices reveal a lot about where the industry is heading.

Diagram of LFM3-1.7B's tri-hybrid architecture showing gated convolutions and attention layers — Figure 1: LFM3-1.7B combines convolutions, sliding-window attention, and global attention layers.

The 24-layer stack is a mix of three operators: 13 gated short convolutions, 5 sliding-window attention layers with a 256-token window, and 6 global attention layers. The convolutions use a kernel size of 7, up from 3 in LFM2. A sigmoid gate scales each attention head’s output, so a head can literally switch off when it has nothing to add. This isn’t just clever, it helps suppress activation outliers that typically hurt quantization. That’s why the model survives 4-bit precision without falling apart.

Partial RoPE is another subtle trick: global attention layers rotate only the highest-frequency half of each head, leaving the low-frequency half to match on content regardless of distance. SWA layers keep full RoPE. The result is that long context stays fast without sacrificing the model’s ability to track relationships across a 256K-token window.

The training recipe is equally aggressive. Pre-training ran on 22T tokens, 15T of web and synthetic data, then 3T of code/math/science at 4K context, followed by 3T tokens of curated agentic data at 32K context. Two more extension stages (128K and 256K) added another 550B tokens. The final 3.5T tokens are a mid-training stage specifically designed to prepare the model for agentic post-training.

Line chart showing the pre-training data mix: 15T web/synthetic, 3T code/math, 3T agentic data — Figure 2: Pre-training stages and token allocation for LFM3-1.7B.

Flow diagram of LFM3-1.7B post-training: SFT, RL, MOPD distillation, agentic RL — Figure 3: The four-stage post-training pipeline, including multi-teacher distillation (MOPD).

Post-training is where things get spicy. Four stages: supervised fine-tuning on 1.75T tokens, mixed reinforcement learning across many domains, then a multi-domain on-policy distillation (MOPD) where six specialist RL teachers (math, code, tool use, long context, agentic work, enterprise workflows) get distilled back into a single student model. Agentic RL comes last, running tasks inside real agent harnesses.

Benchmark Results: The Awkward Conversation at the Party

The head-to-head numbers are uncomfortable for anyone who’s been buying GPUs based on parameter count alone. On agentic benchmarks, LFM3-1.7B doesn’t just compete, it leads:

Agentic benchmark comparison (higher is better)
Benchmark	LFM3-1.7B (1.7B)	Qwen3.5-9B (9.7B)	Gemma 4 E4B (8B)
LiveClaw	45.60	35.77	20.36
WebArena-Verified	38.42	28.94	17.06
AutomationBench	41.29	15.10	1.92
ToolSandbox	80.36	76.41	69.27
BFCL V4	71.39	62.83	48.25
IFEval	96.66	92.08	90.02

Note that Qwen3.5-9B has 5.7x more parameters than LFM3-1.7B. The overall average across the entire benchmark suite tells the story: LFM3-1.7B scores 49.37, Qwen3.5-9B gets 47.24. A 1.7B model just outscored a 9.7B model on average across agents, tool use, coding, instruction following, knowledge, and long context benchmarks.

The previous generation, LFM2.5-2.6B, scored 31.55. That’s a 56% improvement from one generation to the next, with 35% fewer parameters.

Edge Inference: Where the Numbers Actually Matter

Benchmarks are nice, but the real test is whether this runs on hardware people actually own. LiquidAI measured performance with llama.cpp at Q4_0 quantization and 32K context across three devices: AMD Ryzen AI Max+ 395, Apple M5 Max, and iPhone 17 Pro.

Bar chart comparing prefill and decode throughput on three devices for LFM3-1.7B — Figure 4: Edge inference speed at 32K context; LFM3 outperforms larger models across devices.

The results: LFM3-1.7B decodes 1.8 to 2.8 times faster than the next model on all three devices, while using the least memory. Long contexts don’t blow up either, a full 128K-token context needs just 1.6GB of KV cache, against 4.3GB for Qwen3.5-4B and 5.6GB for MiniCPM5-2B.

This matters more than you might think. The KV cache is the hidden tax on long-context inference, and models that manage it efficiently can serve many more concurrent requests on the same hardware. On a single NVIDIA B300 with SGLang in BF16, LFM3-1.7B produces 3.6 billion tokens per day at 1,024 concurrent requests, more than any other model in the comparison.

Graph showing output throughput vs concurrent requests on one NVIDIA B300, LFM3 leads — Figure 5: GPU throughput scaling; LFM3-1.7B handles far more concurrent requests.

To prove the point, LiquidAI ran over 300,000 parallel LFM3-1.7B agents to investigate the Enron email archive. That’s not a benchmark, that’s a stress test of what “cheap enough to run continuously” actually means.

The Real-World Validation Nobody Can Fake

Independent testing is where edge AI claims usually go to die. MacPaw’s staff AI engineer tested LFM3-1.7B against Qwen3.5-2B on 65 everyday agent tasks in real macOS environments. The results: 64% task success versus 48%, 58% fewer tokens per task, and it got stuck in under 1% of attempts versus 15%.

“LFM3 is the first sub-2B model we’ve tested that is ready for real agent work on a Mac.”
— MacPaw Staff AI Engineer

This is consistent with the pattern we’ve seen from LiquidAI’s previous LFM2.5 release, where smaller models kept punching above their weight class. And if you’re wondering whether running agentic models on mobile CPUs at 17 tokens per second was a fluke, the LFM3 data suggests it was just the beginning.

The Honest Caveats: Where 1.7B Still Falls Short

Before you throw out your GPU cluster, the model card is refreshingly honest about limitations. LFM3-1.7B is “not recommended for agentic coding or complex multi-step reasoning due to its small size.” On SWE-bench Verified, Qwen3.5-9B still wins 51.20 to 43.40. Terminal-Bench 2.1 shows a similar gap: 17.98 versus 12.92.

Knowledge benchmarks also favor larger models. GPQA Diamond: Qwen3.5-9B gets 80.40, LFM3-1.7B gets 63.37. Humanity’s Last Exam follows the same pattern.

The mitigation is tool use. Adding search to Humanity’s Last Exam nearly doubles LFM3-1.7B’s score (7.17 to 13.90), and its non-hallucination rate on AA-Omniscience is a stunning 92.93% versus Qwen3.5-9B’s 52.59%. The model is honest about what it doesn’t know, which, for agentic applications, might be more valuable than confident hallucination.

What This Means for How You Build

The “made to be specialized” pitch is the part that should worry proprietary model vendors. Every LFM3 model can be fine-tuned on a single GPU, and LiquidAI published notebooks for SFT, DPO, GRPO, and continued pre-training. The text model alone has fine-tuning examples for structured JSON extraction, retrieval-augmented answer generation, tool calling in a 108-tool phone app, and learning a new language from raw text.

The wind turbine inspection demo is the best illustration. A few hours of fine-tuning on one A100 with about 3,000 public photos takes LFM3-VL-2B from under 10% defect classification accuracy to 67%, with detection F1 improving from 0.003 to 0.11. GPT-6 Luna, meanwhile, gets 0.01 F1 on the same task without fine-tuning.

This is the argument for on-device AI models eliminating cloud dependency taken to its logical conclusion: the model that runs where your data lives, trained on your specific domain, will beat the generalist cloud model for your specific use case.

The Economics Are the Real Story

Here’s the part that should make enterprise architects sit up: at 4-bit precision, LFM3-1.7B takes about 1GB of memory. A full 128K context needs 1.6GB of KV cache. That means dozens of agents can run continuously in the background on hardware you already own, with zero incremental cloud costs.

Tokens are essentially free at this scale. The model explicitly supports “tool search” for deferred tools, so agents can search a catalog of thousands of tools without bloating the prompt. The OpenClaw integration alone shows what this enables: browser agents, inbox triage, calendar management, web research, WhatsApp briefings, all running locally.

And if you want to scale up, the GPU economics are absurd. One NVIDIA B300 producing 3.6 billion tokens per day means you could run a fleet of specialized agents at fractions of a cent per task.

The Bottom Line

LFM3-1.7B isn’t just another small model. It’s the first time a sub-2B model has genuinely competed with models 5x its size on agentic benchmarks while running on an iPhone. The architecture decisions, tri-hybrid layers, head-wise gating, partial RoPE, are deliberate engineering choices for edge deployment, not just compression tricks.

The accelerated AI model release cycles are making this kind of iteration routine, but the direction is clear: capability per parameter, not raw parameter count, is the new battleground. If you’ve been waiting for edge AI to become practical, this is the moment.

The model is open-weight, available on Hugging Face, integrates with llama.cpp, Ollama, vLLM, and SGLang, and ships with a license that permits commercial use. The release blog post has the full benchmark tables if you want to dig deeper.

Your move, cloud providers.