Nanbeige4.3-33B vs Granite 4.2 30B: Claims Against Compliance

The decision between Nanbeige4.3-33B and Granite 4.2 30B will be made in a procurement meeting, not on a leaderboard. Both are roughly 30-billion-parameter dense models under Apache 2.0, both can be downloaded this week, and both claim a 512K-token ceiling. But one is sold by IBM with signed artefacts and a support contract, and the other is a two-day-old repository from a Chinese lab that has not published a launch announcement. IBM's Granite 4.2 30B arrived on August 25, 2026; Nanbeige4.3-33B appeared on Hugging Face on October 24, 2026. They are not really rivals for the same purchase, which is exactly why the comparison is worth making carefully.

What follows is not a winner. It is a shortlist logic: the four questions that actually separate these models, with the evidence each answer rests on and the places where the evidence is weaker than it looks.

Two products wearing the same parameter count

Granite 4.2 30B is the top of IBM's Granite 4.2 line — 3B, 8B and 30B, all dense. It is built on Granite-4.1-30B-Base, pretrained on roughly 15 trillion tokens including about a trillion synthetic code tokens, then given an agentic reinforcement-learning stage for the 8B and 30B sizes. It ships three reasoning modes (thinking, non-thinking, low-effort), native tool calling in OpenAI format, and FP8 and 4-bit builds. IBM lists native vLLM and SGLang support, including a granite_thinking_parser.

Nanbeige4.3-33B is a single dense checkpoint from Nanbeige LLM Lab, the AI team under Kanzhun, the company behind BOSS Zhipin. Its card is unusually specific about deployment: 33.1B parameters, 524,288-token context, English and Chinese, thinking on by default, an XML tool-call format recommended over JSON, and a preserve_thinking flag aimed at multi-turn tool use. It is explicitly positioned as a teacher model for a smaller sibling, Nanbeige4.3-3B, which has not shipped.

The difference in intent matters. Granite is a product line with an enterprise support path. Nanbeige4.3-33B is a research artefact released to seed a family. One is built to be bought; the other is built to be distilled from.

The one row both labs actually ran

Nanbeige's card compares itself to Qwen3.8-27B, Muse-Glimmer-30B and Gemma 4 31B. IBM's Granite materials do not mention Nanbeige at all. So the two cards share exactly one benchmark where a direct contrast is even nominally possible: Terminal-Bench 2.1.

• Terminal-Bench 2.1 — Nanbeige4.3-33B 80.9 (Nanbeige's card) against Granite 4.2 30B 29.24 (IBM's card). A 51.7-point gap in Nanbeige's favour.

That is the largest claimed difference between two vendor tables in this entire comparison, and it needs three caveats before it means anything. First, both figures are vendor-reported. Second, Nanbeige's card says its Terminal-Bench 2.1 run used Terminus 2; IBM's card does not state its scaffold. Third, a terminal benchmark measures a model plus an agent loop, and a 51-point gap can come from the loop as easily as from the weights. A model with a well-tuned harness and a model with a stock one will diverge by tens of points on the same nominal benchmark.

The next-closest shared row is GPQA Diamond: Nanbeige reports 89.5, IBM reports 66.41. That is a genuine gap on a knowledge benchmark and it is broad enough to survive harness differences, but it also measures a different thing from agentic coding — graduate-level science questions, not long-horizon tool use. It says Nanbeige is the stronger reasoner of the two on this evidence. It does not say it is the stronger agent.

Everything else is non-comparable. Nanbeige reports SWE-Bench Pro at 60.3; IBM reports SWE-Bench Verified at 57.00 — different variants, different difficulty. Nanbeige reports AIME 2026 at 95.2; IBM reports AIME25 at 89.17 — different years. Nanbeige reports JobBench and DeepPlanning; IBM reports τ³-bench 62.00, BFCL v4 61.39, MMLU-Pro 77.60, LiveCodeBench v6 75.77 and RULER 128K 81.38. None of those have a Nanbeige counterpart.

Two 512K claims that are not the same claim

Both models advertise a 512K ceiling. They get there differently, and the difference shows up in what each vendor was willing to publish.

• Native window — Nanbeige4.3-33B: 524,288 tokens, native. Granite 4.2 30B: 131,072 tokens, native.

• Extended ceiling — Granite 4.2 30B offers a long-context extension to 512K. Nanbeige does not need one; 512K is the trained window.

• Long-context evidence — IBM publishes RULER at 128K: 81.38. Nanbeige publishes AA-LCR at 84.0, a long-context reasoning benchmark, but not a recall benchmark at a stated depth.

• Output — Nanbeige's card recommends up to 262,144 new tokens for reasoning and chat, 65,536 for agentic and tool-use work. IBM's recommended max_new_tokens is 8,192 in thinking mode and 2,048 in non-thinking.

That last line is the practical one. A 512K input window paired with an 8K output recommendation is a model built for reading a lot and answering briefly. A 512K window paired with a 262K generation budget is a model built for producing long artefacts. If your work is "ingest the repository, write the migration," they are not equivalent products even at the same nominal context length.

Tool calling, thinking modes and the integration tax

Granite's tool calling is OpenAI-format and native, with BFCL v4 at 61.39 on IBM's own evaluation. That means it drops into a standard function-calling client without a custom parser. IBM also publishes a thinking parser for vLLM, so the reasoning traces separate cleanly from the answer.

Nanbeige4.3-33B takes the opposite approach: it recommends tool_call_format="xml" for best performance, ships a ChatML-style template, and asks you to use the Qwen3 reasoning parser and Qwen3-Coder tool parser in vLLM or SGLang. That is not a defect — many strong agent models use XML tool calls — but it is integration work. If your stack speaks OpenAI tool JSON, Nanbeige needs either a translation layer or its JSON mode, which the card says is supported but not preferred.

This is the tax that benchmark tables never show. A model that is 20 points better on a harness you have to rebuild is not 20 points better on Tuesday. Granite's advantage here is not capability; it is that the wiring is documented, standard, and supported by a vendor with a bug tracker.

The compliance line

IBM ships Granite with cryptographic signatures, ISO certification and transparency disclosures. For a regulated buyer, that is not marketing — it is the difference between a model that can go through an approval process and one that cannot. IBM is also the counterparty: there is a contract, a support path, and a company that will still exist in the procurement cycle's timeframe.

Nanbeige4.3-33B has an Apache 2.0 licence, which is legally permissive and commercially usable. It does not have an enterprise support contract, a signed-artefact programme, or a published data-provenance statement beyond the model card. The lab is part of Kanzhun, a public Chinese company, and the model is bilingual English–Chinese. None of that disqualifies it. All of it is the kind of thing a security review will ask about, and the honest answer today is that the evidence is thinner on the Nanbeige side.

For a team outside a regulated process, this section is irrelevant and you can skip it. For a team inside one, it may decide the question before the benchmarks are read.

What a token costs, and what a GPU costs

Granite 4.2 30B is available as a managed API at $0.16 per million input tokens and $0.65 per million output, with a 75% cache discount, roughly 47.5 output tokens per second and a 0.82-second time to first token. Artificial Analysis estimates its cost at about $0.07 per Intelligence Index task. The weights are also downloadable, at about 60GB in BF16 or 30GB at 8-bit — a single-GPU deployment.

Nanbeige4.3-33B has no published per-token price because nobody hosts it. The card states plainly that no inference provider deploys the model. Self-hosting means about 66GB in BF16, or roughly 20GB at 4-bit, with the vendor's own recipes using tensor-parallel size 4. That is four GPUs held open whether traffic arrives or not.

Put the two numbers side by side honestly and the comparison is between a metered bill that starts at zero and a capital expense that starts at four GPUs. At low volume, Granite is cheaper by an order of magnitude. At sustained high volume, a self-hosted 33B can win — but only if utilization is high enough to amortize the hardware, and only if you value the engineering time at zero. Most teams discover it is not zero.

Neither model is on our router, and that is worth saying plainly

OrcaRouter does not carry Nanbeige4.3-33B or Granite 4.2 30B today. We are not going to pretend otherwise, because a reader who signs up expecting either model would lose a day discovering the catalogue does not have it.

What the routing layer still does is keep the rest of the decision cheap. If you already run an incumbent through our endpoint, adding a self-hosted Nanbeige behind the same key and sending it a slice of traffic is a configuration change rather than a second integration. Our 0% markup model — provider list price passed through — also means that when IBM or another host changes the Granite price, the number you see moves with it rather than lagging behind a reseller's margin. That does not make either model available. It makes the experiment around them cheaper to run.

A shortlist, not a winner

• If you need a contract, signatures and a support path: Granite 4.2 30B, and the benchmark gap stops mattering.

• If you need the strongest claimed agentic coding performance in this size class: Nanbeige4.3-33B, with the caveat that its 80.9 on Terminal-Bench 2.1 has never been reproduced outside its own card.

• If you need native 512K input with long output: Nanbeige4.3-33B. Granite reaches 512K by extension and recommends 8K outputs.

• If you need Chinese: either model lists it. Granite's card names Chinese among 12 languages; Nanbeige's lists English and Chinese. Language is not the tiebreaker here.

• If you need to start today with no GPUs: Granite 4.2 30B through IBM's API. Nanbeige has no hosted option at all.

The uncomfortable summary is that these models are close enough in class that the decision will be made by the constraints around them — procurement, deployment, language, modality — rather than by the 51-point row. That row may well be real. It is also the single least verifiable claim in this article, and it should be the last reason you pick a model, not the first.