How Much To Run AI
Open weights

Nanbeige4.3-33B: agent setup and long-context memory

Nanbeige4.3-33B is a downloadable text-generation model for coding and tool-driven work. The official release uses BF16 weights, a Llama-style dense architecture and a 524,288-token context limit. It is released under Apache-2.0. Long-context cache and the complete agent session determine the practical memory and cost.

Content reviewed:

Get the official model and deployment examples ↗
Nanbeige memory planning: roughly 66GB of BF16 weight arithmetic plus runtime state; ideal BF16 KV cache grows from 6.5GiB at 32K tokens to 104GiB at 512K.
Capacity arithmetic from the official configuration, not a measured allocation or a minimum-GPU recommendation.

Use this model

See access details in the guide below.

Use cases

  • Try one repository issue with explicit tests and tool permissions.
  • Compare a complete office or research workflow with your current agent.
  • Choose a context budget before renting GPUs for a long session.

Choose the instruction model and its current access path

This guide covers Nanbeige/Nanbeige4.3-33B, not the separately linked Base checkpoint or a planned smaller student. The publisher presents 33B as the teacher for its smaller-model distillation work. Its benchmark comparisons are publisher evaluations, with different harnesses across tasks; use a representative accepted task to decide whether it suits your work.

The model card supplies Transformers, SGLang and vLLM examples. It does not provide a direct-vendor token tariff or a verified minimum GPU configuration. Choose self-hosting from an identified checkpoint and runtime rather than borrowing a price or throughput from another 33B model.

Budget weights and context memory separately

At two bytes per parameter, 33 billion BF16 parameters give roughly 66GB of weight data before runtime allocations. This is weight arithmetic, not a measured download or peak memory. A quantized release changes that weight budget, while its cache format, buffers and offload placement still need separate accounting.

The official configuration has 52 layers, eight KV heads and a head dimension of 128. For an ordinary full BF16 key/value cache, 2 × 52 × 8 × 128 × 2 bytes gives 208KiB per cached token per sequence. The table shows this ideal cache alone; allocator overhead, attention workspace, concurrent requests and the weights add to it. A runtime using another cache precision or storage scheme needs its own measurement.

The model’s 512K limit therefore does not describe a fixed device requirement. Start with the context your actual prompt needs, include room for generated tokens and measure peak GPU and host memory. Reducing cache precision can change capacity and output behavior; compare the same task before accepting that tradeoff.

Cached tokens · one sequenceIdeal full BF16 KV cache
4,0960.8125GiB
32,7686.5GiB
131,07226GiB
524,288104GiB

Start with a short request before adding agent tools

Download the exact instruction checkpoint and use one of the card’s runtime recipes. Its SGLang and vLLM examples use tensor parallelism across four ranks and a 0.8 memory-utilization setting. They are launch examples, not proof that four GPUs are necessary or that every four-GPU machine fits the full context.

The tokenizer enables thinking by default. The publisher recommends preserve_thinking=false for general chat and true for multi-turn tool and coding workflows. It recommends XML tool-call format while also supporting JSON. Match the chat template, reasoning parser and tool parser in the chosen recipe before connecting an agent.

Begin with a short text question, check the response and record loading time and peak memory. Then try one repository task with a small test suite and a limited output budget. The official Transformers example enables trust_remote_code; review and pin the repository revision before using that option in your own environment.

Official-checkpoint vLLM launch pattern; requires your prepared GPU environment
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

A community W4A16 route for two RTX 3090s

Tonyd2wild publishes an AutoRound W4A16 recipe for two NVLinked RTX 3090 24GB cards with vLLM and GPTQ Marlin. The serving configuration caps context at 131,072 tokens and uses an FP8 e5m2 cache. This provides an Ampere-oriented route to try alongside the official full-precision examples.

The author reports 61–66 decoding tokens/s at concurrency one, with thinking disabled, temperature zero and 400-token outputs. The separate 69-scenario tool evaluation includes a failed money-transfer authorization case and ambiguous requests where the model guessed. Keep approval checks in the application for consequential actions; a tool-format score does not establish permission to execute them.

Use the repository’s exact launcher, weights and recorded test conditions when reproducing the result. Measure peak device and system memory for your own workload. A longer prompt, additional users or a reasoning-heavy request changes the serving budget; the short decoding test does not measure the duration of a repository task.

Price the whole accepted task

On a rented machine, bill the allocated session: model loading, prefill, generation, tool execution, retries and idle time. For illustration, a 30-minute session at an assumed $2 per GPU-hour costs $1 for one billed GPU, or $4 if four GPUs are each billed at that rate. These are budget examples, not a quote for hardware known to fit this model.

On a machine you already own, measure wall power over the full task. An assumed 400W system running for half an hour uses 0.2kWh; at $0.20/kWh, electricity is $0.04. Hardware purchase, storage and your time remain separate. Keep rejected attempts in the session total and divide by the number of results you accept.

Before you use it

  • A tool-using client must execute tool calls and return their results; the model itself does not run workspace commands.

How to get started

Pick the instruction checkpoint and a supported runtime, begin with a bounded context, then record complete task time and memory before scaling up.

Sources

Sources (4)

Calculators