Playbooks · Coding tasks
Run Liquid AI's large 24-billion-parameter agent model on your own computer — if your memory fits it
Written October 30, 2026
For someone with a capable desktop or Mac who wants to run Liquid AI's large agent model — 24 billion parameters in total — on their own computer with Ollama. Settle the memory budget before the download starts: the 15 GB package and the memory it needs decide whether the model runs at all. A smaller machine cannot fit the full weights at a long context, however capable it feels.
Before you start
LFM2.5-24B-A2B is a text-only reasoning model from Liquid AI, built for agents that call tools. The model card lists 24.0 billion parameters in total, with 2.45 billion active per token: a mixture-of-experts design, 64 experts per block with the top 4 routed per token. The small active count is about compute, not memory. The full set of weights still has to fit in memory, and that is the number that decides whether the model runs on your machine.
The model card lists a context length of 131,072 tokens. Ollama starts a chat with a smaller window than that by default, so a long conversation can drop its earliest messages without warning. Inside ollama run, type /set parameter num_ctx 32768 to raise it for that chat, and check what is actually in use with ollama ps. If you plan long agent sessions, set the window and confirm it before trusting the model with a long task.
Two behaviours shape everything below, and both come from the model card. First, this is a reasoning-only model: it always thinks before it answers, adding a <think> block at the start of every assistant answer, and thinking cannot be switched off. Every reply therefore carries reasoning tokens before any answer or tool call. Second, its tool calls are Pythonic by default, and the program running the agent has to be ready for that shape.
What "done" looks like
At the end of this setup, ollama run lfm2.5:24b answers a prompt on your machine, and you know the memory budget it sits inside: a 24 GB graphics card, or a Mac with 32 GB of memory, for the 15 GB Ollama package.
Steps
- Settle the memory budget first. Sizing sources estimate that the Q4_K_M file, 14.53 GB on its own, needs about 17 GB in total at a 32K context once the conversation cache is included. That is why the working guidance is a 24 GB card, such as an RTX 3090 or 4090, or a 32 GB Mac. A 16 GB card does not fit the full Q4_K_M package at 32K context. If your machine is below that budget, use a smaller model from the same family, such as the 8B version, rather than forcing this one to fit.
- Install Ollama on the machine with the memory. Install it from Ollama's own download page, on the desktop or Mac that will hold the model, not on a small box that cannot hold 15 GB of weights plus a conversation cache.
- Pull and run the model. Run:
The first run downloads about 15 GB. Plan for that download: a slow connection makes this a long first step, and an interrupted download restarts work you could have scheduled. Once the download finishes, the same command drops you into a chat with the model.ollama run lfm2.5:24b - Try a short prompt before any agent work. Ask something small and read the whole reply, including the thinking block. This tells you the model answers at all on your machine, and it shows you how much of each reply is reasoning before the answer arrives. If the reply never arrives, the problem is memory or setup, and agent wiring will not fix it.
- Wire an agent program to the local model, not to a cloud key. The model card describes serving the model with an OpenAI-compatible backend and pointing an agent program at it. Whatever program you use, it has to handle the two behaviours from the model card. It must accept that every answer begins with thinking, and it must deal with Pythonic tool calls: by default the model writes a Python list between
<|tool_call_start|>and<|tool_call_end|>tokens. That program must parse that list, run the named function, and return the result with thetoolrole, after which the model gives a plain-text answer. The model card also allows the other route: asking in the system prompt for JSON function calls instead. Pick one route, and make sure the program implements it; a program that only understands JSON tool calls will not understand this model's default output. - Give the model its tools as JSON in the system prompt. The model card's tool-use sequence starts with the tool list supplied as a JSON object in the system prompt. A program that never tells the model what tools exist cannot expect useful tool calls from it, whatever backend serves the weights.
What the numbers mean, and what they do not
The 24B figure is the total parameter count. The 2.45B figure is how many parameters are active for each token. A machine still has to hold the weights, so the download size and the memory budget, not the active count, decide whether the model fits. Sizing sources estimate Q6_K at 19.69 GB as a file and 22.4 GB in total at 32K context, which puts it within 32 GB of system memory on a machine without a graphics card, on paper. No speed figure for a processor-only setup is published in the sources behind this page, so this page makes no claim about how fast that setup answers. Treat any speed number for it from elsewhere as unconfirmed until a source that measured it says so.
The model card also warns that this model is not recommended for knowledge-heavy tasks on its own, and pairs it with retrieval or web search. An agent that leans on the model alone for facts will get confident answers that no source backs. Give it tools that fetch, and treat its unsupported statements as drafts, not findings.
What can go wrong
- The model does not fit. A 16 GB card, or a machine with less memory than the budget above, cannot hold the full package at 32K context. The fix is a smaller quantization or a smaller model, not a setting that makes 15 GB of weights smaller.
- The download stalls. 15 GB is a long download on a slow connection. Start it when you can leave it alone, and do not start agent work that depends on it until the first chat reply works.
- The agent program ignores the tool calls. If the program expects JSON and the model writes Pythonic calls, the agent stalls or the calls pass through as plain text. Match the program to the model's default, or set JSON in the system prompt, and test one real tool call before building a workflow on it.
- Long chats lose their start. If your setup's context window is smaller than the model's 131,072-token limit, early messages drop out of long sessions. Keep agent sessions short, or confirm the window first.
- Thinking tokens crowd out the answer. Because thinking cannot be switched off, a task that needs a short answer still pays for reasoning first. Budget token limits and patience accordingly, and do not mistake a long thinking block for the model being stuck.
Limits
- This page covers the Ollama path only. The same weights exist as GGUF files for llama.cpp, as an MLX build for Apple Silicon, and in other serving formats, but those setups have their own commands and memory behaviour and are not covered here.
- Hardware figures here are the model card's file sizes and sizing sources' estimates at 32K context, not measurements from a machine owned by this site. Longer contexts need more conversation cache, so the budget grows with the session.
- Nothing here is a speed claim. No processor-only speed figure is published in the sources behind this page, and none is given.
Related playbooks
- Run Liquid's LFM3-1.7B privately on your own machine: what runs, on what, and what it is not for
- BotPsy 0.8B: an agent model that fits on-device
- Run Muse Spark in another harness via the Model API
- Run a reasoning task on a schedule with GitHub Agentic Workflows: one Markdown file, one reviewed pull request
Sources
Sources: LFM2.5-24B-A2B model card, LFM2.5-24B-A2B-GGUF files, RigCheck sizing estimates, RunCards Ollama notes.
Back to: Coding playbooks hub