Nanbeige4.3-33B: 17 of 20 Wins, a 512K Context, and Nothing Independently Tested

At 02:49 UTC on 24 October 2026, a Hugging Face repository called Nanbeige/Nanbeige4.3-33B went public, four minutes after the base checkpoint that shares its name. No launch post appeared. No blog entry, no vendor announcement, no press release — the model card is the entire first-party record of a 33.1-billion-parameter open-weights release whose headline claim is that it beats Qwen3.8-27B on 18 of 20 benchmarks. That claim is not false. It is also not checkable yet, and the coverage since has mostly repeated the table without reading the footnotes underneath it.

So the numbers say two things at once. Nanbeige4.3-33B leads 17 of the 20 rows in its own table, and it beats Qwen3.8-27B on 18 of them. Those are different counts and both are accurate: the three rows it does not lead are SWE-Bench Pro, where Qwen3.8-27B wins 61.7 to 60.3, GDPval, where Qwen3.8-27B wins 86.4 to 84.8, and GPQA Diamond, where Gemma4-31B's 91.3 beats both. Losing two rows to Qwen3.8-27B and one to Gemma4-31B gives you 18 of 20 against the Qwen model and 17 of 20 against the field. Most write-ups pick one number and leave the other out, which is a small thing that tells you how closely the rest was read.

What the repository establishes, and what it does not

Start with what can be verified by opening files rather than quoting prose, because the gap between the two is the story here.

• Confirmed: the weights exist. Fourteen safetensors shards totalling 66,259,989,086 bytes, bfloat16, in a repository created 02:49:18Z on 24 October 2026 and last touched 11:11Z on 25 October. A separate base checkpoint, Nanbeige4.3-33B-Base, was created three minutes earlier at 02:46:52Z.

• Confirmed: the licence is Apache 2.0, declared in the repository metadata and in the card's front matter. There is no LICENSE file among the eight non-weight files, which is a paperwork gap rather than a legal one — the metadata field is what the Hub and most scanners read.

• Confirmed: the architecture is a plain Llama stack, not a mixture of experts and not the looped-transformer design the family's small models used. More on the config below.

• Confirmed: there is no vendor-hosted endpoint. The Hub's inference-provider mapping for this repository is empty, and the card offers vLLM, SGLang and Transformers, in that spirit: bring your own GPUs.

• Not confirmed: anything about how it was trained. No pretraining token count, no data mix, no compute figure, no post-training recipe, and no limitations or safety section. The card's citation block is four lines long.

• Not confirmed: that any published number is reproducible. There is no evaluation harness in the repository — no scripts, no task configs, no logs — and as of 26 October no third party has published a score, an arena rating or an index placement for this model.

• Not confirmed: that the release was stealthy. It was not. It was unannounced by the lab, which is a narrower and more accurate description: the card is a full launch document with a twenty-row benchmark table, and aggregators picked it up within a day. What is missing is a first-party post explaining what Nanbeige thinks it built.

That distinction matters for anyone deciding what to do with the release. A lab that says nothing has told you nothing about intent, support or the next checkpoint. A lab that publishes a card but no post has told you a great deal about the model and left the strategy implicit — and in this case the strategy is stated plainly in the second paragraph of the card, once you notice it.

The card calls it a teacher, and that reframes the whole release

Nanbeige4.3-33B is described as the "flagship teacher model" for the Nanbeige4.3 series, built first so that the lab can distil agentic behaviour into smaller models, "e.g. for Nanbeige4.3-3B". The card lists "state-of-the-art agentic performance among open models in the ~30B parameter class" as the goal, and then immediately describes the 33B as the foundation for a distillation pipeline rather than the end product.

Read that literally and the release is a training artefact that happens to be shippable. It is the model you use to generate trajectories for a 3B student, and the reason its benchmark suite is heavy on long-horizon agent tasks — Terminal-Bench, DeepSWE, JobBench, Toolathlon — is that those are the behaviours someone wants to transfer. Nanbeige4.3-3B is not out. When it lands, it will be the model most people actually run, and this 33B will be the thing that explains its scores.

There is a side effect worth naming: a teacher model is optimised to produce good trajectories under a generous token budget, not to be cheap at inference. The card's recommended settings bear that out — 65,536 max new tokens for agentic work and 262,144 for reasoning and chat, with thinking on by default. A model prompted to emit a quarter of a million tokens is not a model you put behind a chat box without a budget.

The 33B the configuration file describes

Read config.json and the shape is conventional in a way that the marketing is not. Fifty-two layers, hidden size 7,168, 56 query heads against 8 key-value heads — a 7:1 grouped-query ratio — head dimension 128, an FFN width of 22,016, and a vocabulary of 166,912 tokens. The RoPE base is 120,000,000 with no scaling applied, and max_position_embeddings is set to 524,288. The transformers version stamped in the file is 4.51.1.

The parameter count follows from those numbers. Attention projections come to 117.4 million parameters per layer, the three-layer MLP to 473.4 million, which makes 590.9 million per block across 52 blocks: 30.7 billion. Two untied embedding matrices at 166,912 by 7,168 add 2.4 billion. The total is 33.1 billion, which is what the name promises and what 66.3 GB of bfloat16 weighs.

Against the model it spends its table attacking, the differences are sharper than the scores suggest.

• Size — 33.1B dense for Nanbeige4.3-33B vs 27.78B dense for Qwen3.8-27B. Both are dense; neither is a mixture of experts.

• Modality — text only, English and Chinese, for Nanbeige4.3-33B vs native text, image and video input for Qwen3.8-27B. If your pipeline reads screenshots, the comparison is over before the benchmarks start.

• Attention — uniform full attention across 52 layers for Nanbeige4.3-33B vs a hybrid stack for Qwen3.8-27B, which runs 48 gated DeltaNet linear layers against 16 full-attention layers in a 3:1 pattern. That is why the Qwen model is cheap at long context and this one is not.

• Context — 524,288 tokens native for Nanbeige4.3-33B vs 262,144 native, extensible to roughly 1M with YaRN, for Qwen3.8-27B.

• Licence — Apache 2.0 on both, which removes the usual reason to prefer one.

The attention difference is not a footnote. It is the whole reason the next section exists.

512K is a value in a config file, not a working context

Every summary of this release leads with the half-million-token window. Almost none of them does the arithmetic, and the arithmetic is unkind.

With 52 layers, 8 key-value heads of 128 dimensions, and bfloat16 storage, each token in the cache costs 2 × 52 × 8 × 128 × 2 bytes — 212,992 bytes, or 208 KiB. Three consequences follow directly.

• At the full 524,288 tokens the KV cache alone is 111.7 GB, about 104 GiB. That is more than the 66.3 GB of weights, and it does not fit on any single accelerator sold today.

• At 131,072 tokens — a quarter of the advertised window — the cache is 27.9 GB, roughly 26 GiB. Add the weights and you are at 92 GB before activations, which is why the card's own examples use four-way tensor parallelism.

• At 32,768 tokens the cache is 6.98 GB, about 6.5 GiB. This is the number that matters in practice, and it is the context length the community GGUF repository's llama.cpp example actually sets.

None of this makes the 512K claim dishonest. The window is native — no YaRN, no scaling factor, a rope base of 120 million — and on a four-GPU node with enough memory you can serve it. It does mean the number in the headline is a ceiling you will not reach on hardware you own, and that anyone quoting "512K context" as a purchasing reason has not priced the cache. Compare that with the Qwen3.8-27B design, where three quarters of the layers hold a constant-size recurrent state instead of a growing cache, and the gap in cost per long-context token is structural rather than a matter of tuning.

One more thing from the config, and it is the kind of detail that costs an afternoon: use_cache is set to false, in both config.json and generation_config.json. Loading the model through the card's Transformers snippet and calling generate without overriding that will recompute the prefix on every step. The vLLM and SGLang paths manage their own cache and are unaffected. If your first benchmark run looks inexplicably slow, check this before you blame the weights.

Reading the benchmark table the way its footnotes ask you to

The table is better documented than most vendor tables, and the documentation is where the caveats live. Twelve footnotes sit under twenty rows, and they say more about comparability than the scores do.

• Terminal-Bench 2.1 was run with Terminus 2. Terminal-Bench 4.0 and DeepSWE were run with mini-swe-agent v2.4.6.

• NL2Repo was run with the Claude Code harness; JobBench with Claude Code plus a search tool.

• SWE-Atlas-QnA answers were graded against 1,304 task-specific rubrics using GPT-6 Sol as judge at medium reasoning effort. A rubric judge is a second model in the loop, and it is not the model under test.

• Toolathlon-Verified sets no max_tokens limit on individual requests. Claw-Eval is scored only on the General subset, 157 single-turn tasks. YC-bench keeps only the most recent ten turns of dialogue as history before each call. GDPval uses revised rubrics.

• Nanbeige4.3-33B itself was evaluated with preserve_thinking=true, which retains earlier assistant reasoning across turns. The card recommends exactly that for multi-turn tool use, and exactly the opposite for ordinary chat.

Read together, those notes describe a suite built to measure long-horizon agent behaviour with generous budgets. That is a defensible thing to measure — it is what the model is for — but it is also the regime in which harness choice moves scores the most. The largest gap in the table, DeepSWE at 65.5 against 42.5 for Qwen3.8-27B, is a 23-point spread on a benchmark driven by an agent scaffold. The smallest gaps are in the rows where the scaffold matters least: AIME 2026 at 95.2 against 94.5, Tau3-Bench at 48.8 against 48.5, EnterpriseOps-Gym at 41.0 against 40.2.

That pattern is consistent with two explanations. Either the model is genuinely much better at agentic coding than its peers, or the agentic rows are the ones where a lab that tunes its own scaffold against its own model gains the most. Nothing in the repository distinguishes between them, and the honest position until someone reruns the suite is that both are live. The rows where the model wins by one point or less — Tau3-Bench, EnterpriseOps-Gym, AIME, Claw-Eval at 78.3 against 75.2 — are the ones least likely to survive an independent harness.

What does not exist, as of 26 October, is any outside number at all. No Artificial Analysis index entry, no arena rating, no reproduction by anyone. The card's own AA-LCR figure of 84.0 is Nanbeige running an Artificial Analysis benchmark, not Artificial Analysis running Nanbeige.

The only hands-on test so far, and what it shows

One person has published anything from actually running the weights, and the result is worth reporting precisely because it is thin. A Japanese developer loaded the full bfloat16 checkpoint on a Colab A100 with 80 GB, using plain Transformers with automatic dtype and device mapping, and measured about 63 GB of VRAM in use. The first reply, capped at 1,024 new tokens, took roughly eleven seconds. No tokens-per-second figure was given; the impression was that a 33B dense model at bfloat16 is slow, which is what the arithmetic predicts.

Three prompts followed. The 9.11-versus-9.8 comparison came out right, with a clear decimal explanation. A question about anime characters produced subjectively fine but garbled names. A question about the Japanese prime minister produced a wrong answer, a claimed knowledge cutoff of June 2024, and a hallucinated name. English chain-of-thought leaked ahead of the closing think tag.

Three casual prompts are not an evaluation and should not be read as one. What they are is a data point that lines up with the shape of the vendor table: a model tuned hard for English agentic work, two years stale on world knowledge, and unremarkable in a second language. The card claims English and Chinese; nobody has published a Chinese-language test either.

Where the quantised version stops being the same model

Most people who run this will not run 66 GB of bfloat16. They will run a 4-bit quant on one card, and the quantisation reports that appeared within a day of release suggest that is a bigger step down than usual.

The community GGUF repository publishes KL divergence and top-1 agreement against the bfloat16 model, measured on a standard text stand, and its own README warns that the model is "unusually sensitive to quantization".

• Q8_0, 35.2 GB — KL 0.0032, 98.0% top-1 agreement.

• Importance-matrix Q5_K_M, 24.7 GB — KL 0.0213, 94.7% top-1.

• Importance-matrix Q4_K_M, 21.2 GB — KL 0.0380, 92.6% top-1.

• Plain llama.cpp Q4_K_M, 20.1 GB — KL 0.0693, 89.9% top-1. Same bit width as the row above, nearly double the drift.

• Importance-matrix IQ3_S, 17.1 GB — KL 0.1019, 87.5% top-1. The README notes that files below 4-bit lose substantially more accuracy.

An 8-bit MLX conversion reports 98.6% top-1 at KL 0.015, and compares a 4-bit AWQ path at 92.1% top-1 with KL 0.181 — a much steeper drop than the importance-matrix GGUF at the same nominal width.

The practical reading: if you evaluate this model at 4-bit on a single 40 or 48 GB card and it fails your agent tasks, you have evaluated a model that agrees with the published one on roughly nine tokens in ten. For prose that is invisible. For tool calls, where one malformed argument ends the turn, a 7% divergence rate is a different product. If the agentic claims are the reason you are interested, the honest minimum is Q5 with an importance matrix, or bfloat16 on rented hardware for the evaluation run.

What it costs to try, and how to try it without betting on it

Nanbeige has published no price, because there is nothing to price: the model is weights, not a service, and the Hub lists no inference provider for it. That leaves three routes — four 80 GB GPUs for bfloat16, one 48 GB card at Q5, or wait for a provider to list it.

For comparison, the model it claims to beat is available on demand. Qwen3.8-27B runs on OrcaRouter at $0.33 per million input tokens and $2.40 per million output, with a 262K window and a p50 time-to-first-token around 2.95 seconds. A 65,536-token agentic prompt plus 8,000 tokens of output costs roughly four cents. That is the number a self-hosted 33B has to beat, and it has to beat it while carrying GPU idle time, quantisation risk and the absence of a fallback path.

We do not host Nanbeige4.3-33B, and nothing here should be read as a claim that we do. What we can do is make the comparison cheap in the other direction: Orca Connect puts your own GPU behind the same key as the hosted catalogue, so a self-hosted Nanbeige endpoint and Qwen3.8-27B can sit behind one endpoint and one routing rule while you decide. Route a share of traffic to the new checkpoint, keep the hosted model as the fallback, and let the request logs — grade, latency, cost per call — settle an argument that vendor tables cannot. The 0% markup matters here in a specific way: provider list prices pass through unchanged, so when a vendor cuts a price, the comparison you set up last week stays honest.

Who should act on this, and who should wait

If you are building a distillation pipeline, this is the most interesting open checkpoint of the month. A 33B dense teacher with a permissive licence, documented sampling settings, and a benchmark suite chosen to measure exactly the behaviour you want to transfer is a useful asset, and the fact that the lab says it is building a teacher first is a signal about where the series is going. Download it, run your own eval, and keep the card's harness notes next to your results.

If you need a model in production this week, wait. There is no independent score, no hosted endpoint, one hands-on report with three prompts in it, and a quantisation profile that degrades faster than usual at the bit widths most people can afford. None of that is disqualifying — it is just not yet evidence.

If you need vision, the comparison is already decided: Qwen3.8-27B reads images and video, and this model reads text in two languages.

The things to watch are specific. Nanbeige4.3-3B, the distillation target, which will tell you whether the teacher was worth building. The first independent run of Terminal-Bench 4.0, the row with the widest gap and the most scaffold sensitivity. And whether a provider lists the 33B at all — because the moment someone does, the 512K context stops being a configuration value and becomes a line item, and the arithmetic in this piece becomes somebody's invoice.