Oct 26, 2026

Nanbeige4.3-33B for Local AI: A 33B Dense Agent Model Claims the Terminal-Bench Crown — Here's the GPU Math (2026)

By RunAIHome Team · 13 min read

local-llmgpuagentic-aicoding-llmbuying-guide

TL;DR: Nanbeige4.3-33B landed on Hugging Face October 24 under Apache 2.0: a 33B dense agent model with 512K context that claims to beat Qwen3.8-27B on Terminal-Bench (80.9 vs 73.0) and DeepSWE (65.5 vs 42.5). Every number is self-reported, there’s no official GGUF yet, and dense 33B means roughly 20GB of weights read per token — a 24GB card fits it with almost no context room.

	Nanbeige4.3-33B	Qwen3.8-27B	Gemma 4 31B
Best for	Terminal/automation agent work (vendor claim)	Proven all-rounder, best SWE-Bench Pro	Knowledge and reasoning (GPQA 91.3)
Q4 weights	~20GB (estimated — no official GGUF yet)	~17GB (measured)	~18GB QAT (measured)
The catch	Day-2 model: vendor-only benchmarks, community quants unproven	Loses to Nanbeige on 5 of 7 vendor agentic benches	Not an agent specialist

Honest take: Don’t buy anything for this model yet, and don’t replace Qwen3.8-27B as your daily driver this week. If the Terminal-Bench and DeepSWE numbers survive independent runs, Nanbeige4.3-33B becomes the strongest agent model that fits a 24GB card — but today it’s a BF16 release with a 4-GPU serving recipe, early community quants that at least one tester found broken, and zero independent benchmarks. The hardware answer doesn’t change either way: a used RTX 3090 if you own nothing, a 32GB R9700 if you want weights and context on one card.

Nanbeige Lab is the model team at BOSS Zhipin, the Chinese recruiting platform, and until this weekend it was known for shipping surprisingly strong small models — the 3B-class Nanbeige4.1 and 4.2 that kept showing up near the top of agent benchmarks nobody expected a 3B to crack. On October 24, 2026 the lab released its first big one: Nanbeige4.3-33B, a 33-billion-parameter dense model (plus a separate Base checkpoint) under Apache 2.0, with a 524,288-token context window and benchmark claims aimed squarely at Qwen3.8-27B and Gemma 4 31B — the two models that currently own the 24GB card.

The r/LocalLLaMA thread cleared 126 points within hours. Here’s what the release actually contains, which claims to trust, and what it takes to run a 33B dense model at home in the most expensive GPU market this site has ever tracked.

What shipped, exactly

Four things are confirmed across the release coverage:

Weights: Nanbeige4.3-33B (instruct/agent tuned) and Nanbeige4.3-33B-Base, both BF16, roughly 66GB on disk. License is Apache 2.0 — no revenue caps, no research-only clauses, unlike the LFM or GLM license games we’ve covered this fall.
Architecture: 33B dense, not a mixture-of-experts. The 512K (524,288-token) context window is the headline spec.
Serving recipe: the model card’s own vLLM and SGLang examples use 4-way tensor parallelism — this is shipped as a server model. There is no official GGUF, no official quantization, and no Ollama tag as of October 26.
Positioning: the card’s benchmark table targets agentic coding and computer-use tasks, not chat.

That last point matters for who should care. Like NVIDIA’s Nemotron 3.5 Bolt 74B, this is a model built to drive tools, terminals, and multi-step workflows — the fastest-growing segment of local AI this year, because agent work is exactly where API bills explode.

The benchmark claims — and the asterisk on every one

All numbers below are from Nanbeige’s own model card, as reported by MarkTechPost and Startup Fortune. No independent reproduction exists yet; treat them as the vendor’s opening bid.

Benchmark	Nanbeige4.3-33B	Qwen3.8-27B	Who wins
Terminal-Bench 2.1	80.9	73.0	Nanbeige
DeepSWE	65.5	42.5	Nanbeige, by a mile
SWE-Bench Pro	60.3	61.7	Qwen
AutomationBench	54.2	38.3	Nanbeige
JobBench	44.8	34.5	Nanbeige
AIME 2026	95.2	94.5	Nanbeige, barely
GPQA Diamond	89.5	— (Gemma 4 31B: 91.3)	Gemma

Two honest readings of this table:

The bullish one: the agentic gaps are too large to be pure benchmark tuning. A 23-point DeepSWE lead and a 16-point AutomationBench lead over Qwen3.8-27B — from the lab whose 3B models already punched above their weight on agent tasks — suggests a real post-training specialty, not noise.

The skeptical one: the vendor chose which benchmarks to publish, and the two most scrutinized numbers in the table go the other way — Qwen3.8-27B still wins SWE-Bench Pro, and Gemma 4 31B still wins GPQA. Early Reddit reaction matched this split: commenters with prior Nanbeige experience expected the results to hold “mostly true” while warning the models can be fragile and prone to doom-looping in long agent runs. And the only hands-on report we found — a user running a day-one community GGUF quant — got visibly bad output on a standard creative-coding prompt. That could be the model; it could just as easily be a broken early quant or a wrong chat template. Day-2 quants fail this way constantly.

The pattern we’ve seen all October — with Recursive Flint 40B and Nemotron Bolt — is that vendor agent benchmarks mostly survive independent testing directionally but shrink by several points. If that holds, Nanbeige4.3-33B ends up the best terminal-agent model in the 24GB class without dethroning Qwen as the all-rounder.

The VRAM math: dense 33B is the expensive kind of 33B

The spec that defines this model’s hardware story isn’t the 33B — it’s the word dense. A sparse MoE like LFM2.5-24B-A2B holds 24B parameters but reads only ~2.5B per token. A dense 33B reads all 33 billion, every token. That sets both the VRAM floor and the speed ceiling.

No official GGUF exists, so quantized sizes below are estimates derived from measured same-class models (Qwen3.8-27B Q4_K_M = ~17GB → ~0.62 GB per billion params; Gemma 4 31B ≈ 18GB):

Format	Size	Fits on
BF16 (official)	~66GB	96GB RTX PRO 6000, 4× 24GB server, 128GB unified memory
Q8_0 (est.)	~35GB	48GB (dual 3090), 64GB+ unified memory
Q4_K_M (est.)	~20–21GB	24GB cards — weights only, context tight
Q3/Q2 (est.)	~13–17GB	16GB cards, with the usual quality tax

The uncomfortable row is the third one. A Q4 of this model fits a 24GB card the way 42GB fits a 48GB pool: technically. With ~20.5GB of weights resident, an RTX 3090 or 4090 has roughly 3GB left for KV cache and compute buffers. On a model whose entire reason to exist is long agentic sessions — the 512K context window — that’s an 8K–16K working context in practice, with KV-cache quantization doing the heavy lifting. The 512K number is real, but it’s a 4-GPU-server feature, not a consumer-card feature. Run your own model/context combination through the VRAM calculator before deciding anything.

The card this release quietly argues for is the 32GB AMD Radeon AI PRO R9700 — ~20.5GB of weights plus ~11GB of context room on a single card, at $1,400–$1,900 street (our full R9700 review). The catch: nobody has confirmed this architecture runs cleanly on ROCm/Vulkan yet, because nobody has confirmed anything about the GGUF path yet (see the troubleshooting section).

How fast it will be: the bandwidth ceiling, computed

Decode speed on dense models is memory-bandwidth-bound. The ceiling is bandwidth divided by bytes read per token (~20.5GB at Q4_K_M); real-world results land at 70–95% of it. No independent tok/s numbers exist for this model yet, so the table below is the physics, not a measurement — we’ll update when real benchmarks land:

Hardware	Bandwidth	Ceiling	Expected (est.)
RTX 3090 24GB	936 GB/s	~46 tok/s	32–43 tok/s
RTX 4090 24GB	1,008 GB/s	~49 tok/s	34–46 tok/s
RTX 5090 32GB	1,792 GB/s	~87 tok/s	61–83 tok/s
R9700 32GB	640 GB/s	~31 tok/s	22–30 tok/s
M5 Max (Mac)	614 GB/s	~30 tok/s	21–28 tok/s
Strix Halo	256 GB/s	~12.5 tok/s	9–12 tok/s

A useful sanity anchor: Qwen3.8-27B (17GB at Q4) measures 41 tok/s on an RTX 3090 — 74% of its 55 tok/s ceiling. Apply the same efficiency here and a 3090 should decode Nanbeige4.3-33B at roughly 34 tok/s. That’s comfortably usable for agent work (agents are bottlenecked by tool execution as often as generation), but it is the price of dense: LFM2.5-24B-A2B, nominally a “24B,” decodes 4–5× faster on the same silicon because it only reads its active experts.

If any site publishes a number above these ceilings, the number is wrong — that’s not a judgment call, it’s arithmetic.

What to actually buy

Prices as of October 2026, from this site’s verified price index (used-GPU prices re-verified October 20; the R9700 September 14; the 5090 September 21):

Your situation	The move	Price	Where
Already own a 24GB card	Nothing — wait for official/major-shop GGUFs, then download	$0	—
Want weights + real context on one card	Radeon AI PRO R9700 32GB	$1,400–$1,900	Check price
Want CUDA and the best used-market value	Used RTX 3090 24GB	$1,456–$1,558	Check price
Running long agent sessions at Q8	2× used RTX 3090 (48GB)	~$2,912–$3,116	Check price
Want to test the model before spending anything	Rented 3090/4090 on Vast.ai	from $0.07/hr	Vast.ai

The rent row is the honest first step this week: a rented 3090 at Vast.ai’s floor price runs the model’s official BF16 on a multi-GPU instance or an early quant for under a dollar of testing, and tells you whether the agent behavior is real before you commit $1,500 to it. The dual-3090 route is covered in depth in our dual-3090 vs used-4090 comparison — at Q8 (~35GB) it’s the cheapest way to run this model without quality anxiety about early Q4 quants.

What you should not buy for this model: a 16GB card. The estimated Q4 weights alone exceed 16GB, and the 16GB tier already has better-fitting options.

The day-2 trap: community quants and how to not get burned

The one reproducible problem with this release so far isn’t the model — it’s the quant ecosystem lag. The failure mode, reported within 24 hours of release:

Problem: you download a day-one community GGUF, run it in llama.cpp or LM Studio, and the output is noticeably worse than the benchmarks suggest — rambling, broken code, or doom-looping in agent runs.

Why it happens: early community conversions regularly ship with wrong chat templates, missing special tokens for the model’s agent/tool-call format, or conversion bugs that don’t surface until the architecture is properly supported upstream. An agent-tuned model is especially sensitive to this, because its tool-calling format is exactly the part a generic template breaks. We watched the same cycle with Qwen3.8-27B in August and Flint 40B last week.

The fix: wait for one of three signals before judging the model — (1) an official GGUF from the Nanbeige HF org, (2) quants from the established shops (Unsloth, Bartowski, mradermacher) that explicitly note the chat template, or (3) a llama.cpp release note confirming the architecture. Until then, the only faithful way to run it is the official BF16/FP8 path via vLLM — which, with a 4-way tensor-parallel recipe, means rented cloud GPUs for almost everyone. If you must try an early quant, compare its output on an identical prompt against the official BF16 weights on a rented instance before concluding anything about the model.

This is also the honest caveat on the R9700 recommendation above: until GGUF support is confirmed, the AMD path is unverified. The 3090’s advantage this week isn’t bandwidth — it’s that CUDA + vLLM runs the official weights today.

Where it fits in the late-2026 local stack

Our October open-source LLM rankings had a clear shape: Qwen3.8-27B as the 24GB all-rounder, Gemma 4 31B for knowledge, small MoEs for speed. Nanbeige4.3-33B doesn’t try to beat that lineup at its own game — it’s a bet that agent specialization is worth a dedicated slot, the same bet NVIDIA made with the Bolt family.

If you’re building a local coding-agent stack around it, pair the model with an editor-side harness — Continue.dev with a local backend is the setup we recommend — and keep a general model loaded for everything that isn’t tool-driving. On a 24GB card you won’t fit both at once; that’s the concrete argument for 32GB+ in 2026, and it’s the same conclusion our 32GB VRAM guide reached from the other direction.

FAQ

Is Nanbeige4.3-33B really open source? The weights are Apache 2.0 — genuinely permissive, commercial use included, for both the instruct and Base checkpoints. Training data and full recipes are not open, which is standard for 2026 releases.

Can I run it on a 16GB GPU? Not at Q4 — estimated weights are ~20–21GB. A Q3/Q2 quant would technically fit, but on an agent model the quality loss shows up as broken tool calls, which defeats the purpose. 24GB is the practical floor; 32GB is the comfortable one.

Will it run in Ollama? Not as of October 26, 2026 — no official GGUF or Ollama tag exists. Check the Nanbeige HF org before downloading third-party conversions; see the day-2 trap section above.

Is it better than Qwen3.8-27B? On the vendor’s own table: better at terminal/automation agent tasks (Terminal-Bench 80.9 vs 73.0, DeepSWE 65.5 vs 42.5), slightly worse at SWE-Bench Pro (60.3 vs 61.7). No independent numbers exist yet. If you’re happy with Qwen, there is no reason to switch this week.

What about the 512K context? Real, but a server feature. At Q4 on a 24GB card you have ~3GB left after weights — expect 8K–16K of usable context with a quantized KV cache. Long-context agent sessions on this model mean 48GB+ local or rented multi-GPU.

Sources

Last updated October 26, 2026. Benchmark figures are vendor-reported and unverified; quantized sizes and tok/s figures marked as estimates are derived from the bandwidth math explained above. Prices change weekly — verify before purchasing.

Recommended Gear

Products linked in this article, with prices as of October 2026:

Used RTX 3090 24GB — $1,456–$1,558, the CUDA floor for this model
AMD Radeon AI PRO R9700 32GB — $1,400–$1,900, weights + context on one card (pending GGUF/ROCm confirmation)

Was this article helpful?

Get the numbers before you buy

New GPU and mini-PC benchmarks, VRAM thresholds, and price checks — sent when there's something worth acting on, not on a schedule. No spam, unsubscribe anytime.