LFM2.5-24B-A2B-DSpark-GGUF Text Generation Model: 4GB+ VRAM

At a Glance
| Item | Value |
|---|---|
| Repository | LiquidAI/LFM2.5-24B-A2B-DSpark-GGUF |
| Family guide | LFM2.5 guide (11 articles) |
| Publisher guide | Liquid AI: models and licenses |
| Published | 2026-10-21 |
| License | lfm1.0 |
| Formats | GGUF |
| Source type | Primary source (the publisher itself) |
Values determined by this site’s code when the information was collected. Dates are JST.
Overview
LiquidAI has released the GGUF version for llama.cpp of “LFM2.5-24B-A2B-DSpark", a model applying the “DSpark" inference acceleration technology. This model is a “draft model" used in combination with the target large-scale model “LFM2.5-24B-A2B", and aims to significantly improve inference speed through speculative decoding.
According to the release blog, DSpark works by having the target model pre-propose tokens for verification, thereby streamlining generation. The files provided in this repository function as a standalone “draft sidecar". It is a lightweight model consisting of 5 attention layers and a Markov head, and operates by sharing token embeddings and the LM head with the target model at runtime, meaning it must always be loaded paired with “LFM2.5-24B-A2B-GGUF".
Specifications
Specifications based on the documentation of the original model (LFM2.5-24B-A2B-DSpark) are as follows:
- Draft parameter count: 327.7M (BF16)
- Architecture: Lfm2DSparkDraftModel
- Backbone details: 5 full attention layers, hidden_size=2048, intermediate_size=6144 (SiLU/SwiGLU), GQA (num_attention_heads=32 / num_key_value_heads=8), head_dim=64
- Additional heads: Markov head (rank 256) + confidence head
- Block size: 9
- Vocabulary size: 128,000
Performance
Regarding the performance of this model, the authors report throughput improvement rates measured on an NVIDIA B300 using SGLang (FP8 precision). The following table shows how much the generation speed improved when applying DSpark (this draft model) compared to inference with the target model alone. Note that these are measured values on the original model, and may vary depending on the environment in quantized GGUF versions.
→ Scroll horizontally to see all columns
| Dataset | Tokens / step | Concurrency 1 | Concurrency 32 | Concurrency 256 |
|---|---|---|---|---|
| MATH-500 | 5.61 | 2.63× | 3.04× | 1.79× |
| GSM8K | 4.46 | 1.71× | 2.56× | 2.15× |
| HumanEval | 4.61 | 2.23× | 2.63× | 1.64× |
| MBPP | 6.70 | 3.08× | 3.28× | 1.64× |
| MT-Bench | 5.77 | 2.66× | 2.47× | 1.81× |
| SimpleQA | 5.22 | 2.48× | 2.91× | 1.95× |
| LiveCodeBench | 4.02 | 1.87× | 2.20× | 1.34× |
| AIME | 4.90 | 2.35× | 2.45× | 1.36× |
| Arithmetic mean | 5.16 | 2.38× | 2.69× | 1.71× |
From this table, it can be seen that the introduction of DSpark significantly improves throughput across all evaluation items. In particular, MBPP, which measures the ability to solve Python coding problems, achieves a remarkable speedup of 3.28x at a concurrency of 32. In addition, MATH-500, which handles high school to competition-level math problems, achieves a 3.04x speedup at a concurrency of 32.
On the other hand, for GSM8K, which handles elementary school-level math word problems, and LiveCodeBench, which handles new competitive programming problems, the speedup rate at concurrency 1 is below 2x, indicating that the degree of acceleration varies depending on the nature of the task. The arithmetic mean reports a 2.38x speedup at concurrency 1 and a 2.69x speedup at concurrency 32, expecting more than a 2x speed increase in many general use cases.
Due to the characteristics of speculative sampling, the authors note that floating-point calculation errors occur between batch verification and normal decoding, meaning the output text may differ (even with Greedy sampling) from when using the target model alone. For this reason, they state that this benchmark evaluates the improvement in inference performance rather than task accuracy. Furthermore, actual acceleration performance with the GGUF version depends on the hardware used and the quantization bit-width of the target model.
Strengths and Use Cases
The main purpose of this model is to dramatically accelerate the inference process of the 24B parameter large-scale model “LFM2.5-24B-A2B". Designed as a dedicated draft model for speculative decoding, it enables a process where a lightweight “sidecar" model takes over some of the heavy calculations that the main model would otherwise perform to create token “drafts", which are then verified by the main model. Through this mechanism, only the generation speed can be improved without compromising the intelligence of the main model.
Due to these characteristics, it demonstrates its true value in chatbots and conversational AI where real-time responsiveness is strongly required, and in long-form text generation. As indicated by the tag information, it is possible to optimize computing resources and gain throughput while leveraging the characteristics of the LFM2 series, which features a MoE (Mixture of Experts) structure. Particularly when operating a 24B class model on a local server or high-performance workstation, token generation speed can become a bottleneck in single-model inference, but using this model together can significantly reduce that stress.
Specifically, fast feedback is also anticipated in tasks requiring step-by-step reasoning, such as coding assistance and mathematical reasoning. This model features a special design that shares token embeddings and the output layer (LM head) with the target model, making it suitable for operation in resource-constrained local environments as it operates efficiently while suppressing memory consumption.
Hardware Requirements
Estimated requirements (calculated by Local Model Watch) — 328M parameters (taken from the base model LiquidAI/LFM2.5-24B-A2B-DSpark)
| Your VRAM | Quantization | File size | Est. memory needed |
|---|---|---|---|
| 4GB (laptop iGPU / phone class) | F16 | 0.6GB | 0.7GB |
Memory estimates add a 20% runtime overhead (KV cache, etc.) to the actual size of the distributed files. Actual usage varies with context length, batch size and inference engine. These figures are computed by this site from file sizes, not published by the model’s authors. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.
Can You Run It Locally?
Runs in Ollama, LM Studio and llama.cpp as-is.
It is distributed in GGUF, so no conversion is needed.
License — lfm1.0 (Commercial use allowed with conditions): LiquidAI’s LFM Open License v1.0. Commercial use is allowed, except by legal entities with annual revenue of $10 million or more (Section 5). Redistribution requires the license text and notice of changes.
Compiled by this site’s code from the published formats, converted builds we have found, and each engine’s own model registry. “Not found" means we have not seen such a build, not that none exists. License summaries are not legal advice — check the publisher’s original terms before relying on them.
Recent Models in the Same Size Class
Models with up to 4B parameters that Local Model Watch covered recently, listed by code from our article log for comparison. VRAM tiers are this site’s estimates; licenses are as stated on the model cards.
→ Scroll horizontally to see all columns
| Model | Parameters | Smallest VRAM tier | License | Our article |
|---|---|---|---|---|
| openbmb/MiniCPM-V-4.7-35B-A3B-DSpark-gguf | 389M | 4GB | apache-2.0 | MiniCPM-V-4.7-35B-A3B-DSpark-gguf Draft Model for Speedup: 4GB+ VRAM (2026-11-17) |
| openbmb/MiniCPM-V-4.7-1B-DSpark-gguf | 214M | 4GB | apache-2.0 | MiniCPM-V-4.7-1B-DSpark-gguf Text Generation Model: 4GB+ VRAM (2026-11-17) |
| IFM/Jais-3-0.9B-GGUF | 1.1B | 4GB | apache-2.0 | Jais-3-0.9B-GGUF Bilingual Dense Model: 4GB+ VRAM (2026-11-17) |
| nvidia/NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16 | 4.0B | 4GB | openmdw-1.1 | NVIDIA Releases Dory1.0-4B: A Recurrent 4B LLM with Dynamic Loops (2026-11-17) |
| inclusionAI/Ling-3.0-tiny-UBTree | 183M | 4GB | mit | Ling-3.0-tiny-UBTree Draft Model for Speculative Decoding: 4GB+ VRAM (2026-11-17) |
How to Get It
This model is released in GGUF format and can be obtained from the Hugging Face repository “LiquidAI/LFM2.5-24B-A2B-DSpark-GGUF". At this time, LFM2.5-24B-A2B-DSpark-F16.gguf (F16 precision) has been confirmed among the distributed files.
Using the model requires a recent build of llama.cpp. This model does not operate on its own and must be used as a set with the target “LFM2.5-24B-A2B-GGUF". The quantization bit-width on the target model side (such as Q4_K_M or Q8_0) can be selected arbitrarily, but generation speed, quality, and the token acceptance rate by the draft model will fluctuate based on that selection.
An example command for operating it using the server feature of llama.cpp is as follows:
llama-server -hf LiquidAI/LFM2.5-24B-A2B-GGUF:F16 \
-hfd LiquidAI/LFM2.5-24B-A2B-DSpark-GGUF:F16 \
--spec-type draft-dspark --spec-draft-n-max 9 --spec-draft-n-min 0 \
-ngl 99 -ngld 99 -fa on
In this configuration, specifying --spec-type draft-dspark enables the DSpark algorithm, and --spec-draft-n-max 9 allows speculative proposals of up to 9 tokens. In addition, the -ngl and -ngld options offload the layers of both the target and draft models to the GPU for acceleration.
In addition to this model (for 24B), the LFM2.5-DSpark family offers draft models tailored for models of different sizes, such as “LFM2.5-1.2B-Instruct-DSpark-GGUF" and “LFM2.5-8B-A1B-DSpark-GGUF". Please pair and use them with the appropriate target model according to your own hardware and use case.
The “lfm1.0" license applies. Since the gating on Hugging Face (settings requiring agreement to terms of use) is not enabled, you can download directly from the repository and start trial usage.
Related Articles
- LFM2.5-24B-A2B-DSpark Speculative Decoding Draft Model: 4GB+ VRAM
- LFM2.5-24B-A2B-MLX-6bit Text Generation Model: 24GB+ VRAM
- LFM2.5-24B-A2B Agent-Optimized MoE Reasoning Model: 12GB+ VRAM
- LFM2.5-24B-A2B-MLX-8bit Text Generation Model: 32GB+ VRAM
What to Read Next
- Find models by VRAM (This model runs from the 4GB tier) → Other models that run on a 8GB GPU
- Explore the same model family → LFM2.5 family overview (11 articles, 17 converted builds)
- Engines that run this model → llama.cpp / Ollama
- Formats this model is available in → GGUF format guide and models
- Learn about the publisher → Liquid AI: models, licenses and articles

