Nanbeige4.3-33B

Nanbeige4.3-33B is an open-weight, dense 33-billion-parameter foundation model developed by Nanbeige LLM Lab, the dedicated AI research team inside BOSS Zhipin (Kanzhun). Engineered primarily as a high-capacity teacher agent for smaller downstream models, it targets terminal-driven agentic coding, multi-turn reasoning, and complex workplace automation. Released under a permissive Apache 2.0 license, the model ships in both instruction-tuned and base variants, giving engineers complete freedom for self-hosted deployment and domain fine-tuning.

In the landscape of mid-sized open weights, Nanbeige4.3-33B establishes a distinct identity. Rather than serving as another generic conversational chatbot, it is tuned specifically to operate inside agentic harnesses like Claude Code, mini-swe-agent, and Terminus. Nanbeige reports class-leading numbers among ~30B parameter architectures, scoring 80.9 on Terminal-Bench 2.1 and 65.5 on DeepSWE. These scores place it ahead of strong segment rivals like Qwen3.8-27B on its own benchmark harness, particularly on tasks requiring multi-step tool execution and long-horizon environment feedback.

For local deployment, Nanbeige4.3-33B represents a compelling sweet spot. At 33B parameters, it avoids the massive memory footprint of 70B models while outperforming smaller 14B alternatives on complex reasoning. Its native support for a 524,288-token context window and configurable reasoning states makes it one of the most capable local AI model 33B parameters 2026 options for software engineering pipelines and local agent infrastructure.

Nanbeige4.3-33B is built on a standard dense decoder-only transformer architecture registered under the LlamaForCausalLM model type. This native compatibility allows modern inference engines like vLLM, SGLang, and NeMo AutoModel to run the checkpoint without requiring custom remote code execution.

The model distributes its 33.1 billion parameters across 52 transformer layers with a hidden dimension of 7,168. Key architectural specifications include:

• Attention Mechanism: Grouped-Query Attention (GQA) with 56 query heads and 8 key/value heads at a head dimension of 128. This 7:1 query-to-KV ratio keeps the memory overhead of the KV cache manageable across extended context windows.
• Feed-Forward Network: SwiGLU activation with an intermediate size of 22,016.
• Vocabulary: 166,912 tokens with untied input and output embeddings, providing strong cross-lingual compression across English and Chinese code and documentation.
• Positional Encoding: Rotary Position Embeddings (RoPE) configured with a base frequency (rope_theta) of 1.2e8 on the instruction checkpoint, natively supporting up to 524,288 tokens (512K) without auxiliary scaling interpolation.

Unlike Mixture-of-Experts (MoE) architectures that activate only a fraction of their parameter base per token, Nanbeige4.3-33B is fully dense. Every token traverses the entire 33.1B parameter stack. While dense inference requires higher raw memory bandwidth than sparse models of equivalent active weight, it delivers predictable compute utilization, eliminates MoE routing overhead, and avoids memory fragmentation issues on standard consumer GPU memory topologies.

The checkpoint features an integrated thinking mechanism enabled by default. In multi-turn agent environments, practitioners can configure the chat template via two parameters: enable_thinking (which toggles chain-of-thought generation on the active turn) and preserve_thinking (which keeps prior reasoning blocks in the context window). Nanbeige recommends setting preserve_thinking=True for agent loops, terminal execution, and multi-turn tool interaction, while setting it to False for standard Q&A to preserve context space.

Nanbeige4.3-33B is designed to complete complex technical tasks autonomously rather than simply answering questions. Its primary capabilities focus on three areas:

Nanbeige4.3-33B for coding excels in iterative, tool-driven environments. Instead of single-shot code completion, it is optimized to read repository structures, invoke command-line utilities, parse compiler diagnostics, and apply git patches. It scores 65.5 on DeepSWE and 80.9 on Terminal-Bench 2.1, showing robust error recovery when terminal commands fail. Key use cases include running automated bug-fix daemons, automated code review workflows, and synthetic code data generation.

On workplace evaluation suites like JobBench (44.8) and Automation Bench (54.2), the model demonstrates strong multi-step planning across dozens of distinct occupations. It natively formats tool calls using structured XML syntax (recommended for maximum accuracy) or JSON. This enables enterprise developers to deploy the model as a local orchestrator for internal APIs, document analysis workflows, and enterprise data extraction.

The model features strong math and algorithmic performance. In the Nanbeige4.3-33B reasoning benchmark evaluations, it achieves 95.2 on AIME 2026 and 89.5 on GPQA Diamond when running at full thinking effort. This makes it viable for verifying code logic, analyzing algorithmic proofs, and executing complex data transformations without external assistance.

Deploying Nanbeige4.3-33B on private hardware requires balancing parameter precision against the memory footprint of its 512K context window.

The unquantized FP16 weights require approximately 66 GB of VRAM simply to load into memory, before accounting for the KV cache. To run the model efficiently, quantization is practically mandatory on consumer hardware:

• FP16 / BF16 (Unquantized): ~66-70 GB VRAM. Requires dual 48GB enterprise cards, dual RTX 4090s via pipeline/tensor parallelism (for short contexts), or an Apple Silicon Mac with 96GB+ unified memory.
• 8-bit Quantization (Q8_0 / FP8): ~36-38 GB VRAM. Runs comfortably on dual 24GB GPUs (such as 2x RTX 3090 or 2x RTX 4090) or a single professional 48GB GPU (RTX 6000 Ada, A6000).
• 4-bit Quantization (Q4_K_M): ~20-22 GB VRAM for the base weights. This enables execution on a single 24GB consumer GPU for standard context sizes (8,192 to 16,384 tokens).
• 3-bit Quantization (Q3_K_M): ~16-18 GB VRAM. Leaves sufficient headroom for medium-length context buffers on a single 24GB card.

Keep in mind that while the model architecture supports up to 524,288 tokens, running the full context requires substantial memory for the KV cache. At 512K tokens with FP16 KV cache, the context alone consumes tens of gigabytes of RAM. For local setups with a single GPU, context should be constrained to 16K-32K tokens unless using FP8 or 4-bit KV cache quantization.

The best quantization for Nanbeige4.3-33B for most developers is Q4_K_M (or equivalent EXL2/AWQ profiles around 4.25 bpw). At 4-bit, the model maintains near-lossless performance on coding and logic benchmarks while staying within accessible memory bounds.

• Best GPU for Nanbeige4.3-33B (Single Card): An Nvidia GeForce RTX 3090 or RTX 4090 (24GB VRAM). At Q4_K_M, you can run Nanbeige4.3-33B locally for daily coding and chat tasks with an 8K-16K context window.
• Multi-GPU Workstation: A setup with 2x RTX 3090 (48GB combined) provides enough VRAM to run Q8_0, or Q4_K_M with context expanded to 64K-128K tokens.
• Apple Silicon: A Mac Studio or MacBook Pro equipped with an M3 Max or M4 Max (64GB or 128GB unified memory) handles Q4_K_M and Q8_0 variants cleanly, providing substantial memory headroom for long-context execution.

On an RTX 4090 running a Q4_K_M GGUF via llama.cpp or an AWQ checkpoint in vLLM, expect Nanbeige4.3-33B tokens per second to hover between 28 and 40 tok/s for generation, depending on prompt size and quantization precision. On Apple Silicon (M3/M4 Max), token generation typically settles between 18 and 28 tok/s under llama.cpp metal acceleration.

The fastest way to test the model locally is via Ollama once community GGUFs are imported:

1ollama run nanbeige4.3-33b

For production agent harnesses requiring high concurrency and native tool-call parsing, use vLLM or SGLang:

1# SGLang deployment with Qwen reasoning and tool parsers
2python -m sglang.launch_server \
3  --model-path Nanbeige/Nanbeige4.3-33B \
4  --host 0.0.0.0 \
5  --port 8000 \
6  --tp-size 2 \
7  --mem-fraction-static 0.85 \
8  --reasoning-parser qwen3 \
9  --tool-call-parser qwen3_coder

1# vLLM deployment
2vllm serve Nanbeige/Nanbeige4.3-33B \
3  --host 0.0.0.0 \
4  --port 8000 \
5  --tensor-parallel-size 2 \
6  --gpu-memory-utilization 0.85 \
7  --enable-auto-tool-choice \
8  --reasoning-parser qwen3 \
9  --tool-call-parser qwen3_coder

Evaluating Nanbeige4.3-33B against other models in the 27B-35B parameter bracket highlights its specific specialization.

Qwen3.8-27B is one of the strongest general-purpose models in this weight class. In standard SWE-Bench Pro evaluations, Qwen slightly edges out Nanbeige (61.7 vs 60.3). However, on terminal interaction and iterative repo-level tasks, Nanbeige4.3-33B pulls ahead significantly: 80.9 vs 73.0 on Terminal-Bench 2.1, and 65.5 vs 42.5 on DeepSWE. Nanbeige also offers an expansive 512K context window compared to standard context profiles. If your focus is purely autonomous shell operations and agentic loops, Nanbeige holds the advantage. For broad multilingual conversational tasks, Qwen remains an exceptionally balanced alternative.

Gemma4-31B performs well on academic knowledge retrieval, scoring slightly higher on GPQA Diamond (91.3 vs 89.5). However, on complex agent workflows, Nanbeige4.3-33B dominates. On Terminal-Bench 4.0, Nanbeige achieves 23.8 compared to Gemma's 0.0, and on DeepSWE it posts 65.5 against Gemma's 2.7. Gemma's tuning lacks the multi-step terminal-harness training that Nanbeige received. For developers needing an agent that can interact with bash commands, git, and file trees, Nanbeige4.3-33B is the more capable engine.