CanItRun Logocanitrun.

Nanbeige4.3 33B

Nanbeige4.3 33B needs roughly 24.5 GB VRAM at Q4_K_M quantization (76.1 GB at FP16). 70 GPUs we track can run it fully in VRAM at 8k context.

70 GPUs run this natively · 33 with CPU offload

Nanbeige33.1B params512k contextApache 2.0Commercial use ok
Q4_K_M total
24.5 GB
at 8k context
Smallest GPU
32 GB
NVIDIA RTX 5090, at Q4_K_M
KV cache, full context
111.7 GB
52 of 52 layers cache
Inputs
Text
Apache 2.0, released October 2026
Thinking mode
On by default
preserve_thinking keeps it across turns
Longest context, 32 GB
32,768 tokens
RTX 5090 at Q4_K_M

Nanbeige4.3 33B is a 33.1B parameter dense model developed by Nanbeige. Released on 24 October 2026 by the Nanbeige LLM Lab under the Apache 2.0 license (Hugging Face repo Nanbeige/Nanbeige4.3-33B). All 33.1B parameters run on every token, unlike a mixture of experts. The stack is a plain Llama-style one, 52 layers with 56 query heads sharing 8 KV heads, and it has no sliding window and no linear-attention layers, so every layer keeps a full KV cache across a 524,288-token window. It was post-trained from the Nanbeige4.3-33B-Base checkpoint for agentic coding and office-style "cowork" tasks, reasons before it answers (thinking is on by default and can be switched off), and calls tools in an XML or JSON format. It is text only and bilingual in English and Chinese. Nanbeige describes it as the teacher for the 4.3 series: the plan is to distill its agent skills into smaller models, starting with a Nanbeige4.3-3B that had not shipped when this page was written.

To run Nanbeige4.3 33B locally: The weights are the easy part and the context is the bill. Q4_K_M comes to 20.2 GB by this site's estimate, close to the 20.8 GB file in bartowski's GGUF repo, and 24.5 GB in total with an 8k context. That is just over what a 24 GB RTX 3090 or RTX 4090 can use, so those cards drop to Q3_K_M (15.9 GB of weights, 19.8 GB in total), which fits 16,384 tokens of context but not 24,576. A 32 GB RTX 5090 holds Q4_K_M at 32,768 tokens but not 49,152. The reason is the KV cache, the memory a model keeps of the conversation so far: all 52 layers keep one, at about 213 KB per token, so the full 524,288-token window adds 111.7 GB by itself (147.7 GB in total at Q4_K_M). A 64 GB Mac reaches 131,072 tokens at Q4_K_M, a 96 GB RTX Pro 6000 reaches 262,144, a 128 GB unified-memory machine reaches 393,216, and the whole window needs 180 GB or more of memory. Nanbeige's own serving examples use four GPUs with vLLM or SGLang; locally, run a community GGUF in llama.cpp. The community NVFP4 builds come to 22.1 GB, larger than Q4_K_M, because the embeddings and output head stay in BF16.

Nanbeige's card reports Terminal-Bench 2.1 at 80.9 (Terminus 2 harness), SWE-Bench Pro at 60.3 and GPQA Diamond at 89.5, plus DeepSWE 65.5, Terminal-Bench 4.0 23.8 and AIME 2026 95.2. Against Qwen3.8-27B, the strongest rival in its table, the card lists Nanbeige ahead on 18 of 20 rows and behind on two: SWE-Bench Pro (60.3 against 61.7) and GDPval (84.8 against 86.4). Gemma4-31B beats it on GPQA Diamond (91.3). Every score is Nanbeige's own, run at the highest thinking effort with preserve_thinking switched on, and no independent reproduction had appeared when this page was written. The card's figures for Qwen3.8-27B match Qwen's published ones, but its figures for Muse-Glimmer-30B (Terminal-Bench 2.1 61.8, SWE-Bench Pro 36.9) differ from the 51.7 and 51.2 Meta reports itself, and its Gemma4-31B GPQA Diamond score (91.3) is well above the 84.3 on this site's Gemma 4 31B page, so read the gaps between models as one lab's harness rather than settled rankings. In this site's tracked data, every other model that scores 80.9 or higher on Terminal-Bench 2.1 has at least 124.6B parameters, and the best dense model near Nanbeige's size is Qwen 3.8 27B at 73.0.

What the 512K window actually costs

Nanbeige4.3 33B advertises a 524,288-token window, and the weights are not what makes that hard. Every one of its 52 layers keeps a full key-value cache, about 213 KB for each token of context, so the cache grows in a straight line and, past roughly 95,000 tokens, outweighs the 20.2 GB of Q4_K_M weights. The grey line shows the same model if only one layer in four cached, the layout Qwen 3.8 27B uses.

030609012064k256k384k512k111.7 GBNanbeige4.327.9 GB3:1 hybrid
Nanbeige4.3 33B: 52 of 52 layers cacheThe same 33B if only 13 of 52 layers cached (a 3:1 hybrid layout, as in Qwen 3.8 27B)

KV cache only, at FP16. Weights and activation overhead sit on top of these figures.

Filling the whole 524,288-token window costs 111.7 GB of KV cache, against 27.9 GB for a layout that caches one layer in four. Add 20.2 GB of Q4_K_M weights and this site's full-window total is 147.7 GB; the hybrid layout would need 53.8 GB. At the 262,144 tokens Qwen 3.8 27B offers, Nanbeige's cache is 55.8 GB against Qwen's 17.2 GB. The longer window comes with a bigger bill, and the cache, not the weights, sets the hardware.

VRAM at each quantization

Calculated at 8k context. Since KV cache scales linearly with context, longer sessions need more VRAM than shown here.

QuantWeightsKV cacheTotal
FP32132.4 GB1.74 GB150.2 GB
BF1666.2 GB1.74 GB76.1 GB
FP1666.2 GB1.74 GB76.1 GB
Q8_035.2 GB1.74 GB41.4 GB
Q6_K29.0 GB1.74 GB34.4 GB
Q5_K_M23.6 GB1.74 GB28.4 GB
Q4_K_Mrec20.2 GB1.74 GB24.5 GB
Q3_K_M15.9 GB1.74 GB19.8 GB
Q2_K12.6 GB1.74 GB16.1 GB
NVFP4cuda22.1 GB1.74 GB26.7 GB

Shown at 8k context with FP16 KV cache. NVFP4 needs a CUDA GPU to run. Toggle TurboQuant in the calculator to view compressed KV cache numbers.

Quantization × context: where it fits

The table above holds context fixed at 8k. Add context as a second axis and the picture changes quickly for this model, because every 32,768 tokens adds about 7.0 GB of KV cache. Pick the row you can download, then the column you actually need; the right-hand column is the full window.

Total VRAM needed by quantization and context length, with the GPU class each figure requires.
Quant8k ctx32k ctx128k ctx512k ctx
Q8_041.4 GB48 GB card47.2 GB48 GB card70.7 GB80 GB card164.5 GB80 GB+ card
Q6_K34.4 GB48 GB card40.3 GB48 GB card63.8 GB80 GB card157.6 GB80 GB+ card
Q5_K_M28.4 GB32 GB card34.2 GB48 GB card57.7 GB80 GB card151.5 GB80 GB+ card
Q4_K_Mrec24.5 GB32 GB card30.4 GB32 GB card53.8 GB80 GB card147.7 GB80 GB+ card
Q3_K_M19.8 GB24 GB card25.6 GB32 GB card49.1 GB80 GB card142.9 GB80 GB+ card
Each cell shows the smallest card that holds it:Consumer GPUWorkstation GPUDatacenter GPU

Benchmarks

GPQA Diamond
89.5
SWE-bench Pro
60.3
Terminal-Bench 2.1
80.9

Nanbeige4.3 33B benchmarks: a 33B model scoring like a 120B+ one on Terminal-Bench

Terminal-Bench 2.1 tests agents on real command-line tasks, and it is the row Nanbeige's card leads with. Plotted by total size against the other tracked models that report it, Nanbeige4.3 sits in the top left corner: every other model scoring 80.9 or higher has at least 124.6B parameters (Ornith 1.5 122B is the smallest, at 81.2), and the best dense model near its size is Qwen 3.8 27B at 73.0. Two cautions. Each score is the vendor's own run on its own harness, and Nanbeige's measurements of other labs' models differ from those labs' published figures (it gets 61.8 for Muse Glimmer 30B where Meta reports 51.7). And the 80.9 is one lab's result, with no independent reproduction when this page was written.

45709510B100B1T10TTotal parameters (log scale)GLM-5.2 753BMiniMax M3InklingBonsai 2 27BKimi K3Muse Glimmer 30BOrnith 1.5 35B-A3B (MoE)Ornith 1.5 397B (MoE)DeepSeek V4.1 Flash 552BFlint 40B (MoE)Nanbeige4.3 33B
Terminal-Bench 2.1, as reported by each model's own publisher. Scaffolding and harness differ between vendors, so read the gaps as approximate rather than a ranking.

Against Qwen 3.8 27B: ahead on agent work, behind on two rows

Qwen3.8-27B is the strongest rival in Nanbeige's own table and the nearest peer by size on this site's board. The card lists 20 rows for both models and Nanbeige is higher on 18. The chart shows the five largest leads, two smaller ones, and both rows where Qwen is ahead.

DeepSWE
Nanbeige4.3 33B
65.5
Qwen3.8 27B
42.5
Terminal-Bench 4.0
Nanbeige4.3 33B
23.8
Qwen3.8 27B
6.3
Automation Bench
Nanbeige4.3 33B
54.2
Qwen3.8 27B
38.3
DeepPlanning
Nanbeige4.3 33B
63.3
Qwen3.8 27B
49.2
JobBench
Nanbeige4.3 33B
44.8
Qwen3.8 27B
34.5
NL2Repo
Nanbeige4.3 33B
53.0
Qwen3.8 27B
48.3
Toolathlon-Verified
Nanbeige4.3 33B
70.4
Qwen3.8 27B
68.5
SWE-Bench Pro
Nanbeige4.3 33B
60.3
Qwen3.8 27B
61.7
GDPval
Nanbeige4.3 33B
84.8
Qwen3.8 27B
86.4

Nanbeige's model card for Nanbeige/Nanbeige4.3-33B, every model at its highest thinking effort and Nanbeige with preserve_thinking on. DeepSWE and Terminal-Bench 4.0 use mini-swe-agent v2.4.6, NL2Repo uses Claude Code, Automation Bench is v1.0.6 and GDPval uses revised rubrics. Self-reported by Nanbeige, which also chose the rivals, and not independently reproduced when this page was written. The 11 rows not charted include Terminal-Bench 2.1 and GPQA Diamond, which appear elsewhere on this page, and three more where the gap is under one point (AIME 2026, EnterpriseOps-Gym and Tau3-Bench).

Nanbeige's lead is widest on long, multi-step agent work (repository-level bug fixing, terminal tasks, office automation, planning) and shrinks to nothing on single-patch and professional-task grading: Qwen is ahead by 1.4 points on SWE-Bench Pro and 1.6 on GDPval, and four of Nanbeige's 18 wins are by less than a point. Qwen 3.8 27B also takes image and video input and caches far less at long context, so the better benchmark table is not automatically the better model for a given machine.

GPUs that run Nanbeige4.3 33B natively (70)

Show 65 more
Plus 33 GPUs that run it with CPU offload (slower)

No GPU? Rent an RTX A6000 from $0.33/hr ↗

Prices as of Oct 17, 2026. Rates change; check RunPod for current pricing. Affiliate link: CanItRun may earn a commission. Doesn't affect the fit calculation above.

Notes

Released 24 October 2026 by the Nanbeige LLM Lab as the flagship of its Nanbeige4.3 series, post-trained from Nanbeige4.3-33B-Base for coding agents and office ("cowork") work. It is a plain dense Llama-architecture model: 33.1B parameters, 52 layers, 8 KV heads and a 524,288-token window in which every layer keeps a full KV cache, so long context is expensive (111.7 GB of cache at the full window). The lab calls it a teacher model, meant to anchor distilling its agent skills into smaller models, starting with a planned Nanbeige4.3-3B that had not been released when this page was written. Nanbeige's card scores it against Qwen3.8-27B, Muse-Glimmer-30B and Gemma4-31B at each model's highest thinking effort: Terminal-Bench 2.1 80.9 (Terminus 2 harness), SWE-Bench Pro 60.3 and GPQA Diamond 89.5. It is ahead of Qwen3.8-27B on 18 of the 20 rows the card lists and behind on SWE-Bench Pro (61.7) and GDPval (84.8 against 86.4); Gemma4-31B leads it on GPQA Diamond (91.3). Every figure is Nanbeige's own. The card's Qwen3.8-27B numbers match Qwen's published ones, but its Muse-Glimmer-30B numbers (Terminal-Bench 2.1 61.8, SWE-Bench Pro 36.9) differ from Meta's own (51.7 and 51.2), so harness and settings move results, and no independent reproduction had appeared when this page was written. Nanbeige publishes BF16 safetensors only (66.2 GB); the GGUF, NVFP4, FP8, MLX and EXL3 builds are community uploads, and Ollama's library had no Nanbeige4.3 page. Apache 2.0, text only, English and Chinese.

Hugging Face ↗Released 2026-10-24

Compare Nanbeige4.3 33B with other models

How to run Nanbeige4.3 33B locally

8244880160320

Q4_K_M needs 24.5 GB: needs a 32 GB GPU such as the RTX 5090.

llama.cpp with a community GGUF (it uses the standard Llama architecture), or vLLM and SGLang, which Nanbeige's card documents

./llama-server \
  -hf bartowski/Nanbeige_Nanbeige4.3-33B-GGUF:Q4_K_M \
  -c 32768 -ngl 99 -fa on --jinja \
  --temp 1.0 --top-p 0.95

Ollama

ollama run hf.co/bartowski/Nanbeige_Nanbeige4.3-33B-GGUF:Q4_K_M

llama.cpp

# 24 GB card (RTX 3090 or 4090): Q3_K_M with an 8-bit KV cache
./llama-server \
  -hf bartowski/Nanbeige_Nanbeige4.3-33B-GGUF:Q3_K_M \
  -c 16384 -ngl 99 -fa on -ctk q8_0 -ctv q8_0 --jinja \
  --temp 1.0 --top-p 0.95

# Nanbeige's profiles: agent and tool use at temperature 1.0, top-p 0.95;
# reasoning and chat at temperature 0.6, top-p 0.95

# Nanbeige's own vLLM example (BF16 weights, four-way tensor parallel)
vllm serve Nanbeige/Nanbeige4.3-33B --tensor-parallel-size 4 \
  --gpu-memory-utilization 0.8 --enable-auto-tool-choice \
  --reasoning-parser qwen3 --tool-call-parser qwen3_coder

LM Studio: Search for 'Nanbeige4.3' and take the Q4_K_M build from bartowski (20.8 GB) on a 32 GB or larger machine, or Q3_K_M (15.9 GB) on a 24 GB card. The model reasons before it answers, so expect a think block, and keep the reasoning in the conversation for agent work (Nanbeige's preserve_thinking setting). Temperature 1.0 and top-p 0.95 are Nanbeige's agent settings; use 0.6 and 0.95 for chat. Budget for the context: this model caches every layer, so each 32,768 tokens adds about 7.0 GB at 16-bit.

Why this quantization? Q4_K_M puts the weights at 20.2 GB by this site's estimate, close to the 20.8 GB bartowski publishes, and the total is 24.5 GB at an 8k context. Unlike hybrid-attention models, this one caches every layer, so context is the second bill, about 7.0 GB of KV cache for every 32,768 tokens. That sets the plan: a 32 GB card holds Q4_K_M to 32,768 tokens, a 24 GB card has to step down to Q3_K_M (15.9 GB of weights) and 16,384 tokens, and long agent sessions are a 64 GB Mac or 96 GB card job. The community NVFP4 builds suit Blackwell cards but weigh 22.1 GB, more than Q4_K_M, because the embeddings and output head stay in BF16.

Who is Nanbeige4.3 33B for?

Developers who want an open-weight coding and office agent in the 30B class and have 32 GB or more of fast memory: an RTX 5090, a 48 GB workstation card or a 64 GB Apple Silicon machine. It is dense, so all 33.1B parameters are read for every token and decode runs at the speed of a 33B dense model rather than a small-active mixture of experts: this site estimates 58.8 tokens per second for Q4_K_M on an RTX 5090 and 19.9 on an M4 Max. Nanbeige pitches it for terminal work, repository-scale coding, tool-calling workflows and professional-document tasks.

Best for

  • Local coding agents for terminal and repository tasks on a 32 GB card or a 64 GB Mac, with Nanbeige's agent settings (temperature 1.0, top-p 0.95, preserve_thinking on)
  • Multi-step tool use through an OpenAI-compatible server, with the XML tool-call format Nanbeige recommends
  • Long agent sessions on a 96 GB or larger machine, where 262,144 tokens of context still fits at Q4_K_M
  • Bilingual English and Chinese work

Not ideal for

  • A 24 GB GPU if you want Q4_K_M or more than 16,384 tokens of context, since the weights and the cache together outgrow the card
  • Anyone who wants the full 524,288-token window locally, Q4_K_M needs 147.7 GB in total, which only 180 GB or larger memory holds
  • Image, audio or video input, it is text only
  • Anyone who needs an official quantization or an Ollama library tag, Nanbeige ships BF16 only and the library had no Nanbeige4.3 page
  • Anyone who needs the benchmark claims independently verified before adopting a model, it was released on 24 October 2026 and every score is Nanbeige's own

Should you run Nanbeige4.3 33B locally?

It depends on how much context your work needs, because memory goes mostly to the cache. On a 24 GB RTX 3090 or RTX 4090, Q4_K_M just misses at 24.5 GB with an 8k context, and Q3_K_M (15.9 GB of weights) fits 16,384 tokens: workable for chat, thin for an agent that reads files and tool output. A 32 GB RTX 5090 holds Q4_K_M at 32,768 tokens, at an estimated 58.8 tokens per second. A 64 GB Mac such as the M4 Max reaches 131,072 tokens at Q4_K_M, at an estimated 19.9 tokens per second, and a 96 GB RTX Pro 6000 reaches 262,144. The full 524,288-token window needs 147.7 GB at Q4_K_M, which only 180 GB or larger memory holds. If long context on modest hardware matters more than the benchmark lead, Qwen 3.8 27B caches far less per token, and storing the KV cache at 8 bits roughly halves the bill on either model. Before relying on the scores, test it on your own repository: every one is Nanbeige's, the model was released on 24 October 2026, and the card's Transformers example sets trust_remote_code=True, so read the repo's code first or run a GGUF, vLLM or SGLang instead.

Explore

Browse all guides →Browse all models →Browse all GPUs →

Frequently asked questions

What are the VRAM requirements for Nanbeige4.3 33B?
Nanbeige4.3 33B requires approximately 24.5 GB of VRAM at Q4_K_M quantization, 41.4 GB at Q8, and 76.1 GB at FP16. These numbers assume 8k context window; VRAM scales linearly with context length due to the KV cache.
How many parameters does Nanbeige4.3 33B have?
Nanbeige4.3 33B has 33.1 billion parameters.
Can Nanbeige4.3 33B run on a 16 GB GPU?
No. At Q4_K_M, Nanbeige4.3 33B needs 24.5 GB of VRAM, more than 16 GB. You will need a 32 GB GPU like the RTX 5090.
Can Nanbeige4.3 33B run on a 24 GB GPU?
No. Even at Q4_K_M, Nanbeige4.3 33B needs 24.5 GB. Consider a 32 GB card like the RTX 5090.
What is the smallest quantization for Nanbeige4.3 33B that fits in 24 GB of VRAM?
At Q3_K_M, Nanbeige4.3 33B needs 19.8 GB, the highest-quality quantization that fits in 24 GB of VRAM.
What GPU do I need to run Nanbeige4.3 33B locally?
A 32 GB GPU is the minimum. At Q4_K_M, Nanbeige4.3 33B needs 24.5 GB VRAM. Good option: RTX 5090 (32 GB).
Can I run Nanbeige4.3 33B in the cloud?
Yes. The cheapest RunPod setup we found that holds Nanbeige4.3 33B entirely in GPU memory at 8k context is 1× RTX A6000 at Q8_0, at roughly 17.3 tokens per second and from $0.33 per hour for the whole pod. Prices as of Oct 17, 2026; RunPod rates change, so check their pricing page for the current figure.
How much VRAM does Nanbeige4.3 33B need at its full 512K context?
About 147.7 GB in total at Q4_K_M: 20.2 GB of weights, 111.7 GB of KV cache for the entire 524,288-token window, and activation overhead on top. Every one of its 52 layers keeps a cache, at about 213 KB per token, so the cost grows in a straight line. An 8k session totals 24.5 GB, and each additional 32,768 tokens adds about 7.0 GB. Only machines with 180 GB or more of memory hold the full window, such as a 192 GB M2 Ultra, a 256 GB M3 Ultra or M5 Ultra, an AMD MI300X or an NVIDIA B200.
What context length can a 24 GB or 32 GB GPU handle with Nanbeige4.3 33B?
On a 24 GB RTX 3090 or RTX 4090, Q4_K_M just misses (24.5 GB in total at 8k) and Q3_K_M, at 15.9 GB of weights, fits 16,384 tokens but not 24,576. A 32 GB RTX 5090 holds Q4_K_M at 32,768 tokens but not 49,152, and Q3_K_M at 49,152. Each 32,768 tokens adds about 7.0 GB, so storing the KV cache at 8 bits is the cheapest way to stretch either card.
How does Nanbeige4.3 33B compare with Qwen 3.8 27B?
On Nanbeige's own table it is ahead on 18 of 20 rows, including Terminal-Bench 2.1 (80.9 against 73.0) and DeepSWE (65.5 against 42.5), and behind on SWE-Bench Pro (60.3 against 61.7) and GDPval (84.8 against 86.4). The practical differences are memory and inputs: Qwen 3.8 27B takes image and video, totals 19.0 GB at Q4_K_M with an 8k context (24.5 GB for Nanbeige), and caches 17.2 GB at 262,144 tokens where Nanbeige caches 55.8 GB. All the benchmark scores are self-reported.
Does Nanbeige4.3 33B work with llama.cpp, Ollama and LM Studio?
Yes for llama.cpp and LM Studio, through community GGUF builds: the model uses the standard Llama architecture, and bartowski's repo publishes quants from IQ2_XXS (10.1 GB) to Q8_0 (35.2 GB) plus BF16. Ollama's library had no Nanbeige4.3 page when this page was written, but ollama run hf.co/bartowski/Nanbeige_Nanbeige4.3-33B-GGUF:Q4_K_M pulls a GGUF directly. Nanbeige's own serving examples use vLLM and SGLang with the qwen3 reasoning parser and the qwen3_coder tool-call parser.
Are Nanbeige4.3 33B's benchmark scores independent?
No. Every score comes from Nanbeige's model card, which compares the model with only three others of 27B to 31B parameters and chose the harnesses. The card's Qwen3.8-27B numbers match what Qwen publishes, but its Muse-Glimmer-30B numbers do not (Terminal-Bench 2.1 61.8 against Meta's 51.7, SWE-Bench Pro 36.9 against 51.2), a sign that harness and settings can move a result by many points. No independent reproduction had appeared when this page was written.
Is Nanbeige4.3 33B a mixture-of-experts model, and does that change its speed?
No, it is dense: all 33.1B parameters are read for every token, so decode speed tracks a 33B dense model. This site estimates 58.8 tokens per second for Q4_K_M on an RTX 5090 and 19.9 on an M4 Max (64GB) at 8k context. Mixture-of-experts coding models with a few billion active parameters read far less per token and decode faster, but they need memory for every expert.