LFM3-1.7B Benchmarks: A 1.7B Model Built for Agentic Tool Use
LFM3-1.7B is a 1.7B-parameter model from Liquid AI tuned for agentic tool calling and local deployment. Here's what it is and who it's for.
What is LFM3-1.7B?
LFM3-1.7B is a 1.73-billion-parameter language model from Liquid AI, built on what the company calls a tri-hybrid architecture mixing gated short convolutions, sliding-window attention, and global attention across 24 layers. It’s post-trained specifically for agentic use: calling tools, producing structured outputs, and running inside agent harnesses like Hermes Agent, Pi, and OpenClaw. It ships with a 256K-token context window and runs in roughly 1 GB of memory at 4-bit precision, which puts it within reach of phones and laptops rather than requiring a GPU cluster.
TL;DR
- LFM3-1.7B is a 1.73B-parameter text model from Liquid AI designed for local agents, tool calling, and structured output generation rather than general chat or coding.
- The model uses a tri-hybrid architecture (gated short convolutions, sliding-window attention, global attention) across 24 layers, a design choice aimed at efficiency rather than raw scale.
- It supports a 256K-token context window and fits in about 1 GB of RAM at 4-bit quantization, making it viable for on-device deployment on phones and laptops.
- Liquid AI ships the model in multiple formats, including BF16, FP8, NVFP4, GGUF, MLX, and ONNX, covering GPU inference, CPU inference, and Apple Silicon.
- The model supports deferred tool loading, letting an agent search a large catalog of tools and load only the relevant ones into context instead of stuffing every tool schema into the prompt.
- Liquid AI explicitly recommends against using it for agentic coding or complex multi-step reasoning, positioning it as a specialist rather than a generalist.
- Fine-tuning workflows (SFT, DPO, GRPO, continued pretraining) are documented for single-GPU setups, reinforcing the model’s pitch as something you adapt to a narrow domain rather than deploy as-is for everything.
Remy doesn't build the plumbing. It inherits it.
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
How is LFM3-1.7B different from a typical small model?
Most small open-weight models in the 1 to 4 billion parameter range are scaled-down general chat models. They try to do a bit of everything: conversation, light coding, summarization, some reasoning. LFM3-1.7B takes a narrower stance. Liquid AI post-trained it specifically for agentic harnesses and tool use, not as a general-purpose chatbot. The model card is direct about this: it’s not recommended for agentic coding or complex multi-step reasoning, precisely because of its size.
The architecture reflects that focus. Instead of a standard transformer stack, LFM3-1.7B mixes 13 gated short convolution layers with 5 sliding-window attention layers and 6 global attention layers. This hybrid approach is part of a broader trend among efficiency-focused labs: use attention where it matters for long-range dependencies, and use cheaper operations (convolutions, local attention windows) everywhere else. The result is a model that claims strong tool-calling behavior and long-context handling without needing the parameter count of a 4B or 7B model to get there.
What does “agentic” actually mean for this model?
In practice, agentic training means the model has been tuned to work inside a loop where it reads a user request, decides whether it needs a tool, calls that tool using a structured format, reads the tool’s response, and decides what to do next. LFM3-1.7B outputs tool calls in an XML-like format wrapped in <tool_call> tags, and its chat template is built to handle multi-turn tool conversations, including passing tool results back into the model as tool role messages.
One notable feature is deferred tool loading. Instead of putting every available tool’s schema into the context window up front, which gets expensive and noisy when an agent has access to dozens or hundreds of tools, LFM3-1.7B supports a search-then-load pattern. A lightweight search tool returns the names of relevant tools as references, and the model’s chat template inserts their full definitions only when needed. Liquid AI’s own fine-tuning example demonstrates this against a 108-tool phone app scenario, which signals the kind of real-world agent (a phone assistant juggling many small utilities) this capability targets.
Why does model size matter for agentic tasks?
Tool-calling and structured-output tasks are, in some ways, more forgiving of small parameter counts than open-ended reasoning or coding. The task is narrower: recognize intent, pick the right function, format arguments correctly. That’s a more constrained generation problem than writing correct multi-file code or working through a long chain of logical steps, which is why a well-tuned 1.7B model can plausibly compete with larger general-purpose models on these specific benchmarks even though it can’t match them on broader tasks.
This is also why Liquid AI frames the model around specialization rather than generality. The documentation recommends pairing it with retrieval or search for anything knowledge-heavy, rather than expecting the model itself to carry facts. The pitch is a small, fast, cheap-to-run model that handles the tool-routing and formatting layer of an agent system, while heavier lifting (retrieval, long reasoning, code generation) gets delegated elsewhere.
Remy is new. The platform isn't.
Remy is the latest expression of years of platform work. Not a hastily wrapped LLM.
How do you run and deploy LFM3-1.7B?
Liquid AI ships several checkpoint formats, each targeting different hardware:
- BF16 weights for GPU inference through vLLM, SGLang, or Transformers.
- FP8 and NVFP4 quantized versions for GPU inference via SGLang, useful for cutting memory and latency further on supported hardware.
- GGUF for CPU and GPU inference through llama.cpp, Ollama, or LM Studio, the path most relevant to local, on-device use.
- MLX 4-bit quantization for Apple Silicon.
- ONNX for cross-platform inference through ONNX Runtime.
This spread matters for anyone evaluating the model for production. A 1.7B model that only ran well on datacenter GPUs wouldn’t be especially interesting; the point of this size class is that it can run on a laptop or phone, and Liquid AI’s format coverage backs that up.
Sampling parameters differ by task type: general chat, tool use, and coding work best around a low temperature (0.1) with top-k sampling and a repetition penalty, while math and STEM tasks call for higher temperature and top-p sampling. Reasoning traces are enabled by default in the chat template, though Liquid AI notes this can be disabled, with the caveat that behavior gets inconsistent on reasoning-heavy prompts when you do.
Can you fine-tune LFM3-1.7B for your own use case?
Yes, and that’s arguably the main use case Liquid AI is designing for. The model card documents four fine-tuning paths through TRL, each with a Colab notebook: supervised fine-tuning for extracting structured JSON from messy documents, DPO for grounding answers in retrieved documents (or declining to answer when it can’t), GRPO for improving tool selection in a multi-tool environment, and continued pretraining for teaching the model a new language from raw text.
The common thread is single-GPU feasibility. None of these workflows assume a large training cluster, which fits the broader positioning of LFM3-1.7B as a model you adapt cheaply to a narrow domain rather than a frontier model you use off the shelf for everything.
Is LFM3-1.7B worth using?
It depends entirely on the task. For general chat, coding assistance, or open-ended reasoning, a larger model will outperform it, and Liquid AI says as much directly. For narrow agentic applications, tool routing, structured extraction, or on-device assistants where memory and latency are tightly constrained, a sub-2B model that’s specifically post-trained for tool calling and ships in formats for phones, laptops, and Apple Silicon fills a real gap that general chat models in the same size class don’t address well.
Frequently Asked Questions
What is LFM3-1.7B used for?
It’s designed for local agents and tool-calling applications: deciding when to call a function, formatting the call correctly, and handling multi-turn agent conversations, typically after fine-tuning for a specific domain.
How many parameters does LFM3-1.7B have?
1.73 billion parameters, across 24 layers combining gated short convolutions, sliding-window attention, and global attention.
Can LFM3-1.7B run on a phone or laptop?
Yes. At 4-bit quantization it takes about 1 GB of memory, and Liquid AI ships GGUF, MLX, and ONNX formats specifically for on-device inference on CPUs, Apple Silicon, and cross-platform runtimes.
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
Is LFM3-1.7B good for coding or complex reasoning?
No. Liquid AI’s own documentation recommends against using it for agentic coding or complex multi-step reasoning, citing its small parameter count. It’s built for tool use and structured output, not general problem solving.
What context length does LFM3-1.7B support?
A 256K-token context window, covering both input and output combined.
