Skip to page content
SAVRN
Search Plan a project

Open-weight model · Text generation

LFM2.5-24B-A2B-JANGH2

by Osaurus-AI OsaurusAI/LFM2.5-24B-A2B-JANGH2

LFM2.5-24B-A2B-JANGH2 is an open-weight model for text generation from Osaurus-AI, released under Apache License 2.0. It has 2.7B parameters and a 131,072-token context. At 16-bit it needs about 6.5 GB of GPU memory, which fits on 1x MI300X from $1.85 an hour, at the lowest prices in the SAVRN Index.

A JANG bundle of LiquidAI/LFM2.5-24B-A2B: Liquid AI's 24B mixture-of-experts reasoning model with 2B active parameters (40 layers: 30 short-convolution and 10 full-attention, 64 routed experts with 4 active, two dense layers), built for on-device agents.

Parameters2.7B
Context131,072
Weights7.8 GB
Licenseapache-2.0
AccessOpen weights
Monthly Downloads—

Runs On

What it takes to serve LFM2.5-24B-A2B-JANGH2 (2.7B parameters): the memory its weights need at each precision, and the cheapest way to rent enough data-center GPUs to hold them.

PrecisionWeightsMemory neededCheapest setupPer hourAlso fits
16-bit 5.4 GB 6.5 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
8-bit 2.7 GB 3.2 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
4-bit 1.4 GB 1.6 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00

Memory is the weights at that precision plus 20% for the runtime and a short context; a long context needs more. Prices are the lowest on-demand hourly rates in the SAVRN Index, read Oct 19, 2026.

LFM2.5-24B-A2B-JANGH2 on every accelerator the SAVRN Index prices, at every precision

Model Card

By Osaurus-AI, published under apache-2.0, revision 2739b413f493.

A JANG bundle of LiquidAI/LFM2.5-24B-A2B: Liquid AI's 24B mixture-of-experts reasoning model with 2B active parameters (40 layers: 30 short-convolution and 10 full-attention, 64 routed experts with 4 active, two dense layers), built for on-device agents. It always thinks before answering and calls tools in Liquid's Pythonic format. 44.7 GiB of bf16 weights in 7.3 GiB. Every quantized matrix with an input Hessian was rounded with GPTQ. The Hessians come from the model's own outputs: the bf16 model wrote its thinking and answers for math, finance, code in eleven languages, terminal and coding-agent sessions (with real tool results), multi-step tool calls, networking, cybersecurity, science…

Read Osaurus-AI's full model card

Runtime: Osaurus 0.25.21 or newer (osaurus.json: required_osaurus_version).

This bundle uses the JANGH expert format (jangtq2 banks); it needs a runtime with the JANGH MoE kernels.

OsaurusAI/LFM2.5-24B-A2B-JANGH2

A JANG bundle of LiquidAI/LFM2.5-24B-A2B: Liquid AI's 24B mixture-of-experts reasoning model with 2B active parameters (40 layers: 30 short-convolution and 10 full-attention, 64 routed experts with 4 active, two dense layers), built for on-device agents. It always thinks before answering and calls tools in Liquid's Pythonic format. 44.7 GiB of bf16 weights in 7.3 GiB.

What is quantized how

part format
routed experts gate / up JANGH 2-bit: Hadamard-32 rotation + odd-cubic codebook, fp16 per-row scale, act-order GPTQ per expert
routed experts down JANGH 3-bit, same scheme
dense MLP (layers 0-1), attention q/k/v/out, short-conv in/out projections affine 8-bit, GPTQ
embeddings (tied lm_head) affine 8-bit
routers, expert bias, depthwise conv kernels, norms source values

Every quantized matrix with an input Hessian was rounded with GPTQ. The Hessians come from the model's own outputs: the bf16 model wrote its thinking and answers for math, finance, code in eleven languages, terminal and coding-agent sessions (with real tool results), multi-step tool calls, networking, cybersecurity, science, office tasks, long documents and multilingual chat at its native sampling settings, and those sequences were the calibration data. Per-expert Hessians use only the tokens routed to that expert. Affine quantization is MLX's own grid (bf16 scales and biases).

Fidelity vs the bf16 model

232,094 teacher-forced positions on held-out sequences the bf16 model generated itself (never seen in calibration), scored against the bf16 model: top-128 KL, top-1 agreement, and the change in log-likelihood of the real next token (dNLL).

This model routes chaotically: changing the bf16 embeddings by a single bf16 ULP already moves top-1 on 1.8% of positions. That run is the floor row below; read the quantized rows against it.

size KL median KL mean top-1 dNLL
bf16 model, embeddings perturbed by 1 ULP (the floor) 44.7 GiB 1.1e-04 0.0036 98.24% -0.0000
JANGH2 7.3 GiB 5.5e-03 0.1136 89.93% +0.0989

By prompt family (KL median, top-1):

family KL median top-1
multi-step tool agent 0.0195 86.3%
tool use (single turn) 0.0212 88.9%
code: cpp 0.0015 91.1%
code: go 0.0000 94.6%
code: javascript 0.0014 91.0%
code: python 0.0002 93.5%
code: rust 0.0081 89.3%
code: shell 0.0111 89.0%
code: swift 0.0072 89.8%
code: typescript 0.0029 90.8%
creative writing 0.0289 85.8%
cybersecurity 0.0525 83.4%
finance 0.0068 90.1%
general / multilingual / structured output 0.0127 87.9%
coding agent (native tools) 0.0017 93.7%
coding agent, next turn 0.0059 93.5%
long documents 0.0150 87.6%
math 0.0010 92.6%
networking 0.0014 91.9%
office tasks 0.0043 91.8%
PyTorch code 0.0033 90.4%
science 0.0034 90.9%
SWE-agent 0.0313 84.7%
terminal agent (shell) 0.0038 90.5%
turn after a tool result 0.0279 87.7%

Decisions: the quantized model picks the same token as bf16 at 98 / 99 </think> closes (floor run: 99 / 99) and at 22 / 24 tool-call starts (floor run: 24 / 24).

Model notes

  • Text only. 131,072-token context.
  • Reasoning: always on. The chat template opens <think> for every answer; there is no off switch and no effort levels. preserve_thinking keeps earlier turns' thinking in the context.
  • Tools: tool definitions go into the system prompt; calls come back as <|tool_call_start|>[name(arg='value')]<|tool_call_end|> (a Python-literal list, parsed as data). Tool results use the tool role.
  • Sampling (generation_config.json, mirrored in jang_config.json): temperature 0.1, top-k 50, repetition penalty 1.05, EOS <|im_end|>.
  • Router: sigmoid scores with the expert bias used only to pick the top-4; the expert weights are the unbiased scores. The bundle's jang_config.json documents this; a softmax router produces wrong output on this model.
  • No draft model exists for the 24B, so there is no speculative decoder in this bundle.

Source

  • LiquidAI/LFM2.5-24B-A2B revision 1769516ac588, Apache-2.0.
  • Quantization and bundle by Jinho Jang ([email protected]), 2026-10-13.

Configuration

Architecture
Lfm2MoeForCausalLM
Context length (tokens)
131,072
Layers
40
Hidden size
2,048
Feed-forward size
11,776
Attention heads
32
Key/value heads
8
Vocabulary size
128,000
Experts
64
Experts active per token
4
Model type
lfm2_moe

Identity and Version

Repository
OsaurusAI/LFM2.5-24B-A2B-JANGH2
Publisher
Osaurus-AI
Task
Text generation
Modality
Text
Library
mlx
Parameters
2.7B parameters
Languages
en, de, fr, es, ja, ko, zh, ar
Revision
2739b413f493c5876e0d1f3b878b40596c225fff
First published
2026-10-14
Last updated
2026-10-14

Files and Weights

14 files, 7.8 GB in total. The weights are 2 files totalling 7.8 GB in safetensors.

Weights2 files · 7.8 GB
Configuration5 files · 137.0 KB
Tokenizer2 files · 17.9 MB
Documentation2 files · 15.7 KB
Other2 files · 31.8 KB
Repository1 file · 1.6 KB
Every file
FileTypeSizeSHA-256
model-00001-of-00002.safetensorsWeights4.3 GB 6391d5e7b7d0
model-00002-of-00002.safetensorsWeights3.5 GB 024282122338
config.jsonConfiguration58.3 KB —
generation_config.jsonConfiguration329 B —
jang_config.jsonConfiguration13.6 KB —
model.safetensors.index.jsonConfiguration64.8 KB —
osaurus.jsonConfiguration67 B —
LICENSEDocumentation10.6 KB —
README.mdDocumentation5.1 KB —
chat_template.jinjaOther5.4 KB —
osaurus-x-banner.pngOther26.3 KB —
.gitattributesRepository1.6 KB —
tokenizer.jsonTokenizer17.9 MB 695be7802a0e
tokenizer_config.jsonTokenizer363 B —

License and Download

License
apache-2.0
Access
Open weights, no gate
Download size
7.8 GB
Download from Osaurus-AI

Released by Osaurus-AI through its official repository on Hugging Face. Read the license.

Built From

  • Derived from LiquidAI/LFM2.5-24B-A2B
  • Quantized from LiquidAI/LFM2.5-24B-A2B

Memory Requirements

PrecisionWeights in memory
As published7.8 GB
16-bit5.4 GB
8-bit2.7 GB
4-bit1.4 GB

Weights only, from the published parameter count; the key-value cache and runtime add to this.

Questions About LFM2.5-24B-A2B-JANGH2

How much GPU memory does LFM2.5-24B-A2B-JANGH2 need?

About 6.5 GB at 16-bit and 1.6 GB at 4-bit: the weights (2.7B parameters) plus a working margin. A long context needs more.

What is the cheapest GPU to run LFM2.5-24B-A2B-JANGH2 on?

At 16-bit, 1x MI300X from $1.85 an hour; at 4-bit, 1x MI300X from $1.85 an hour, at the lowest on-demand prices the SAVRN Index lists.

Can I use LFM2.5-24B-A2B-JANGH2 commercially?

Yes. LFM2.5-24B-A2B-JANGH2 is released under Apache License 2.0. The Apache License 2.0 is a permissive open-source license. It permits commercial use, modification and redistribution. It requires keeping the license and copyright notices and any NOTICE file, stating significant changes, and it includes an express patent grant from contributors.

What is LFM2.5-24B-A2B-JANGH2's context length?

131,072 tokens, from the maximum position embeddings in its published configuration.

Similar Models

An English LFM2.5 2.6B checkpoint associated with the Trendyol Cybersecurity Instruction Tuning Dataset. This repository contains both Transformers-format model files and local GGUF exports. This is a research release. The repository does not currently publish benchmark, baseline-comparison, or safety-evaluation results. Transformers assets include model.safetensors, configuration files, tokenizer files, and a chat template. Keeping both formats in one repository is convenient, but users should explicitly choose the path that matches their runtime. The checked configuration includes a bitsandbytes quantization block. Pin and test the exact Transformers, Accelerate, bitsandbytes, and device…

Open weights apache-2.0 2.7B parameters 131,072 tokens transformers

Model · Text generation

d

Khtsly

In-training periodic checkpoint (step 16300). Architecture: Kimi K3 mini port (KimiLinearForCausalLM). Not a finished model -- intermediate weights uploaded during training for safekeeping/diffing.

Open weights 2.7B parameters 1,048,576 tokens transformers

Model · Text generation

MiniCPM5-2B

OpenBMB

English | We are releasing MiniCPM5-2B, the second model in the MiniCPM5 series, following MiniCPM5-1B. It is a dense 2B Transformer that scales up the same training recipe, built for on-device, local deployment, and resource-constrained scenarios, reaching 2B-class open-source SOTA. 2B-class open-source SOTA: compared with strong open-source models of similar size, MiniCPM5-2B achieves SOTA performance within this comparison set. It remains competitive with 4B-class models overall, while showing its advantages over models of comparable size in coding, mathematics, long-context understanding, tool use, and agentic tasks. font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto…

Open weights apache-2.0 2.5B parameters 131,072 tokens transformers

Model · Text generation

MiniCPM5-2B-Math

Caldalis

English | MiniCPM5-2B-Math is a math and proof model built on MiniCPM5: a dense 2.5B model based on MiniCPM5-2B and post-trained for long-form mathematical reasoning and proof writing. It runs on a single consumer GPU or a laptop and keeps the native 128K context. - Strong for its size. As a plain single call with up to 128K tokens of thinking, 92.3 on AIME 2025, 89.8 on AIME 2026 and 81.8 on HMMT February 2026 (avg@16), and 100 / 93.3 / 90.9 with a 16-sample vote. The official general-purpose MiniCPM5-2B scores 87.1 / 89.8 / 68.4 under the same protocol. - Writes checkable proofs. On IMO-ProofBench Basic, an average single call with up to 128K tokens writes a complete proof for 21 of the…

Open weights apache-2.0 2.5B parameters 131,072 tokens transformers

Model · Text generation

axeron-mf-44

AXERON AI INC

This is a forge of pre-trained language models created using forgelm. This model was forged using the SLERP forge method. The following models were included in the forge: The following YAML configuration was used to produce this model

Open weights 3.1B parameters 32,768 tokens transformers

Model · Text generation

Qwen2.5-3B-Instruct

Qwen

Qwen2.5 is the latest series of Qwen large language models. For Qwen2.5, we release a number of base language models and instruction-tuned language models ranging from 0.5 to 72 billion parameters. Qwen2.5 brings the following improvements upon Qwen2: - Significantly more knowledge and has greatly improved capabilities in coding and mathematics, thanks to our specialized expert models in these domains. - Significant improvements in instruction following, generating long texts (over 8K tokens), understanding structured data (e.g, tables), and generating structured outputs especially JSON. More resilient to the diversity of system prompts, enhancing role-play implementation and…

Open weights other 3.1B parameters 32,768 tokens transformers