Liquid AI LFM2.5-24B-A2B: Hybrid Convolution and GQA Architecture for On-Device Reasoning

The evolution of frontier artificial intelligence models has bifurcated into two equally ambitious engineering fronts: while hyperscale giants construct gigawatt cloud superclusters to process trillion-parameter models, a quiet and technically revolutionary race is reconfiguring edge computing. For millions of developers, cybersecurity researchers, and corporations subjected to strict data privacy regulations, the compulsory dependency on centralized external APIs represents network latency bottlenecks, astronomical request costs, and permanent intellectual property leakage risks. With the official announcement of the LFM2.5-24B-A2B by Liquid AI, the local computing ecosystem reaches a historic milestone: enabling complex deliberative reasoning agents running 100% on-device on consumer hardware with fluid interactive speeds.

Conceived as the peak and final model of the influential LFM2.5 family, the LFM2.5-24B-A2B breaks away from the exclusive dogma of pure Transformers. The model adopts a 40-layer hybrid topology, combining 30 double-gated short convolution blocks and 10 Grouped-Query Attention (GQA) blocks. Operating under a Mixture of Experts (MoE) architecture with 64 experts per block and Top-4 dynamic routing, the system mobilizes only 2.45 billion active parameters per token out of a total of 24 billion parameters. This conformation allows the model to fit comfortably into just 15 GB of RAM (via Q4KM quantization using llama.cpp), decoding at an astounding 184 tokens per second on an Apple M5 Max chip and exceeding 21,000 tokens per second of throughput on a single private cloud NVIDIA B300 accelerator.

The release of the model's open weights under the LFM Open License v1.0 and on Hugging Face repositories redefines local software automation. Scoring 27.69% on the AutomationBench benchmark—tripling the score of competitors of its size—and 80.71% on ToolSandbox, the LFM2.5-24B-A2B establishes a new benchmark in tool invocation, demonstrating that private and sovereign agents no longer require the intermediation of remote data centers to deliver cognitive excellence.

Architectural Innovations: Convolutions Meet GQA

The formal launch of the LFM2.5-24B-A2B by Liquid AI's research team—led by MIT pioneers in liquid base models—represents the commercial maturation of a mathematical thesis developed over recent years: neural networks do not need to calculate dense quadratic attention matrices in every layer to retain causal relations in lengthy documents.

Standard attention-based models face an explosion in the memory footprint of the Key-Value Cache (KV Cache) as context extends, making their execution on personal computers unfeasible. Liquid AI's model distributes the processing load:

• 30 Convolutional Layers: Execute local temporal token mixing with linear complexity $O(N)$ and fixed memory consumption, synthesizing syntax and immediate context with extreme hardware speed.
• 10 Global GQA Layers: Strategically inserted along the network's backbone to perform long-range associative retrieval.
• Context Expansion: The native window was quadrupled compared to the preceding generation, jumping from 32,768 to 131,072 tokens, accompanied by a vocabulary expansion to 128,000 tokens, optimizing tokenization efficiency by up to 50% in non-Latin languages and source code.

Native Reasoning and Performance Benchmarks

Unlike conventional conversational models that generate immediate responses and frequently commit syntax errors in multi-step agentic tasks, the LFM2.5-24B-A2B was designed as a pure reasoning engine. Every interaction obligatorily opens a deliberative chain-of-thought block (<think>), allowing the model to plan tool calls, decompose objectives into subtasks, and test hypotheses internally before issuing the final command.

When evaluating the model against contemporaries like Qwen3.6-35B-A3B and Gemma-4-26B-A4B-it, its specialization profile becomes clear. To leverage these models seamlessly in enterprise workflows, developers can integrate them via n1n.ai for high-performance proxy routing and unified API management.

Python Orchestrator Implementation

Below is a complete and functional Python implementation of a local agent orchestrator for the LFM2.5-24B-A2B. The script communicates via a local endpoint compatible with vLLM/llama.cpp server (http://localhost:8080/v1), processes the deliberative reasoning block (<think>), executes tool calls in the OS, and calculates latency telemetry.

import asyncio
import json
import time
from typing import Dict, Any, List

class LocalLiquidAgentOrchestrator:
    def __init__(self, endpoint: str = "http://localhost:8080/v1") -> None:
        self.endpoint: str = endpoint
        self.model_name: str = "lfm2.5-24b-a2b"
        self.active_params_b: float = 2.45
        self.context_limit: int = 131072
        self.hardware_target: str = "Apple M5 Max / Llama.cpp Q4"

    def parse_reasoning_and_action(self, raw_output: str) -> Dict[str, str]:
        reasoning_block: str =