Nanbeige4.3-33B: reading a 33B open-weight agent model's release

A new open-weight model aimed at coding agents appeared on Hugging Face on 24 October 2026: Nanbeige4.3-33B, released under the Apache 2.0 license with a base model alongside it. Its card claims "state-of-the-art agentic performance among open models in the ~30B parameter class". Models of this size matter to platform teams because they can run on hardware a company can own, keeping prompts and code in-house. This article reads the card carefully: what the model is, what the numbers do and don't establish, and how we would test it before trusting it with real work.

What was released

Two repositories went up on 24 October: the instruction-tuned model and Nanbeige4.3-33B-Base, both under Apache 2.0. The facts that matter for deployment:

• Size and architecture. About 33.1 billion parameters, stored in BF16. The configuration file declares a standard dense Llama-style architecture: 52 layers, grouped-query attention with 8 key-value heads, and a vocabulary of about 167,000 tokens. It is not a mixture-of-experts model, so every parameter is used for every token.
• Context. Up to 524,288 tokens (512K).
• Modes. The chat template has an enable_thinking switch (on by default), a preserve_thinking option that keeps reasoning from earlier turns (recommended for multi-turn tool use and code-agent workflows), and a tool-use template. The card recommends the XML tool-call format for the best tool-calling results, with JSON also supported.
• Serving. The card shows examples for Transformers, SGLang and vLLM, the latter two with a tensor-parallel size of 4, and recommends a temperature of 1.0 and top-p of 0.95 for agentic tasks.

The card describes the model as the "flagship teacher" for the series, with smaller distilled models such as a 3B variant planned. That smaller model is described as upcoming; it is not available.

Reading the benchmark table

The card compares the model with three other open models of similar size, at their highest thinking effort, using the same inference settings and harness for each. Nanbeige4.3-33B leads most rows. A few results on coding tasks, as reported:

Benchmark (as reported on the card)	Nanbeige4.3-33B	Best other model in the table
Terminal-Bench 2.1	80.9	73.0
Terminal-Bench 4.0	23.8	6.3
SWE-Bench Pro	60.3	61.7
SkillsBench	61.1	56.4

Some things worth noticing before drawing conclusions:

• These are the developer's own numbers. We have not seen an independent evaluation at the time of writing.
• The harness changes from row to row. Terminal-Bench 2.1 used one agent harness, Terminal-Bench 4.0 and SWE-Bench Pro another (mini-swe-agent), and NL2Repo was run inside Claude Code. One code question-answering benchmark was scored with GPT-6 Sol as the judge. Each footnote is honest, but it means the rows are not one consistent measurement.
• Not every row is a win. On SWE-Bench Pro, a repository-level coding benchmark, another model in the comparison scores slightly higher.
• The hardest benchmark shows the gap that remains. On Terminal-Bench 4.0, 23.8% is well ahead of the other open models in this size class, and well below what proprietary models report: OpenAI reports 50.3% for GPT-6.1 Terra at maximum effort, for example, with its own harness.

None of this makes the numbers wrong. It means they are a reason to test the model, not a substitute for testing it.

Running it yourself

For a dense 33B model in BF16, the weights alone take roughly 66 GB before any memory for the key-value cache, and long contexts need a great deal of cache. The card's serving examples split the model across four GPUs. Quantised builds would cut the footprint, at some cost to quality that you would need to measure. If your interest is in the 512K context, budget the memory for it explicitly; a server configured for short contexts will not deliver it.

The card's Transformers example passes trust_remote_code=True. When we looked on 27 October, the repository contained configuration and tokeniser files for standard Llama classes and no custom Python code, so the flag should not be needed to load it. As a habit, leave it off unless loading fails, read any code it would run, and pin the exact repository revision you have reviewed. Our earlier piece on open-weight model risk covers the wider checks.

How we would evaluate it

1. Use your harness, not theirs. Run it inside the agent you actually use, with your tools, prompts and tool-call format.
2. Use your tasks. Twenty to fifty recent, real tasks from your repositories, with known good outcomes, tell you more than any leaderboard row.
3. Repeat runs. Agent results vary; run each task several times and look at the worst run as well as the average.
4. Test thinking modes. Compare enable_thinking on and off, and preserve_thinking, since the card recommends different settings for different workloads.
5. Price the hardware. Compare the cost per accepted change on your own GPUs with the same work on a hosted model, including idle time.
6. Consider the sub-agent role. As we argued for small models as coding sub-agents, a mid-sized local model may earn its place on search, summarising and well-scoped fixes before it earns the main seat.

What it means for engineering and security leaders

Nanbeige4.3-33B adds a permissively licensed option in the size class many companies can host themselves. The card is clear about its harnesses and settings, which makes it easier to read than many releases. Its results are self-reported and come from several different harnesses, so treat them as a shortlist entry: pin the revision, avoid running remote code you have not read, and decide on the evidence of your own tasks.