IFM Releases K2-Horizon-32B-NVFP4 with Native Blackwell Support

September 23, 2026

At a Glance

Values determined by this site’s code at collection time. Dates are JST.

Overview

IFM has released “IFM/K2-Horizon-32B-NVFP4", a model obtained by quantizing the Stage1 checkpoint of the open-weight large language model “K2-Horizon-32B" into the NVFP4 format.

This model is a 32B dense-configuration, decoder-only model featuring a massive context length of 512K (524,288 tokens). Both weights and activations are quantized to NVFP4 across all linear layers except for lm_head, making it optimized for NVIDIA Blackwell generation (Bシリーズ) and later GPUs with native NVFP4 support.

Specifications

• Parameter count: 32B (Total parameters 32B / Activated parameters 32B)
• Architecture: Dense (decoder-only)
• Context length: 512K (524,288 tokens)

Performance

The model card published by the release origin features a comparison table against other open-weight dense models, as well as a quantization comparison table between the BF16 version and the NVFP4 version.

First, the comparison results with open-weight dense models in the same scale category are as follows:

From this table, it can be seen that K2-Horizon-32B-Stage1 demonstrates high-level reasoning capabilities comparable to Muse Glimmer-30B and outperforms IBM Granite 4.2 30B in Humanity’s Last Exam (22.8%), which collects expert-level ultra-difficult questions, and GPQA Diamond (82.3%), which tests PhD-level science questions. On the other hand, in agent capabilities and coding metrics such as Terminal-Bench 2.1 (36.6%) measuring terminal operation completion, tau3-Banking (22.5%), and SciCode (30.2%), it falls short of Qwen3.8-27B (79.8%, 48.0%, 44.7%), showing a clear gap.

Next is the direct comparison data between the original model’s BF16 version and this NVFP4 version (65,536 token context length, 0-shot evaluation).

According to measurements by the release origin, the average score dropped by a mere 1.1 points from 89.5% for the BF16 version to 88.4% for the NVFP4 version. While maintaining figures equal to or higher than BF16 in GSM8K (96.59%), which solves math word problems, and BBH (93.30%), a reasoning task, slight score drops are observed in challenging fields such as GPQA-Diamond (81.76% → 78.82%), AIME 26 (92.60% → 91.15%) testing Math Olympiad preliminary levels, MBPP (94.40% → 93.20%) solving Python problems, and IFEval (86.69% → 85.40%) measuring instruction-following. Note that evaluation of the NVFP4 version is currently limited to non-agent tasks, and agent task results are scheduled to be released at a later date.

Strengths and Use Cases

While possessing an easy-to-manage scale of 32B, “IFM/K2-Horizon-32B-NVFP4" combines extremely long-context processing capabilities, advanced reasoning abilities, and flexible tool use functions, making it particularly strong in the following use cases:

Long-Context Processing (Supports 512K Tokens)

This model supports a native context window of 524,288 tokens (512K) from the midtraining stage onwards. This makes it possible to input bundles of academic papers, large-scale source code bases, or lengthy contracts all at once, and perform advanced analysis, summarization, and Q&A based on their contents.

Advanced Reasoning with Thought Processes

This model features the capability to output thought processes (Reasoning). When used via the API, by specifying the recommended setting reasoning_effort="high", the model outputs the thought process leading to the answer in reasoning_content and the final answer in content separately. This enables obtaining high-quality answers that build accurate step-by-step thoughts in difficult tasks such as mathematics, science, and complex logic puzzles.

Flexible Tool Use and Agent Integration

This model supports multiple formats for integration with external tools. Specifically, it supports three types of tool-calling formats: json, xml, and xml_typed, with xml used by default. These can be toggled per request via chat_template_kwargs, allowing flexible agent construction tailored to system requirements.

Fast and Memory-Efficient Inference on Blackwell GPUs

The greatest feature of this model is that the weights and activations of all linear layers except for lm_head are quantized into the NVFP4 format. This allows for extremely fast inference while drastically reducing memory usage on GPUs with native NVFP4 support from the NVIDIA Blackwell generation (Bシリーズ) and later. Because the performance drop compared to the BF16 version is suppressed to a mere minimum (a 1.1-point drop in average score), it becomes an extremely practical choice for engineers who own Blackwell hardware.

Hardware Requirements

Estimated requirements (calculated by Local Model Watch) — 20.7B parameters

Inference engine support (architecture name matched against each project’s own model registry in its source code, checked 2026-09-22): llama.cpp: not registered, vLLM: registered, MLX (mlx-lm): not 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. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.

Recent Models in the Same Size Class

Models with 15–40B 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.

How to Get It

This model can be freely downloaded and used from the Hugging Face repository. It is published under the “Apache-2.0" license and is not a gated model requiring prior consent for use, meaning anyone can obtain it immediately.

The distribution format is safetensors, and it is compatible with vLLM, SGLang, and Hugging Face’s Transformers library as serving engines.

Below are usage methods and code examples for each engine provided by the release origin. Note that the following code examples are written based on the BF16 version (IFM/K2-Horizon-32B), but similar settings and parser designations are also recommended when running the NVFP4 version.

Serving with vLLM

Here is an example command for launching a server using vLLM. It is recommended to enable the k2_horizon reasoning parser for chat and the tool call parser for agents.

vllm serve IFM/K2-Horizon-32B \
  --revision main \
  --model-impl vllm \
  --tensor-parallel-size 2 \
  --trust-remote-code \
  --dtype bfloat16 \
  --max-model-len 131072 \
  --reasoning-parser k2_horizon \
  --enable-auto-tool-choice \
  --tool-call-parser k2_horizon

Serving with SGLang

Here is an example command when using SGLang. This recipe is verified on a 2× H200 environment.

python3 -m sglang.launch_server \
  --model-path IFM/K2-Horizon-32B \
  --revision main \
  --tp 2 \
  --dtype bfloat16 \
  --attention-backend fa3 \
  --reasoning-parser k2_horizon \
  --tool-call-parser k2_horizon \
  --host 0.0.0.0 --port 30000

API Usage Example (Python)

Here is a Python code example to obtain answers with thought processes via the OpenAI-compatible API after starting the server. Recommended settings such as temperature=1.0, top_p=0.95, and reasoning_effort="high" are specified.

from openai import OpenAI

client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")
response = client.chat.completions.create(
    model="IFM/K2-Horizon-32B",
    messages=[{"role": "user", "content": "Explain the result step by step."}],
    temperature=1.0,
    top_p=0.95,
    max_tokens=32768,
    extra_body={"chat_template_kwargs": {"reasoning_effort": "high", "tool_call_format": "xml"}},
)
message = response.choices[0].message
print("Reasoning:", getattr(message, "reasoning_content", None))
print("Answer:", message.content)

Usage Example with Transformers

Here is a code example to load the model directly and generate text using Transformers (verified with version 5.15.0, PyTorch 2.13.0, and Safetensors 0.8.0).

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "IFM/K2-Horizon-32B"
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id, device_map="auto", dtype="bfloat16", low_cpu_mem_usage=True, trust_remote_code=True
)

inputs = tokenizer("Explain why long-context evaluation is difficult.", return_tensors="pt").to(model.device)
inputs.pop("token_type_ids", None)
outputs = model.generate(**inputs, max_new_tokens=32768, temperature=1.0, top_p=0.95, do_sample=True)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Related Articles

• IFM Releases K2-Horizon-375B-A23B-NVFP4 Quantized Model
• NVIDIA Releases NVFP4 Quantized DeepSeek-V4-Pro
• OpenBMB Releases MiniCPM5-2B: A SOTA 2B On-Device Model

Sources

• IFM/K2-Horizon-32B-NVFP4 (Hugging Face)