Up to 3.2x Faster Inference with LFM2.5-DSpark

Liquid AI has officially unveiled the DSpark draft model checkpoints for its LFM2.5 model family, marking a significant leap forward in inference efficiency. By introducing a specialized speculative decoding path, these new checkpoints enable substantial speed improvements without compromising the output quality of the original models. This release covers three key models: LFM2.5-1.2B-Instruct, LFM2.5-2.6B, and LFM2.5-8B-A1B.

The core value proposition of this update is a dramatic reduction in latency. Users can now experience up to a 3.18x throughput improvement on GPU-accelerated environments and up to 2.87x faster performance on local, on-device hardware. Furthermore, for developers focused on agentic workflows, the update cuts function-calling latency by an average of 57% for the LFM2.5-2.6B model. To ensure immediate usability, Liquid AI has provided day-one support for both llama.cpp and SGLang.

Understanding the DSpark Mechanism

In the landscape of Large Language Model (LLM) inference, the "decode phase" is notoriously memory-bound. The primary bottleneck is not the computational intensity of the model itself, but rather the physical limitation of streaming weights from DRAM into SRAM.

Speculative decoding circumvents this by employing a lightweight "draft" model to generate a sequence of candidate tokens. These candidates are then validated by the target model in a single forward pass. This approach effectively amortizes the cost of loading the target model's weights across multiple tokens, significantly increasing the number of tokens generated per second.

DSpark refines this process by integrating three sophisticated components:

• Parallel Backbone: Utilizing a DFlash-style architecture, the system is conditioned on the context features of the target model, allowing it to produce hidden states for all draft tokens simultaneously.
• Markovian Sequential Head: A lightweight head that models dependencies between neighboring tokens, which boosts the acceptance rate of tokens at later positions in the sequence.
• Confidence-Scheduled Verifier: A smart mechanism that evaluates the survival probability of each token, pruning low-confidence suffixes to ensure that verification efforts are only spent where they provide a net performance gain.

Architecture and Training Methodology

Liquid AI’s approach to training these draft models involved a diverse data mix, encompassing Supervised Fine-Tuning (SFT), conversational chat, complex code generation, and function-calling datasets. The resulting draft models are remarkably compact, weighing in at approximately 300 million parameters each.

The architecture consists of a 5-layer attention-only stack, a hidden-state projection layer, and the specialized Markov head. During the training phase, the team ran 15 epochs across the entire dataset, prioritizing the epoch that yielded the highest token acceptance rate rather than simply chasing the lowest loss. This strategic choice ensures that the models are optimized specifically for the speculative decoding task.

"The emitted sequence is identical to baseline greedy decoding by construction, meaning that benchmark accuracy—whether measured by pass@1 or exact match—remains completely unchanged."

Performance Metrics: From H100s to MacBooks

The performance gains provided by DSpark are consistent across both high-end data center hardware and edge devices. Liquid AI tested these models using SGLang on an H100 80GB GPU and llama.cpp on an M4 Max MacBook Pro.

LFM2.5-2.6B Performance Highlights

For the 2.6B model, the speedup on the MacBook is particularly impressive, pushing interactivity levels to roughly 140 tokens per second, which far exceeds the throughput typically offered by proprietary cloud-based models.

| Dataset | Acceptance (of 10) | Speedup (H100) | Speedup (M4 Max) | | :--- | :--- | :--- | :--- | | MATH500 | 5.42 | 3.06x | 2.25x | | HumanEval | 4.54 | 2.56x | 2.63x | | MT-Bench | 5.07 | 2.87x | 1.99x | | Mean | 4.81 | 2.67x | 2.27x |

LFM2.5-8B-A1B and Hardware Constraints

While the 8B model shows a high acceptance rate, the on-device speedup is more modest (averaging 18%). This is attributed to the current implementation of Mixture-of-Experts (MoE) in the llama.cpp Metal backend, where verifying multiple tokens triggers higher weight traffic than a standard decode step. Despite this, the H100 performance remains stellar, with a mean speedup of 2.54x.

Implementation and Getting Started

Liquid AI has ensured that integrating DSpark is straightforward for developers. For those using SGLang, the process involves launching the server with the --speculative-algorithm DSPARK flag and pointing to the corresponding draft model path.

For llama.cpp users, the integration is handled via the llama-server command, utilizing the --spec-type draft-dspark flag. Because speculative decoding is an exact process, the target model verifies every token, ensuring that the final output remains identical to a standard, non-speculative execution.

Availability

The DSpark draft model checkpoints are currently available on Hugging Face in both Safetensors and GGUF formats. This release empowers developers to build faster, more responsive AI applications that can run efficiently on everything from massive GPU clusters to personal laptops.

• Safetensors: Available for LFM2.5-2.6B, 1.2B-Instruct, and 8B-A1B.
• GGUF: Optimized versions for local deployment are also ready for immediate download.

As the industry continues to push for lower latency in agentic and conversational AI, tools like DSpark represent a critical step in making high-performance inference accessible and efficient across the entire computing stack.

*

Citation: Liquid AI, "LFM2.5-DSpark: Up to 3.2x Faster Inference from H100 to MacBook", Liquid AI Blog, Aug 2026.

@article{liquidAI2026dspark,
  author = {Liquid AI},
  title = {LFM2.5-DSpark: Up to 3.2x Faster Inference from H100 to MacBook},
  journal = {Liquid AI Blog},
  year = {2026},
  note = {www.liquid.ai/blog/lfm2.5-dspark}
}