Nanbeige 4.3 33B arrived on 24 October with a benchmark table aimed straight at the model this site tells most people to run. Its maker says the dense 33-billion-parameter model beats Qwen3.8 27B on 16 of 20 agentic coding, office-work and reasoning tests, under a plain Apache 2.0 licence. Three weeks later, Hugging Face has thousands of downloads of community quants, a 16-comment thread titled "Benchmaxxed", and an independent test that puts it behind Qwen. Here is what the lab claims, what owners found, and the memory cost that decides whether it belongs on a 24GB card.
What the lab says
Nanbeige comes from the Nanbeige lab at Kanzhun, the company behind the Boss Zhipin recruitment app; the model card's contact address is a kanzhun.com one. The lab is best known for small models: its 3B releases are documented in three arXiv reports. The card calls 4.3 33B a "flagship teacher model", built first so that its agent skills can later be distilled into a 4.3 3B. Users in the model's discussions are already asking when that smaller model ships.
The model is text only, with a 524,288-token context, a thinking mode that can be switched off, and a recommended XML format for tool calls. The card's table compares it with Qwen3.8 27B, Muse-Glimmer-30B and Gemma4-31B, all at their highest thinking effort and, it says, in the same harnesses:
| Benchmark (lab-reported) | Nanbeige 4.3 33B | Qwen3.8 27B |
|---|---|---|
| Terminal-Bench 2.1 | 80.9 | 73.0 |
| DeepSWE | 65.5 | 42.5 |
| SWE-Bench Pro | 60.3 | 61.7 |
| Automation Bench | 54.2 | 38.3 |
| GDPval | 84.8 | 86.4 |
| Tau3-Bench | 48.8 | 48.5 |
| GPQA Diamond | 89.5 | 89.2 |
The wins are large on agent harnesses the lab ran itself (DeepSWE, Automation Bench, its job and planning suites) and small or absent on the two most widely watched tests: Qwen leads on SWE-Bench Pro and GDPval, and Gemma4-31B leads on GPQA Diamond at 91.3. Some scores rely on judges and harness settings the card spells out in footnotes, such as GPT-6 Sol grading SWE-Atlas answers. These are the creator's numbers; no independent leaderboard had reproduced them when we wrote this.
The research behind it
There is no technical report for 4.3 33B; the card asks people to cite the Hugging Face page. The lab's published work explains its approach. The Nanbeige4-3B technical report (Yang et al., 2025) describes pre-training on 23 trillion tokens with a staged data schedule and a "Dual Preference Distillation" step from a larger reasoning model. The Nanbeige4.2-3B report (2026) adds reinforcement learning on agent tasks with rewards for both outcomes and intermediate steps, across a wide range of executable environments. Treat those as the lab's recipe, not as proof of what was done for 4.3 33B.
The part that matters to a local runner is in the config file, and it is deliberately ordinary. Nanbeige 4.3 33B is a standard Llama-architecture transformer: 52 layers, every one using full attention, with grouped-query attention (Ainslie et al., 2023) sharing 8 key-value heads among 56 query heads. The upside is that llama.cpp, Ollama, LM Studio and MLX all load it today with no patches, unlike Kolibri last month. The downside is the KV cache.
The memory catch: context is expensive
With full attention in all 52 layers, every token of context stores keys and values for every layer. From the published shape, that is about 208KB per token at 16-bit precision (our arithmetic: 2 × 52 layers × 8 KV heads × 128 dimensions × 2 bytes):
| Context | KV cache at 16-bit | At q8_0 |
|---|---|---|
| 8K tokens | 1.7GB | 0.9GB |
| 32K tokens | 7.0GB | 3.5GB |
| 128K tokens | 27.9GB | 14.0GB |
| 512K (the maximum) | 111.7GB | 55.8GB |
Compare Qwen3.8 27B, where 48 of 64 layers use linear attention whose state does not grow with context. Its Q4_K_M file is also smaller, 16.5GB against 20.8GB here. On a 24GB card, that difference decides how much of a coding session you can keep in view. One commenter in the model's "Don't waste your time" thread blamed much of the negative feedback on exactly this: "insufficient memory for context, after barely fitting the model weights into VRAM." The KV cache explainer covers the mechanics.
The quant ladder
| File (bartowski GGUF) | Size | Room on a 24GB card |
|---|---|---|
| Q8_0 | 35.2GB | Needs 48GB |
| Q6_K | 29.0GB | Needs 32GB+ |
| Q5_K_M | 25.1GB | Does not fit |
| Q4_K_M | 20.8GB | About 10K tokens at 16-bit, 20K at q8_0 |
| IQ4_XS | 18.6GB | About 20K at 16-bit, 40K at q8_0 |
| IQ3_XXS | 14.5GB | Long context, at a quality cost |
Sizes are from bartowski's repository; the context column is our estimate after about 1GB of runtime overhead. The most thorough 24GB recipe we found is HyperNanbeige-33B, a mixed-precision GGUF at 3.82 bits per weight (16.7GiB) that fits a 57,344-token q8_0 cache on one RTX 3090. Its author makes two practical points worth copying for any llama.cpp setup: use matching cache types (-ctk q8_0 -ctv q8_0), because mixed types fall back to a slower path and halved prefill speed in his test, and stop llama-server re-inserting old reasoning blocks into every agent turn, which he says added more than 30,000 tokens over a ten-step session. See the quantization guide for the formats.
What it runs on
Dense models read every weight for every token, so speed tracks memory bandwidth (the bandwidth explainer covers why). Measured numbers so far are from 24GB cards:
- RTX 3090, 3.82 bits per weight: 31–34 tok/s for reasoning text, 45–87 tok/s for code and JSON with n-gram speculative decoding, and 900–1,115 tok/s prompt processing (HyperNanbeige's benchmarks).
- RTX 3090, IQ3_XXS: about 35 tok/s in llama.cpp (ahtx's page).
From those, by the bandwidth arithmetic for the 20.8GB Q4_K_M:
| Machine | Fits | Ceiling at Q4_K_M |
|---|---|---|
| Used RTX 3090 / RTX 4090 (24GB) | Q4 with short context; IQ4 or 3.8-bit for agents | About 45–48 tok/s |
| RTX 5090 (32GB) | Q4_K_M with about 50K tokens at q8_0 | About 86 tok/s |
| Mac with 64GB, Max-class chip | Q6_K or Q8_0 with long context | About 26 tok/s at Q4 |
| Mac mini M4 Pro or DGX Spark | Fits easily | About 13 tok/s |
| 128GB Strix Halo box | Q8_0 with 100K+ context | About 12 tok/s |
Real runs land at roughly 60–75% of these ceilings. The slow unified-memory boxes are usable for chat but painful for agent loops that think for thousands of tokens. A smoke test of a community MLX 4-bit build on an M4 Pro with 48GB passed chat, streaming and structured tool calls, but did not report speeds. Check your machine in Can I Run It.
What owners report
The most useful independent test so far is from shoo99, who ran a Korean document question-answering benchmark (Q4_K_S, Ollama, RTX 3090) with the same retrieved pages for each model and two judges from different model families. At each model card's recommended settings, Qwen3.8 27B scored 77.9% with thinking on against Nanbeige's 70.6–71.2%. The tester notes Korean is outside the languages the card lists, so this is not a verdict on the lab's English and Chinese benchmarks, but it is the cleanest like-for-like comparison published. Also from that thread: Nanbeige ran away more often at higher temperature, hitting a 20K-token cap about 10 times against about 3 at temperature 0.
The critical threads are loud. In "Benchmaxxed", a user complained it lacked basic knowledge, citing a common microphone module; a lab member replied that the base model answered correctly and the chat model did with web search, adding: "Agentic capabilities were a major focus of this release, but we recognize that the model should also handle factual questions better without search." Another owner, on an RTX Pro 6000 with vLLM, reported in "Don't waste your time with this model" that it thought for 30 minutes and coded for 40 to produce a broken HTML Tetris game, where Qwen3.8-Flash-Next produced a working one in two minutes. The lab pointed to the model being text-only. Defenders in both threads argued that a 33B model should look facts up rather than store them, which is a fair description of how the lab built it.
Two setup problems are worth knowing before judging it yourself. A community quantizer reported several errors in the chat template, including stray line breaks that can affect generation and tool calls; as of this writing, the official repository's template has not been updated since release, so check which template your GGUF embeds. And one vLLM user saw raw byte tokens such as <0x0A> in responses, a sign of a tokenizer mismatch in that version. The card's own advice also matters: set preserve_thinking on for agent work and off for chat.
Verdict: worth downloading?
If you run agents and tool calls on a machine with 32GB or more of fast memory (an RTX 5090, a 64GB Max-class Mac or a 48GB setup), yes, it is worth a side-by-side test against Qwen3.8 27B on your own tasks, with the template fixed and the card's sampling settings. The lab's agent-harness numbers are strong, and the plain Llama architecture means it runs everywhere with no patches. On a single 24GB card, Qwen3.8 27B remains our default: it is smaller, its mostly linear attention leaves far more room for context, and the only independent comparison published so far favours it. If you want a model that knows things without a search tool, look elsewhere. Pick your file in the Quant Picker.
Sources and how we researched this
Creator documents: the Nanbeige 4.3 33B model card and config. Research: Yang et al., Nanbeige4-3B Technical Report (2025); Nanbeige Lab, Nanbeige4.2-3B: Unlocking Agentic Capabilities in a Compact Model (2026); Ainslie et al., GQA (2023). Quantizations and measurements: bartowski GGUF, HyperNanbeige-33B, ahtx IQ3_XXS. Owner reports: the model's Hugging Face discussions, including threads 22, 31, 32, 34 and 36. KV-cache sizes, context estimates and speed ceilings are our arithmetic from the published architecture and file sizes, not measurements. We have not run the model; the site is non-commercial.
Related: Qwen3.8-Flash-Next · MLX vs llama.cpp on a Mac · Which Mac for local LLMs
