Nanbeige 4.3 (33B): benchmarks, memory needs, and the catch

TL;DR

Nanbeige 4.3 is a free, Apache 2.0, 33-billion-parameter open model that beats Qwen3.8-27B on 18 of the 20 benchmarks its lab published, with the widest leads on agentic coding: 65.5 vs 42.5 on DeepSWE and 23.8 vs 6.3 on Terminal-Bench 4.0. It came out on Hugging Face on October 24, 2026, and Nanbeige calls it a "teacher": the real target is a distilled Nanbeige4.3-3B that hasn't shipped yet.

The catch is memory. It's a plain dense Llama-style model, so its context cache costs about 0.2 MB per token. At 128K context that's ~28 GB of cache on top of ~21 GB of 4-bit weights, which rules out most single consumer GPUs.

And if you're eyeing it for support work, read the fine print: on Nanbeige's own JobBench chart it scored 21.1 on customer service tasks against Qwen's 31.6. A support agent lives or dies on your helpdesk setup, not a coding score, which is why teams like smava run a ready-made AI helpdesk teammate on top of models like this rather than wiring one up themselves.

What is Nanbeige 4.3?

Nanbeige 4.3 is the fourth-and-a-bit generation of models from the Nanbeige LLM Lab, the AI team inside BOSS Zhipin, the Chinese recruiting platform run by Kanzhun Limited. The series has one public model so far, Nanbeige4.3-33B, plus its untuned base model. Both went up on October 24, 2026, and the lab announced it on X the next day, where the post picked up 2,248 likes.

I build integrations and APIs at eesel, so a new open model always gets the same first question from me: what would it take to actually run this behind a real product? That's the lens here.

The interesting part isn't the size. Nanbeige made its name with small language models: Nanbeige4.2-3B, a 3B "Looped Transformer" that reuses its layers to think harder per token (the same idea that got attention around GPT-6 Astra), has over 116,000 downloads in the last month. So why ship a 33B? The model card answers it directly: the strategy is "building a high-capacity teacher agent first," then distilling its skills into small models, which the launch post says will start "with Nanbeige4.3-3B."

In other words, the 33B is a step on the way. It's useful in its own right, but the model Nanbeige actually cares about is the 3B student.

The specs at a glance

Everything below comes from the model card and the config file in the repo.

One reply under the launch post saved a lot of people a download:

"33B dense, text only no vision in case it saves anyone time"

w (@WesWong3), X

How good is Nanbeige 4.3 on benchmarks?

Very good, on paper. Nanbeige compared it against three open models of similar size, all at their highest thinking effort, and published 20 scores. Nanbeige4.3-33B tops all three rivals on 17 of them and beats Qwen3.8-27B, its closest competitor, on 18. Here's the full table from the model card:

The coding numbers are the headline. Terminal-Bench 4.0 is a newer, much harder version of the command-line test, and Nanbeige scores 23.8 where the next-best model in its class gets 6.3. DeepSWE tells the same story: 65.5 against 42.5. If you run a terminal coding agent like Claude Code or OpenClaw against a local model, that's the gap you'd notice. My agentic coding CLI guide covers how those harnesses differ.

Three honest caveats before anyone screenshots that table:

1. They're the lab's own runs. Nanbeige used the same harness and settings for every model, which is fair, but no independent tester has repeated them yet. Artificial Analysis lists earlier Nanbeige models but not this one so far.
2. The harness matters. Terminal-Bench 2.1 ran on Terminus 2, DeepSWE on mini-swe-agent v2.4.6, NL2Repo inside Claude Code. Your agent setup will move these numbers.
3. The small print wobbles. The bar chart and the table disagree on two cells (Muse-Glimmer's JobBench is 18.3 in the chart and 16.6 in the table). Small, but worth knowing if you cite it.

Where does Nanbeige 4.3 fall behind?

Look past the coding rows and the lead narrows fast. Against Qwen3.8-27B specifically (a smaller sibling of Qwen3.8 Max), it trails on SWE-Bench Pro (60.3 vs 61.7) and GDPval (84.8 vs 86.4), and it's basically tied on Tau3-Bench, the benchmark that simulates an AI agent serving customers of an airline or a retailer (48.8 vs 48.5).

The detail I'd circle sits inside the JobBench chart, which breaks the score down across 35 occupations. Nanbeige wins most of them, and wins big for web administrators (72.0 vs 36.0) and technical writers (72.1 vs 53.7). But on customer service representative tasks it scores 21.1 to Qwen's 31.6, and it also loses on secretaries and administrative assistants (28.8 vs 47.5).

That lines up with what I see in support work. Being great at writing code in a terminal doesn't transfer automatically to answering a customer who's annoyed about a refund, which is also why an AI agent and a chatbot are not the same purchase. Support quality depends far more on what the model can look up than on the model itself. In my roundup of models for support tickets, the same model dropped 68 points on Sierra's Tau benchmark the moment the answer lived in documents instead of a tool.

Nanbeige ran Tau3-Bench with the official repository, but its score isn't on Sierra's public leaderboard, so don't stack it against the leaderboard numbers.

How much memory does Nanbeige 4.3 need?

This is the part the launch post skips. The weights are manageable: a community 4-bit GGUF from bartowski is 20.79 GB at Q4_K_M and 35.2 GB at Q8_0. The problem is the context.

Nanbeige4.3-33B is a classic dense transformer with grouped-query attention: 52 layers, 8 key-value heads of 128 dimensions each. Every token you keep in context costs 2 × 52 × 8 × 128 × 2 bytes, or 212,992 bytes per token at 16-bit. That's the number that decides your GPU, not the parameter count.

So the "512K context" headline is real, but using all of it means server hardware. Nanbeige's own serving examples for vLLM and SGLang set tensor parallelism to 4, meaning four GPUs.

Users noticed within a day. The most-discussed thread on the repo is a request to optimize the KV cache, where people point out that some rivals in this size class need several times less cache for the same context. It's a fair point against the model card's "cost-effective" line: at long context, a dense 33B is the opposite of cheap.

The upside of the plain design is compatibility. Because it's standard Llama architecture, at least 30 community conversions (GGUF, MLX for Apple Silicon, NVFP4, FP8) showed up on Hugging Face within two days, and it runs on stock vLLM and SGLang with Qwen's reasoning and tool-call parsers.

How do you run Nanbeige 4.3?

There's no hosted API from Nanbeige, and OpenRouter didn't list the model as of October 26, 2026. You download the weights and run them. The model card gives three paths:

1. Transformers for quick testing. Load Nanbeige/Nanbeige4.3-33B with trust_remote_code=True and device_map='auto'.
2. vLLM for serving. The card's example uses --tensor-parallel-size 4, --reasoning-parser qwen3 and --tool-call-parser qwen3_coder.
3. SGLang, with the same two parsers and --tp-size 4.

Two chat-template switches matter more than they look:

• enable_thinking is on by default. Turn it off for quick answers.
• preserve_thinking keeps reasoning from earlier turns. Nanbeige recommends True for tool use and coding agents and False for plain chat. Their benchmark scores were run with it on.

Recommended settings differ by job too: temperature 1.0 with up to 65,536 new tokens for agent and tool work, and temperature 0.6 with up to 262,144 new tokens for reasoning and chat.

If you're comparing local options, the other open models I've covered recently, like Gemma 4, Mistral Large 4 and DeepSeek V4 Flash, make different trade-offs between size, context cost and hosted access. My list of open-source AI agents covers the harnesses you'd plug any of them into, and the AI coding assistant roundup covers the hosted side. For API access instead of self-hosting, Kimi K3 and MiniMax 3 are the obvious places to look.

What's next for Nanbeige?

Nanbeige's team has been answering questions directly on the model's Hugging Face page, and three answers sketch the roadmap. Asked whether the 33B reuses the looped design from 4.2, a Nanbeige team member said no, and why:

"Based on our experiments, the Looped Transformer architecture offers a better quality–compute trade-off at smaller model sizes. Our upcoming small models, such as Nanbeige4.3-3B and Nanbeige4.5-3B will use the Looped Transformer architecture and deliver improved performance."

Ran Le, Nanbeige, Hugging Face

The same team member said a technical report will ship with Nanbeige4.3-3B, a DFlash2 speculative-decoding module is planned for faster generation, and FP8 weights are "coming soon." Back in September, the lab also said on X that Nanbeige4.5 was already training.

My read: if you run small agents on modest hardware, the release to wait for is Nanbeige4.3-3B, not this one. The 33B is the proof that the teacher is strong. Whether the 3B student keeps most of that coding edge, in a model that fits on a laptop, is the real question, and nobody can answer it until it ships.

Should you use Nanbeige 4.3?

It depends on what you're building, and the benchmark table already tells you most of it:

• Coding agents on your own hardware: yes, try it. The Terminal-Bench 4.0 and DeepSWE leads are large enough to survive some harness noise, and Apache 2.0 means no licence headaches. Budget for the KV cache, or cap context at 32K to 64K.
• Long-document work on one GPU: probably not. A 128K prompt needs about 49 GB with 4-bit weights.
• Fine-tuning your own agent: the Base model is a good starting point. Nanbeige reports it beating Gemma4-31B-Base on all eight base benchmarks it tested, including MMLU-Pro (66.9 vs 59.3).
• Customer support: not on these numbers. It loses to Qwen on customer service tasks and only ties on Tau3-Bench, and a model alone doesn't answer tickets anyway. My pick of the best AI agent for customer service looks at the whole setup instead.

Running AI on real support tickets, not benchmarks

That last point is where I spend my days. A model like Nanbeige4.3-33B is infrastructure. To answer a real ticket, something still has to sit in your helpdesk, read your macros and past tickets, know which customers belong to a human, and follow the rules about what it's never allowed to say. That's the job eesel's AI helpdesk teammate is built for, one of the ready-to-work AI teammates you hire for a specific role. It runs inside tools like Zendesk AI setups rather than replacing them, and the cost per ticket math is what usually settles the decision.

smava, a Berlin loan-comparison platform, shows what that looks like in practice. eesel handled about 27,000 Zendesk tickets in one month across smava and its sister brand Finanzcheck, categorising about 14,600 and preparing about 15,300 draft replies from roughly 820 macros and help center articles. Customers who already have a credit advisor get skipped, so they hear from their advisor, and eesel never sends the customer-ready replies itself: an agent approves each one. None of that shows up in a coding benchmark, and all of it decides whether the AI helps or hurts.

Before going live, eesel runs your setup against hundreds of your past tickets so you see its answers before a customer does, which tells you more than any benchmark a vendor quotes. I wrote up how that testing works separately. SamCart went the same way on Freshdesk, with one agent on email tickets and another on its website chat, both answering from about 280 help center articles. If you like to work from the terminal the way you would with a local model, the eesel CLI lets you, a script, or a coding agent like Claude Code connect integrations, edit the agent's standing instructions, approve or deny its pending actions, and read its activity log, all as JSON.

Try eesel

Nanbeige 4.3 is a strong open engine for coding agents. If what you actually need is an agent answering your support queue this week, eesel's AI helpdesk teammate joins your Zendesk, Freshdesk or Gorgias in minutes, learns from your past tickets and help center, and drafts or sends replies within the rules you set. It's free to start with 100 credits and no card, so you can test it on real tickets before you decide. Try eesel.