Liquid AI d1-2B

Benchmark data sourced from: Hugging Face, Arena.ai, Artificial Analysis.

• 13 gated short convolution layers for rapid local token mixing with low memory footprint
• 5 sliding-window attention layers to capture local contextual dependencies
• 6 global attention layers to retain long-range coherence across the input state

This hybrid design allows the model to process long inputs with significantly lower compute complexity than quadratic full-attention architectures. The parameter count sits at exactly 1.92B (1,918,181,888 parameters), striking a balance between edge deployability and semantic depth.

The model supports a maximum context length of 128,000 tokens with a 128,000-token vocabulary. In practical deployment, Liquid AI notes that reasoning reliability remains highest up to roughly 64,000 tokens of state context. Because the architecture reads its answers out of the latent representation during a single forward pass, the inference phase requires no key-value (KV) cache generation loop. You query a state with any number of named questions simultaneously, and the model resolves all answers within the same forward execution.

d1-2B serves as a deterministic processing block across multimodal inputs (text, JSON states, static images, and video frames). Instead of producing free-form string tokens, its output heads are trained to emit structured data structures with associated confidence scores.

• Binary and Choice Probabilities: Direct evaluation of boolean questions (yes/no) and single- or multi-label classifications with calibrated probability distributions.
• Span Extraction: Pinpointing character offsets for entities, dates, numbers, and key textual fragments directly from source documents without rewriting the text.
• Visual Grounding: Producing bounding box coordinates for objects detected across images or video sequences.
• Bounded Estimation: Providing numerical and interval estimates for counts and ordinal scores.

• Agentic Routing and Triage: Classifying user intents and routing execution paths to specialized models or API tools instantly.
• Safety and Guardrails: Running input/output moderation, checking for prompt injections, policy violations, or sensitive data leaks in single-digit milliseconds.
• Document Processing: Extracting fields from invoices, receipts, and complex forms across multimodal layouts where both spatial visual cues and text matter.
• Multilingual Support: Native coverage across 16 languages, including English, Arabic, Chinese, French, German, Italian, Japanese, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Russian, and Polish.

Running a local AI model with 1.92B parameters in 2026 is accessible across virtually all modern hardware tiers, but d1-2B's zero-generation design introduces unique performance dynamics.

Because d1-2B runs a single forward pass without maintaining an expanding autoregressive KV cache during output generation, memory requirements remain static based on the input size:

• BF16 / FP16 (Unquantized): ~4.2 GB VRAM. Recommended for maximum calibration accuracy on spans and bounding boxes.
• Q8_0 (8-bit Quantization): ~2.3 GB VRAM. Near-lossless decision metrics with almost half the memory footprint.
• Q4_K_M (4-bit Quantization): ~1.4 GB to 1.8 GB VRAM. The best quantization for Liquid AI d1-2B when deploying to resource-constrained edge nodes, micro-instances, or mobile hardware.

To run Liquid AI d1-2B locally, almost any modern consumer GPU is sufficient:

• NVIDIA Desktop GPUs: An entry-level RTX 3060 (12GB) or RTX 4060 (8GB) can easily host d1-2B in full precision while leaving the majority of VRAM available for a larger generative model in the same pipeline. For enterprise throughput, data center cards like the RTX 4090 or A5000 allow massive batching of concurrent decisions.
• Apple Silicon: Macs equipped with M2, M3, or M4 chips (even base models with 8GB or 16GB unified memory) run d1-2B effortlessly. On an M4 Max, execution completes almost instantaneously.
• CPU Deployment: Thanks to the 1.92B parameter count and gated short convolutions, modern x86 and ARM CPUs with AVX-512 or NEON support can achieve practical decision latencies under 50 ms.

Developers frequently search for Liquid AI d1-2B tokens per second, but that metric does not apply here. Because the model outputs structured decisions in one forward pass rather than generating output tokens sequentially, performance is measured in latency per decision:

• Enterprise Accelerators (NVIDIA H100 / AMD MI325X): 3.8 ms to 5.7 ms per decision state.
• Consumer GPUs (RTX 4090 / 4080): Typically under 12 ms for text-only states, scaling slightly higher when parsing high-resolution vision tokens.

Deployment requires Python environments with transformers>=5.19, torch, torchvision, and pillow, using trust_remote_code=True to load the custom LFM3 architectural layers. For containerized local environments, GGUF conversions compatible with local model runners allow integration into embedded edge systems.

Evaluating Liquid AI d1-2B vs Qwen2.5-1.5B or SmolLM2-1.7B requires understanding the difference between generative models and decision models.

If your application demands conversational interaction, creative synthesis, code generation, or textual explanation, d1-2B is the wrong tool. Choose Qwen2.5 or SmolLM2 instead.

If your task involves evaluating input states, filtering prompts, routing between agents, locating objects in pictures, or extracting dates and numbers into database records, d1-2B is objectively superior. Generative models waste hundreds of milliseconds outputting tokens, burn unnecessary memory bandwidth, and occasionally produce invalid schemas. d1-2B executes the decision natively, deterministically, and in a fraction of the time.