---
license: apache-2.0
language:
- en
- zh
library_name: transformers
pipeline_tag: text-generation
tags:
- llm
- nanbeige
base_model:
- Nanbeige/Nanbeige4.2-3B-Base
---
# 1. Introduction
Nanbeige4.2-3B is a compact agentic model built on [Nanbeige4.2-3B-Base](https://huggingface.co/Nanbeige/Nanbeige4.2-3B-Base), designed to combine strong agentic behavior with broad reasoning and alignment capabilities. Its Looped Transformer architecture reuses the transformer layers to increase model capacity without adding parameters. With only 3B non-embedding parameters, the model delivers solid performance on general-agent and code-agent tasks.
During supervised fine-tuning (SFT), we expand the diversity of training environments through real-world environment integrations and large-scale environment synthesis. We further diversify task types, task assets, and the agentic scaffolds used for each task. To ensure training data quality, we apply filtering at both the trajectory and turn levels, combining test-case-based validation with rubric-based assessment. During reinforcement learning (RL), we combine outcome and process rewards to improve training stability for the compact model.
Key strengths include:
- **Solid Agentic Behavior at the 3B Scale**: Across complex tool-use, office-agent, and code-agent benchmarks, Nanbeige4.2-3B outperforms larger models such as Qwen3.5-9B and Gemma4-12B.
- **Strong Reasoning Capabilities**: Nanbeige4.2-3B leads open-source models of comparable size across mathematical, coding, and scientific reasoning tasks, continuing the strong reasoning performance of [Nanbeige4.1-3B](https://huggingface.co/Nanbeige/Nanbeige4.1-3B).
- **Local Personal Assistant**: When integrated with an agentic scaffold designed for personal workflows (e.g., OpenClaw), Nanbeige4.2-3B can support extended tasks spanning daily assistance, office work, and deep research.
> The accompanying `modeling_nanbeige.py` also includes our latest architectural improvements, including **LoopSplit**, **mHC with depth attention**, and **concatenated n-gram embeddings**. These features have been incorporated into Nanbeige4.5, whose training is underway for release later in 2026.
# 2. Model Performance
## General and Agentic Capabilities
We compare Nanbeige4.2-3B with Qwen3.5 and Gemma4 models across a diverse benchmark suite covering general agents, code agents, reasoning, and alignment capabilities.
| - |
- |
Nanbeige4.2-3B1 |
Qwen3.5-9B |
Qwen3.5-4B |
Gemma4-12B |
Gemma4-E4B |
| Parameters |
Total Params | 4B | 10B | 5B | 12B | 8B |
| Non-embedding Params | 3B | 8B | 4B | 10B | 4B |
| General Agent2 |
GDPval rubrics | 74.3 | 61.9 | 46.7 | 68.5 | 31.5 |
| Agent-IF-Oneday | 67.5 | 60.4 | 56.9 | — | — |
| Office-QA-Pro3 | 21.1 | 15.8 | 8.3 | 15.3 | 3.1 |
| Pinch-Bench-V2 | 74.7 | 68.2 | 63.9 | 53.8 | 33.3 |
| Claw-Gym | 65.0 | 56.1 | 53.0 | 40.8 | 16.4 |
| Claw-Evalpass^3 | 52.2 | 47.1 | 36.9 | 25.5 | 15.9 |
| MCP-Atlas | 57.8 | 47.4 | 40.8 | 30.5 | 15.0 |
| Code Agent4 |
SWE-Bench Verified | 63.6 | 53.1 | 38.8 | 44.2 | 14.0 |
| SWE-Bench Pro | 46.9 | 33.8 | 29.4 | 21.9 | 4.0 |
| Terminal-Bench 2.0 | 44.1 | 29.2 | 25.8 | 21.1 | 12.4 |
| Reasoning |
HLE w/o Search | 17.8 | 12.5 | 6.8 | 14.8 | 4.0 |
| SciCode | 35.6 | 32.7 | 22.7 | 38.2 | 24.9 |
| GPQA-Diamond | 87.4 | 81.7 | 78.2 | 78.8 | 60.6 |
| HMMT-Feb-2026 | 82.8 | 69.6 | 60.6 | 51.5 | 24.2 |
| IMO-Answer-Bench | 67.3 | 56.3 | 46.8 | 54.5 | 24.0 |
| LiveCodeBench-V6 | 72.5 | 65.6 | 55.8 | 72.0 | 55.3 |
| Alignment |
AA-LCR | 58.7 | 58.0 | 52.0 | 55.3 | 30.7 |
| IF-Bench | 54.6 | 54.1 | 41.4 | 73.5 | 44.0 |
| Recruit-Bench5 | 63.3 | 59.0 | 40.7 | 69.4 | 57.9 |
1 All evaluations are conducted in thinking mode with preserve_thinking=true in the chat template.
2 Office and co-work tasks such as GDPval, Office-QA-Pro, and Agent-IF-Oneday are evaluated with our in-house scaffold.
3 For OfficeQA-pro, we follow the most challenging evaluation setup: for each question, we provide all the original PDF materials without giving any hints about the relevant documents.
4 SWE-Bench Verified uses the OpenHands scaffold, SWE-Bench Pro uses the SWE-agent scaffold, and Terminal-Bench 2.0 uses the Terminus 2 scaffold.
5 Recruit-Bench is our in-house benchmark covering enterprise hiring scenarios (B2C) and job-seeking scenarios for candidates (C2B).
The results demonstrate that Nanbeige4.2-3B delivers strong performance well beyond its parameter scale. With only 3B non-embedding parameters, it consistently outperforms larger models, including Qwen3.5-9B and Gemma4-12B, across general-agent, code-agent, and reasoning benchmarks, while remaining competitive on alignment tasks.
## Local Personal Assistant
With only 3B non-embedding parameters, Nanbeige4.2-3B is compact enough for local deployment while retaining the agentic capabilities needed for multi-step workflows, making it a natural fit for local personal-assistant applications. To assess this use case in a practical and consistent agent environment, we use OpenClaw, a general-purpose framework that supports daily assistance, office workflows, and deep research tasks. All compared models use the same framework and are evaluated on tasks requiring multi-step interaction with tools and external resources.
| Capability |
Benchmark |
Nanbeige4.2-3B |
Qwen3.5-9B |
Qwen3.5-4B |
| Daily Tasks |
Pinch-Bench-V2 | 74.7 | 68.2 | 63.9 |
| Claw-Gym | 65.0 | 56.1 | 53.0 |
| Office Tasks |
GDPval | 68.8 | 38.0 | 37.0 |
| Agent-IF-Oneday | 58.9 | 32.1 | 27.0 |
| Deep Research |
DeepResearch Bench II | 33.4 | 28.3 | 26.0 |
| ResearchRubrics | 44.8 | 37.2 | 35.1 |
Across all six benchmarks, Nanbeige4.2-3B outperforms both Qwen3.5-4B and the larger Qwen3.5-9B. These results support its use as a compact local personal assistant.
# 3. Quickstart
The tokenizer provides a configurable chat template for reasoning and tool-use scenarios:
- `enable_thinking` controls whether the model generates reasoning for the current response. It is enabled by default; set it to `False` for non-thinking mode.
- `preserve_thinking` controls whether reasoning from previous assistant turns is retained in a multi-turn conversation. We recommend `False` for general chat and question answering, and `True` for multi-turn tool use, office tasks, and code-agent workflows.
- Passing `tools` enables the tool-use template. We recommend `tool_call_format="xml"` for the best tool-calling performance; `json` is also supported for compatibility.
We recommend adjusting the inference settings according to the target scenario:
| Scenario | Temperature | Max New Tokens |
|---|---:|---:|
| Agentic and tool-use tasks | 1.0 | 65,536 |
| Reasoning and chat tasks | 0.6 | 131,072 |
## Huggingface
```python
from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "Nanbeige/Nanbeige4.2-3B"
tokenizer = AutoTokenizer.from_pretrained(
model_id,
use_fast=False,
trust_remote_code=True
)
model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype="auto",
device_map="auto",
trust_remote_code=True
)
messages = [
{"role": "user", "content": "Which number is bigger, 9.11 or 9.8?"}
]
prompt = tokenizer.apply_chat_template(
messages,
add_generation_prompt=True,
tokenize=False
)
input_ids = tokenizer(
prompt,
add_special_tokens=False,
return_tensors="pt"
).input_ids
output_ids = model.generate(
input_ids.to("cuda"),
max_new_tokens=131072,
temperature=0.6,
top_p=0.95,
top_k=20,
eos_token_id=166101
)
response = tokenizer.decode(
output_ids[0][len(input_ids[0]):],
skip_special_tokens=True
)
print(response)
```
## SGLang
### Installation
```bash
# Clone repository
git clone -b nanbeige42 https://github.com/Nanbeige/sglang.git
cd sglang
pip install -e "python"
```
### Usage
```bash
MODEL_PATH=/path/to/your/Nanbeige4.2-3B
python -m sglang.launch_server \
--model-path ${MODEL_PATH} \
--host 0.0.0.0 \
--port 8000 \
--tp-size 1 \
--mem-fraction-static 0.8 \
--reasoning-parser nanbeige \
--tool-call-parser nanbeige
```
## vLLM
### Installation
```bash
# Clone repository
git clone -b nanbeige42 https://github.com/Nanbeige/vllm.git
cd vllm
pip install -e .
```
### Usage
```bash
MODEL_PATH=/path/to/your/Nanbeige4.2-3B
vllm serve ${MODEL_PATH} \
--host 0.0.0.0 \
--port 8000 \
--tensor-parallel-size 1 \
--gpu-memory-utilization 0.8 \
--enable-auto-tool-choice \
--tool-call-parser nanbeige \
--reasoning-parser nanbeige
```
## llama.cpp
### Installation
```bash
# Clone repository
git clone -b nanbeige42 https://github.com/Nanbeige/llama.cpp.git
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j
```
### Usage
```bash
# input: HuggingFace model directory
MODEL_PATH_HF=/path/to/your/Nanbeige4.2-3B
# output: converted / quantized GGUF
MODEL_PATH_BF16_GGUF=/path/to/your/Nanbeige4.2-3B-BF16.gguf
MODEL_PATH_GGUF_Q4_K_M=/path/to/your/Nanbeige4.2-3B-Q4_K_M.gguf
# convert to gguf
python3 convert_hf_to_gguf.py ${MODEL_PATH_HF} \
--outfile ${MODEL_PATH_BF16_GGUF} \
--outtype bf16
# quantize to int4
./build/bin/llama-quantize \
${MODEL_PATH_BF16_GGUF} \
${MODEL_PATH_GGUF_Q4_K_M} \
Q4_K_M
# run inference
./build/bin/llama-cli \
-m ${MODEL_PATH_GGUF_Q4_K_M} \
-ngl 99
```
## ollama
### Requirements
- **Go**
- **llama.cpp** (see the [llama.cpp](#llamacpp) section above)
### Installation
```bash
# Clone repository
# For llama-server (GGUF) backend only, the official ollama repo also works:
# git clone https://github.com/ollama/ollama.git
git clone -b nanbeige42 https://github.com/Nanbeige/ollama.git
cd ollama
# Full native build (MLX Metal on macOS arm64; llama-server payload included)
# Pick one:
cmake -B build .
cmake --build build --parallel $(sysctl -n hw.ncpu) # macOS
# cmake --build build --parallel $(nproc) # Linux
# Copy the llama.cpp build output from the section above into Ollama's runtime payload dir
LLAMA_CPP_PATH=/path/to/your/llama.cpp
cp -r ${LLAMA_CPP_PATH}/build/bin/* build/lib/ollama/
go build .
```
Ollama supports two local inference backends:
| Path | Model format | Backend | Typical use |
|------|--------------|---------|-------------|
| **llama-server** | GGUF | llama.cpp (Metal / CUDA / ...) | Traditional GGUF quantized deployment |
| **MLX** | HuggingFace safetensors | MLX (Apple Metal, etc.) | Run BF16 or quantized safetensors directly |
### Usage — llama-server (GGUF)
```bash
# Option 1: pull a published model (no Modelfile on the client)
./ollama serve
./ollama run nanbeige/nanbeige4.2:3b-Q4_K_M
```
```bash
# Option 2: create from a local .gguf produced by llama.cpp
# (see convert_hf_to_gguf.py / llama-quantize above)
MODEL_PATH_GGUF_Q4_K_M=/path/to/your/Nanbeige4.2-3B-Q4_K_M.gguf
# Modelfile
cat > Modelfile < Modelfile <4. Limitations
While we place great emphasis on model safety throughout the training process, the model may still generate unexpected or inappropriate outputs due to its probabilistic nature. Such outputs may include inaccurate information, bias, discrimination, or other harmful content. Please do not propagate such content. We do not assume responsibility for consequences of disseminating inappropriate information.
# 5. Citation
If you find our model useful or would like to use it in your own work, please cite this Hugging Face project:
```bibtex
@misc{nanbeige2026,
title = {Nanbeige4.2-3B},
author = {Nanbeige Team},
year = {2026},
publisher = {Hugging Face},
howpublished = {\url{https://huggingface.co/Nanbeige/Nanbeige4.2-3B}}
}
```
# 6. Contact
If you have any questions, please open an issue in this repository or contact us at nanbeige@kanzhun.com.
