Nanbeige4.3-33B Review: Benchmarks & Hardware Needs

Nanbeige4.3-33B is a dense text model positioned as the “flagship teacher model” of the Nanbeige4.3 series. The phrase matters. The lab is not primarily selling a 33B model to be run everywhere; it is publishing a strong agentic model that smaller students (a Nanbeige4.3-3B is expected) can be distilled from. That is the same playbook that made small open models competitive over the past two years, and it explains why the release leans so heavily on agent benchmarks rather than chat polish.

On the numbers the lab chose to publish, the model wins 18 of 20 head-to-head tests against Qwen3.8-27B, the strongest open 27B-class rival, and wins far more decisively against Muse-Glimmer-30B and Google's Gemma4-31B. The widest gaps are in long-horizon agentic coding. On pure reasoning (GPQA Diamond, AIME 2026) the four models are bunched within a few points, and Gemma4-31B actually leads GPQA Diamond.

• Best for: teams that want a self-hosted agent model for coding, terminal work and office automation under a permissive licence.
• Headline numbers: 33B parameters, 512K context, Apache 2.0, 80.9 on Terminal-Bench 2.1, 65.5 on DeepSWE.
• Defining trait: a large lead on long-horizon agent tasks over similarly sized open models, with reasoning roughly level.
• Main caveat: self-reported results, lab-chosen harnesses, no technical report and no published safety evaluation.

Nanbeige is the LLM research group at BOSS Zhipin (Kanzhun), the Chinese recruitment platform; the model card lists a Kanzhun address for contact. Coverage describes a team of roughly 19 people, which is tiny next to the labs behind Kimi K3.1 Pro, DeepSeek V4 or Z.ai's GLM-5.3-Flash. Their earlier work was small: a 3B-class Nanbeige4 in December 2025, Nanbeige4.1-3B in March 2026 and Nanbeige4.2-3B in late summer. According to secondary coverage, Nanbeige4.3-33B is the first 33B-class model in the family.

That history is useful context. A group that spent a year squeezing capability out of 3B models has strong incentives to build a large teacher and distil downwards, and a recruitment company has an obvious interest in models that can do professional tasks, which is exactly what the JobBench and GDPval-style evaluations in this release measure. It is also a reminder that frontier-adjacent open weights no longer come only from the best-known labs.

The release itself is two repositories on Hugging Face: the post-trained model (Nanbeige4.3-33B) and the pre-post-training Nanbeige4.3-33B-Base checkpoint for anyone who wants to run their own post-training. At the time of the model-card snapshot used for this review, the page showed 783 likes, about 9,600 downloads in the previous month and dozens of community quantisations, which is healthy traction for a team of this size.

What is public is thin. The model card lists a dense text-generation model of about 33 billion parameters in BF16 safetensors, tagged with the llama architecture family, a maximum context length of 524,288 tokens, English and Chinese language support and the Apache 2.0 licence. It does not describe the training data, the reinforcement-learning recipe or the compute used, and there is no linked technical report. Anything beyond the card, including how the model was trained, should be treated as unknown.

What the card does reveal is how the model is meant to be used. Reasoning is on by default through an enable_thinking flag that can be switched off. A second flag, preserve_thinking, keeps earlier reasoning in multi-turn conversations; the lab recommends leaving it off for general chat and turning it on for tool use, office work and code agents. Tools are enabled by passing a tools list, with xml the recommended call format and json also supported. The lab's own evaluation was run with preserve_thinking=true, which is worth remembering when you compare the results with models tested without it.

The teacher framing deserves a sentence of scepticism and a sentence of credit. The scepticism: a teacher model is only valuable if the students it produces are good, and no Nanbeige4.3-3B exists yet to judge. The credit: publishing the teacher with a permissive licence lets anyone else run the same distillation recipe on their own data, which is a more generous release than many labs offer.

Agentic coding

The card groups eight benchmarks under agentic coding: Terminal-Bench 2.1, Terminal-Bench 4.0, DeepSWE, SWE-Bench Pro, SWE-Atlas-QnA, NL2Repo, Scicode and SkillsBench. These are not one-shot code-completion tests. They put the model in a loop with a shell or repository, let it run commands and edit files, and score the end result. A 512K context window matters here because real repositories, long logs and multi-hour agent histories fill context quickly, and the model is expected to keep its thread across them.

Agentic co-working

The second group is office-style work: Automation Bench, JobBench, GDPval, Claw-Eval, Toolathlon-Verified, DeepPlanning, EnterpriseOps-Gym, YC-bench and Tau3-Bench. This is the area where a recruitment-platform lab has natural domain interest. These tasks involve calling tools, following multi-step business procedures, planning and recovering from errors, and they are a better proxy for “can this model run my back-office automation” than any reasoning exam.

Reasoning and long context

Reasoning is covered by GPQA Diamond, AIME 2026 and AA-LCR (a long-context reasoning benchmark). The model is strong here but not dominant, which is the honest reading of the table below. If your workload is mathematics or graduate-level science question answering, a 33B open model is unlikely to be the deciding factor; if it is long-running tool use, it might be.

Serving and tool support

Practical support is good for a fresh release. The card gives Transformers code, SGLang and vLLM launch commands (using the qwen3 reasoning parser and qwen3_coder tool-call parser) and notes quantised builds that run in llama.cpp, Ollama and LM Studio. If you already serve Qwen-family models, the existing parsers carry over, which lowers the cost of trying it side by side. See our Hermes Agent explainer for one way to put a self-hosted model like this behind an agent harness.

The figure below is the lab's own eight-panel chart from the model card, comparing Nanbeige4.3-33B with Qwen3.8-27B, Muse-Glimmer-30B and Gemma4-31B on a subset of the agentic tests. It is the same image used as this article's cover, so here is the underlying table with every row the card publishes. All models were evaluated at their highest thinking effort.

Table: selected rows from the Nanbeige4.3-33B Hugging Face model card (self-reported). Some rows are omitted for length; the card also reports NL2Repo, Scicode, EnterpriseOps-Gym, YC-bench and Tau3-Bench, where Nanbeige4.3-33B is again ahead. Secondary write-ups of the card disagree slightly on a couple of the Muse-Glimmer and Gemma cells, so check the original page if a specific cell matters to you.

Reading the table honestly

Three patterns stand out. First, the Terminal-Bench 4.0 and DeepSWE gaps are enormous: 23.8 against 6.3 and 65.5 against 42.5 for Qwen3.8-27B, and near-zero for the other two. When a gap is that large on a harder test, it usually signals a difference in long-horizon behaviour rather than raw knowledge. Second, the model does not win everything: Qwen3.8-27B leads SWE-Bench Pro (61.7 against 60.3) and GDPval (86.4 against 84.8), and Gemma4-31B leads GPQA Diamond (91.3 against 89.5). Third, on reasoning the four models sit close together, so the story is agentic execution, not intelligence in the abstract.

The card also lists the evaluation set-up, and it is where independent scrutiny will focus. Terminal-Bench 2.1 used the Terminus 2 harness; Terminal-Bench 4.0 and DeepSWE used mini-swe-agent v2.4.6; NL2Repo and JobBench ran through Claude Code (JobBench with a search tool); SWE-Atlas-QnA used 1,304 rubrics judged by GPT-6 Sol; GDPval used revised rubrics; Claw-Eval used only its 157-task General subset; Toolathlon-Verified had no max_tokens limit; and YC-bench kept only the last 10 user turns of context. Each of these is a choice, and each can move a score by several points. The lab states that hyperparameters and harnesses were kept the same across models for each test, but the cover chart and the table remain vendor numbers until someone reproduces them.

Coverage of the release also notes that many of the individual leads on easier tests are under a point, which is within the run-to-run noise of agent benchmarks. The Terminal-Bench 4.0, DeepSWE, Automation Bench and DeepPlanning gaps are the ones that look structural.

The second chart in the model card is a heatmap of JobBench scores across 35 occupations, grouped into software and IT, engineering, finance, healthcare, legal and public services, commerce and operations, research and education, and content and administration. Overall scores are 44.80 for Nanbeige4.3-33B, 34.51 for Qwen3.8-27B and 16.60 for Muse-Glimmer-30B, where each cell is the mean task score within an occupation on a 0 to 100 scale.

The heatmap is more informative than the single headline number. Nanbeige4.3-33B's strongest cells include web administrators (72.0, against 36.0 for Qwen3.8-27B), technical writers (72.1 against 53.7), producers (72.2 against 69.4), online merchants (68.5 against 46.9) and social science research assistants (65.3). It also posts big margins for lawyers (50.0 against 25.0) and emergency dispatchers (57.4 against 29.8), although the underlying task counts per occupation are small, so single cells should not be over-read.

The weaknesses are just as visible. Qwen3.8-27B is ahead for healthcare managers (45.3 against 27.8), secretaries and administrative assistants (47.5 against 28.8), customer service representatives (31.6 against 21.1), personal financial advisors (20.5 against 10.3), technical product sales and data entry keyers. The card's own wording is that Nanbeige4.3-33B outperforms the baseline in most of the 35 occupations, which the chart supports: most, not all. If your use case is patient-facing, front-office or data-entry heavy, test the two head to head rather than assuming the overall score transfers.

There is no system card. The Hugging Face page does not describe a safety evaluation, red-teaming, refusal behaviour, cyber or biological risk testing, or any alignment work, and the training details section is empty. That is common for open-weight releases from smaller labs, but it matters more for this model than for a chat-only one, because it is explicitly built to run commands, call tools and edit systems autonomously.

Compare this with the disclosure we have seen from closed frontier labs, for instance the cyber and prompt-injection data published for Gemini 4 Carbon, or the safety-hardening delay Z.ai applied to its flagship before releasing open weights (covered in our GLM-5.3-Flash review). With Nanbeige4.3-33B you should assume you are responsible for your own guardrails: run agents in sandboxes, restrict credentials, log tool calls, and treat any web content the agent reads as untrusted input.

Two further points. The model supports only English and Chinese on paper, so safety behaviour in other languages is untested. And because the weights are Apache 2.0, anyone can fine-tune away whatever safeguards exist; the 3 finetunes of the base checkpoint and 9 finetunes of the chat model already visible on Hugging Face at the time of the snapshot show that is happening.

At the time of writing there is almost no independent evidence. The release is days old, third-party evaluations are still in progress, and the lab did not publish transcripts of agent runs. The only fair conclusion is that the benchmark story is plausible and unconfirmed.

Plausible, because the pattern (large agentic gaps, near-parity on reasoning) is what you would expect from a model post-trained heavily on agent trajectories with preserve_thinking style long-horizon reasoning. Unconfirmed, because agent benchmarks are notoriously sensitive to harness, prompt and scaffold, and the harnesses here were chosen by the lab. The more careful way to use this release is as a candidate to add to your own evaluation set, not as a replacement decision.

A practical test plan: take ten to twenty real tasks from your own repositories or processes, run them with the lab's recommended settings (temperature 1.0, top_p 0.95 and up to 65,536 new tokens for agentic work; temperature 0.6 and up to 262,144 for reasoning and chat), and compare pass rates and cost per completed task against Qwen3.8-27B and whatever you use today. Watch for failure modes on long contexts, since a 512K window is only useful if retrieval quality holds across it.

Access is self-hosted. There is no official hosted API, no published per-token price and, at the time of the snapshot, no Hugging Face Inference Providers support. That makes the cost question one about your own compute rather than a rate card.

• Weights: roughly 66.3GB in BF16, per the Hugging Face file listing.
• Single 80GB GPU: it fits, but with little headroom once you allocate the KV cache, particularly at long context. Treat it as marginal.
• Multi-GPU serving: the SGLang and vLLM examples use tensor parallelism of 4 with around 0.8 GPU memory utilisation.
• Quantised: four-bit builds reduce the weights to around 20GB plus cache, and GGUF versions are available for llama.cpp, Ollama and LM Studio, so a well-specified workstation can run it at reduced quality and speed.
• Licence: Apache 2.0 allows commercial use, modification and redistribution subject to attribution and notice terms. No performance or output guarantees come with it.

For a UK team, the decision is a classic build-versus-buy. Renting four data-centre GPUs for always-on agent serving will cost far more per month than a frontier model API for modest volumes, but becomes attractive when you have steady high-volume workloads, data-residency or confidentiality requirements, or want to fine-tune. Our AI API pricing comparison is a useful baseline for the buy side of that calculation.

• Self-reported results. Nothing has been independently reproduced yet; third-party measurements such as MathBench are said to be under way.
• Lab-chosen harnesses. Several tests use scaffolds and rubrics selected, and in some cases revised, by the authors.
• No technical report or system card. Training data, recipe and safety work are undocumented.
• Two languages. English and Chinese only; no claims for anything else.
• Heavy to host. Roughly 66GB of weights, so you need real GPU capacity for full quality.
• Mixed occupational results. Qwen3.8-27B is ahead in several front-office and healthcare-management cells on JobBench.
• Teacher, not product. The lab frames it as a base for distillation; the smaller models most teams will actually want to deploy do not exist yet.

Against Qwen3.8-27B. The closest rival and the one the lab targets. Qwen3.8-27B is a smaller model with a vision component, discussed in our Qwen3.8 27B article, and it still wins SWE-Bench Pro and GDPval. Nanbeige4.3-33B wins the long-horizon terminal and repository tests by wide margins. If you need vision, Qwen remains the safer choice on the card; if you need terminal agents, test Nanbeige first.

Against Gemma4-31B. Google's open model leads GPQA Diamond (91.3) but trails badly on agentic tasks in this table. Gemma4 is a strong general model; the card suggests it was not tuned for long-horizon agent work in the way Nanbeige4.3 was.

Against larger open models. The card does not compare with big mixture-of-experts models such as DeepSeek V4, Kimi K3.1 Pro, GLM-5.3 or Reflection Beam, which are far larger, and it would be misleading to infer parity from a table that excludes them. The relevant comparison is cost per task: a 33B dense model is much cheaper to serve than a several-hundred-billion-parameter MoE.

Against closed frontier models. No head-to-head with Claude Opus 5.5 or GPT-6 Astra is published, and the benchmarks that use different harnesses cannot be compared across vendors without care. Expect a gap at the very top end.

Try it now if you already self-host Qwen-family models and want a stronger agent for terminal, repository and automation work, if you want an Apache 2.0 base to distil into smaller in-house models, or if you handle sensitive code and cannot send it to a hosted API.

Wait if you need vision, wider language coverage, a documented safety posture or a managed API with an SLA, or if you only need a modest-volume assistant, where a hosted frontier model will be cheaper and better. The sensible move for most teams is to wait a week or two for independent evaluations and for the first Nanbeige4.3-3B student, then run your own bake-off.

Nanbeige4.3-33B is the most interesting open-weight agent model of its size class this week: a permissively licensed 33B model with a 512K context window and large published leads over Qwen3.8-27B on the hardest agentic tests. The leads on Terminal-Bench 4.0, DeepSWE and Automation Bench are big enough to take seriously.

But the evidence is a model card, not a verdict. The numbers are the lab's own, the harnesses are the lab's own, and there is no safety documentation at all. Put it on your shortlist, run your own tasks, sandbox anything it controls, and revisit once independent testing and the smaller students arrive.