LFM2.5-24B-A2B-DSpark Speculative Decoding Draft Model: 4GB+ VRAM

LFM2.5-24B-A2B-DSpark Speculative Decoding Draft Model: 4GB+ VRAM

At a Glance

Item Value
Repository LiquidAI/LFM2.5-24B-A2B-DSpark
Family guide LFM2.5 guide (11 articles)
Publisher guide Liquid AI: models and licenses
Published 2026-10-20
License lfm1.0
Formats safetensors
Source type Primary source (the publisher itself)

Values determined by this site’s code when the information was collected. Dates are JST.

Overview

Liquid AI has released “LFM2.5-24B-A2B-DSpark", a draft model for speculative decoding. This model is designed to accelerate the generation speed of the target model, “LiquidAI/LFM2.5-24B-A2B", improving inference efficiency by having the target model verify the tokens proposed by the draft side. Measurements using SGLang on an NVIDIA B300 show an average 2.4x (up to 3.1x) improvement in output throughput at concurrency 1, and 1.7x at concurrency 256, compared to the target alone.

Specifications

  • Parameters: Draft parameters 327.7M (BF16)
  • Architecture: 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

Since this model is a draft model for speculative decoding and generated text may differ due to floating-point arithmetic variations during verification, the measurement results below evaluate inference speed (throughput) rather than task accuracy.

Listed in the model card, a comparison of output throughput using DSpark versus the target model (FP8 version) alone across various datasets is as follows:

→ 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×

According to measurements by the publishers, throughput improvements of 2.38x at concurrency 1, 2.69x at concurrency 32, and 1.71x at concurrency 256 are confirmed as the arithmetic mean across all evaluation datasets. In particular, MBPP (accuracy in solving introductory to intermediate Python problems) shows the highest acceleration rate with 3.28x at concurrency 32 and 3.08x at concurrency 1. On the other hand, differences in acceleration rates are observed depending on the nature of the task, such as LiveCodeBench (evaluated on new competitive programming problems categorized by release period) remaining at 1.34x at concurrency 256. In addition, consistent speedups of about 1.6x to 2.6x are achieved on GSM8K, which solves elementary school-level math problems, and HumanEval, which measures the accuracy of implementing Python functions according to specifications.

Furthermore, regarding the task accuracy of the base target model (LFM2.5-24B-A2B itself), it is reported as follows in the benchmark comparison table published by the original creators:

→ Scroll horizontally to see all columns

Benchmark LFM2.5-24B-A2B Qwen3.6-35B-A3B Gemma-4-26B-A4B-it Nemotron-3.5-Lightning (30B-A3B)
AutomationBench 27.69 8.72 5.46 2.61
BFCLv4 65.01 65.00 57.09 53.78
ToolSandbox 80.71 75.02 72.09 75.13
LiveClaw 48.09 38.19 41.25 37.72
PinchBench 83.18 89.93 77.12 84.20
τ³-Bench Banking 8.04 7.63 4.54 7.01
WebArena Verified 26.75 37.62 25.62 28.69
GPQA Diamond 74.42 83.69 74.90 72.42
AA-Omniscience -24.90 -24.35 -59.39 -3.58
HLE 7.40 7.69 8.57 5.65
IFEval 96.75 93.06 92.00 94.19
IFBench 74.69 64.21 47.44 71.67
Multi-IF 84.38 81.53 82.19 82.34
MATH-500 96.04 96.73 95.66 96.40
SWE-Bench Verified (OpenCode) 51.00 66.20 25.80 53.40
SciCode 32.71 37.35 35.42 27.78

In the measurement results of the original model, LFM2.5-24B-A2B showed the highest accuracy among the compared models in IFEval (96.75), which measures the accuracy of following formal instructions, and also recorded high scores in tasks such as AutomationBench (27.69) and LiveClaw (48.09). On the other hand, it falls behind other models such as Qwen3.6-35B-A3B (GPQA Diamond: 83.69, SWE-Bench: 66.20) in GPQA Diamond (74.42), which handles PhD-level difficult questions, and SWE-Bench Verified (51.00), which looks at the ability to fix issues in real repositories. It scores 96.04 in MATH-500, which measures high school to competitive-level mathematical ability, placing it at a level that competes with top-tier models.

Strengths and Use Cases

LFM2.5-24B-A2B-DSpark is designed to dramatically accelerate inference for its target model, “LFM2.5-24B-A2B". Therefore, the strengths and expected use cases of this model inherit the characteristics of the original model, LFM2.5-24B-A2B, as they are.

The original model LFM2.5-24B-A2B is a 24B parameter reasoning model developed with the primary objective of building fast and private on-device agents. Its defining feature is that it is a “pure reasoning model" that always incorporates a “thinking" process before generating a response. In the chat template, a <think> tag is automatically inserted at the beginning of the assistant’s response, leading to final answers through logical steps despite having a small active parameter count of 2B per token.

Specific strengths include the following:

Agent Tasks and Tool Use

This model is tuned specifically for agent workflows involving function calling. It supports tool execution instructions in JSON and Python formats, equipped with the capability to reliably perform four steps: definition, invocation, execution, and final answer. In the publisher’s evaluations, it records competitive scores in agent-style tasks such as LiveClaw, even when compared to models with larger total or active parameter counts like Qwen3.6-35B-A3B. Because it has learned the system prompts and dialogue patterns of major agent frameworks such as OpenClaw and Hermes Agent, its compatibility with these tools is extremely high.

Long-Context Reading and Multilingual Support

It features an extremely long context length of 131,072 tokens, enabling the reading of large documents and long-duration conversations. It also supports 16 languages including Japanese (English, Arabic, Chinese, French, German, Italian, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Russian, Polish). Specifically, tokenizer expansions have been implemented to improve tokenization efficiency for non-Latin characters, making it suitable for multilingual environments.

Maximizing Inference Efficiency

It adopts a Mixture-of-Experts (MoE) architecture with a structure that activates 4 out of 64 experts for each token (Top-4 routing). This achieves fast on-device decoding while maintaining high inference capability. Using the DSpark draft model in combination allows for further enhancement of this inference efficiency.

Note that the model card does not recommend having the model solve “knowledge-intensive tasks" on its own. Utilizing the model’s strength in tool-calling capabilities, a configuration that retrieves necessary information externally by combining it with a search engine or external database (RAG) is most strongly recommended.

Hardware Requirements

Estimated requirements (calculated by Local Model Watch) — 328M parameters

Your VRAM Quantization File size Est. memory needed
4GB (laptop iGPU / phone class) F16 0.6GB 0.7GB

Inference engine support (architecture name matched against each project’s own model registry in its source code, checked 2026-11-17): llama.cpp: registered, vLLM: not registered, MLX (mlx-lm): registered. “Not registered" means the name is absent from that registry today, not that the model cannot run.

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. File sizes are measured from the converted build LiquidAI/LFM2.5-24B-A2B-DSpark-GGUF. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.

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 distributed in safetensors format on Hugging Face. There are no gating restrictions (agreement to terms of service) required for use, and anyone can download it.

As an inference engine, the latest SGLang supporting LFM2-MoE DSpark is required. Specifically, please use builds that incorporate PR #31041 (LFM2-MoE DSpark support) and PR #43939 (native Hugging Face config support) on GitHub.

Below is an example command for launching a server using SGLang to apply this draft model to the target model (using the FP8 quantized version as an example here):

python -m sglang.launch_server \
  --model-path LiquidAI/LFM2.5-24B-A2B-FP8 \
  --speculative-algorithm DSPARK \
  --speculative-draft-model-path LiquidAI/LFM2.5-24B-A2B-DSpark \
  --speculative-draft-attention-backend flashinfer \
  --speculative-dspark-block-size 9 \
  --speculative-num-draft-tokens 10 \
  --mem-fraction-static 0.8 --port 30000

After launching the server, you can access it as an OpenAI-compatible API endpoint at http://localhost:30000/v1. Significant throughput improvements can be expected compared to when speculative decoding is not used.

Quantized and Converted Variants

→ Scroll horizontally to see all columns

Added Publisher Format Repository Smallest VRAM tier (build, est. memory)
2026-11-17 LiquidAI GGUF LiquidAI/LFM2.5-24B-A2B-DSpark-GGUF F16 0.7GB (fits in 4GB VRAM)

File sizes of each build:

  • Available builds in LiquidAI/LFM2.5-24B-A2B-DSpark-GGUF: F16 0.6GB

This section is appended automatically by Local Model Watch when a converted build of this model appears after publication. Memory figures are estimated from the size of the distributed files. What the quantization names mean: glossary.

Related Articles

What to Read Next

Sources

Update History

  • 2026-11-17: Added converted builds to “Quantized and Converted Variants”: LiquidAI/LFM2.5-24B-A2B-DSpark-GGUF
  • 2026-11-17: Updated the hardware requirements table with the actual file sizes of LiquidAI/LFM2.5-24B-A2B-DSpark-GGUF.
  • 2026-11-17: Changed the title to show what the article covers (VRAM requirements, file list, etc.).