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

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

What to Read Next

Sources