Lounge
Connecting…
Connecting…
View all

Nanbeige4.3-33B: Benchmarks, VRAM Needs and License

Nanbeige4.3-33B explained from its model card: dense 33B architecture, self-reported agentic benchmarks, GGUF file sizes, KV cache memory and Apache 2.0 terms.

AILatest5 min read45 viewsPublished Updated
Contents6 sections
  1. What is Nanbeige4.3-33B?
  2. How to read the Nanbeige4.3-33B benchmarks
  3. Hardware needed to run a 33B model locally
  4. Apache 2.0 license: what commercial users should check
  5. Frequently asked questions
  6. Sources and references

Key takeaways

  • Nanbeige4.3-33B is a 33B-parameter text model from Nanbeige LLM Lab, released as the 'teacher' model of the Nanbeige4.3 series and tuned for agentic coding and cowork tasks.
  • Its benchmark table is self-reported. It leads Qwen3.8-27B on Terminal-Bench 2.1 (80.9 vs 73.0) but trails it on SWE-Bench Pro (60.3 vs 61.7) and GDPval (84.8 vs 86.4).
  • The BF16 weights total about 66 GB. In bartowski's GGUF set, Q4_K_M is 20.79 GB and Q8_0 is 35.20 GB, before any KV cache.
  • The model accepts up to 524,288 tokens of context, but a full-length 16-bit KV cache would need roughly 111.7 GB on its own.
  • The Hub lists the license as Apache 2.0, which permits commercial use with notice requirements; derivative quants and fine-tunes must be checked separately.

Nanbeige4.3-33B is a 33-billion-parameter open-weights language model from Nanbeige LLM Lab, built for agentic work such as terminal coding, repository tasks and multi-step office automation. The developer describes it as the flagship "teacher" of the Nanbeige4.3 series, meant to anchor distillation into smaller models such as a planned Nanbeige4.3-3B. This guide is based on the model card, its config file and community quantization repositories as checked on October 31, 2026, when the page showed 820 likes and 13,832 downloads in the past month.

What is Nanbeige4.3-33B?

It is a fine-tuned chat model built on Nanbeige4.3-33B-Base and published in BF16 safetensors. The Hub tags it for text generation with Transformers, and lists English and Chinese as its languages. According to the developer, the goal was state-of-the-art agentic performance among open models in the roughly 30B class, with particular strength in complex coding and what the card calls professional cowork tasks.

  • Architecture: LlamaForCausalLM with 52 layers, a hidden size of 7,168 and a vocabulary of 166,912 tokens (config.json).
  • Attention: 56 query heads and 8 key-value heads (grouped-query attention), head dimension 128.
  • Context: up to 524,288 tokens (512K).
  • Files: 14 safetensors shards totaling about 66.3 GB.
  • License tag: apache-2.0.

Because the config has no mixture-of-experts fields, this is effectively a dense model: every parameter participates in every token. Keep that in mind when comparing it with MoE models that advertise a similar total size but activate only a fraction per token.

Thinking mode and tool calling

The chat template exposes two switches. enable_thinking is on by default and makes the model reason before it answers. preserve_thinking keeps earlier reasoning in the conversation history; the developer recommends False for ordinary chat and True for multi-turn tool use, office tasks and coding agents. Passing tools enables a tool-use template, with XML tool calls recommended and JSON supported for compatibility. Suggested sampling is temperature 1.0 and top_p 0.95 with up to 65,536 new tokens for agentic work, and temperature 0.6 with up to 262,144 new tokens for reasoning and chat.

How to read the Nanbeige4.3-33B benchmarks

How to read the Nanbeige4.3-33B benchmarks

The model card compares Nanbeige4.3-33B with Qwen3.8-27B, Muse-Glimmer-30B and Gemma4-31B, all evaluated at their highest thinking effort with shared hyperparameters and harnesses. These are developer-reported numbers. Treat them as a starting hypothesis until independent evaluations appear.

Terminal-Bench 2.1

Nanbeige4.3-33B
80.9
Qwen3.8-27B
73.0
Gemma4-31B
47.2

DeepSWE

Nanbeige4.3-33B
65.5
Qwen3.8-27B
42.5
Gemma4-31B
2.7

SWE-Bench Pro

Nanbeige4.3-33B
60.3
Qwen3.8-27B
61.7
Gemma4-31B
36.9

GDPval

Nanbeige4.3-33B
84.8
Qwen3.8-27B
86.4
Gemma4-31B
71.4

GPQA Diamond

Nanbeige4.3-33B
89.5
Qwen3.8-27B
89.2
Gemma4-31B
91.3

AIME 2026

Nanbeige4.3-33B
95.2
Qwen3.8-27B
94.5
Gemma4-31B
89.2

The biggest margins are on terminal tasks, DeepSWE and Automation Bench (54.2 vs 38.3 for Qwen3.8-27B). On SWE-Bench Pro, which is closer to real repository fixes, and on GDPval, Qwen3.8-27B is slightly ahead, while Gemma4-31B posts the top GPQA Diamond score. The useful question is not which model wins most rows but which row looks most like your workload.

Read the footnotes. Nanbeige4.3-33B was scored with preserve_thinking=true, NL2Repo was run through the Claude Code harness, and SWE-Atlas-QnA used another model as the judge. Different harnesses and settings can move scores substantially, so do not expect identical results from a local setup.

Early community reports often surface practical problems a benchmark table hides, such as broken chat templates or repetitive output. Tracking how developers discuss a new release in theddari's AI Telegram trends and blog trends feeds can help you spot those issues before you commit hardware time.

Hardware needed to run a 33B model locally

Hardware needed to run a 33B model locally

Start with weight size. The full BF16 checkpoint is about 66 GB, which is why the developer's vLLM and SGLang examples use tensor parallelism across four GPUs. The developer has also published official FP8, INT8 and INT4 variants, and the Hub listed 99 quantized derivatives at the time of checking. For llama.cpp-style runtimes, the bartowski GGUF repository is a common reference.

BF16

File size
66.24 GB
Maker's note
Full weights

Q8_0

File size
35.20 GB
Maker's note
Max quality, usually unnecessary

Q6_K

File size
29.02 GB
Maker's note
Very high quality

Q5_K_M

File size
25.07 GB
Maker's note
High quality

Q4_K_M

File size
20.79 GB
Maker's note
Default for most use cases

IQ3_M

File size
17.80 GB
Maker's note
Medium-low quality

Q2_K

File size
13.53 GB
Maker's note
Very low quality

The repository's rule of thumb: for full GPU offload, choose a file 1 to 2 GB smaller than your VRAM; for maximum quality, compare against VRAM plus system RAM. The quants were made with llama.cpp release b11845, so update older builds before loading them.

The KV cache is the hidden cost

Context length adds memory on top of the weights. Using the config values, a 16-bit KV cache needs 2 (keys and values) × 52 layers × 8 KV heads × 128 dimensions × 2 bytes = 212,992 bytes per token. That works out to about 6.98 GB at 32,768 tokens, 27.9 GB at 131,072 tokens and 111.7 GB at the full 524,288 tokens. Runtimes that quantize or page the cache will use less, but 512K support does not mean 512K is practical on a desktop. On a 24 GB card, Q4_K_M leaves roughly 3 GB, which is not enough even for a 32K context at 16-bit. Apple Silicon users face the same arithmetic with unified memory, plus whatever the operating system needs.

Apache 2.0 license: what commercial users should check

The Hub metadata lists apache-2.0. The Apache License 2.0 allows use, modification, redistribution and commercial use, and includes a patent grant. If you redistribute the weights or a derivative, you must include a copy of the license, mark modified files and keep existing attribution notices. The license grants no trademark rights and comes with no warranty.

  1. Record the exact repository and commit you deploy. At the time of checking, the original repository's file list showed no separate LICENSE or NOTICE file, so keep the metadata snapshot or written confirmation from the developer if your legal team needs it.
  2. Check each quantization or fine-tune separately. Repositories labeled abliterated or Heretic advertise removed safeguards and deserve extra output review.
  3. The Transformers example sets trust_remote_code=True. Pin a commit, read the code and run it in an isolated environment.
  4. Plan your own evaluation and filtering before exposing the model to customers; responsibility for outputs stays with the deployer.

In short, Nanbeige4.3-33B is a dense 33B model with strong self-reported agentic scores and a permissive license tag, but it is heavy to run: about 66 GB in BF16 and around 20 GB even at 4-bit, before context. Size your memory budget for the context you actually need, confirm your runtime version, verify the license of the exact files you download, and benchmark it on your own tasks against the model you use today.

Frequently asked questions

Is Nanbeige4.3-33B a mixture-of-experts model?
No sign of it. The published config.json uses the LlamaForCausalLM architecture and contains no expert-related fields, so it reads as a dense model where all 33B parameters are used for every token. That means more compute per token than an MoE model with a similar total size, and generation speed depends heavily on memory bandwidth.
Can I run Nanbeige4.3-33B on a single 24 GB GPU?
The weights can fit: the Q4_K_M GGUF is 20.79 GB. That leaves only about 3 GB for the KV cache and runtime buffers, so long contexts will not fit at 16-bit precision. You can shorten the context, quantize the KV cache, or offload some layers to system RAM, accepting slower generation in exchange.
Does Nanbeige4.3-33B support Ollama or LM Studio?
Community GGUF builds are available and the bartowski repository lists LM Studio, Ollama and llama.cpp among compatible apps. Those files were produced with llama.cpp release b11845, so older app versions may fail to load them. Update your runtime first and confirm the chat template renders the thinking and tool-call tags correctly.
How good is it in languages other than English and Chinese?
As of October 2026 the model card tags only English and Chinese and publishes no multilingual scores. Other languages may work, but quality is not documented, so test with your own prompts before relying on it.

Sources and references

  1. 1Hugging Face: Nanbeige/Nanbeige4.3-33B model card(opens in a new tab)huggingface.co
  2. 2Hugging Face: Nanbeige4.3-33B config.json(opens in a new tab)huggingface.co
  3. 3Hugging Face: Nanbeige4.3-33B repository files(opens in a new tab)huggingface.co
  4. 4Hugging Face: quantized models based on Nanbeige4.3-33B(opens in a new tab)huggingface.co
  5. 5bartowski: Nanbeige4.3-33B GGUF quantizations(opens in a new tab)huggingface.co
  6. 6Apache License, Version 2.0(opens in a new tab)www.apache.org