Intel / article

StepFun Step 5 Preview: 600B open-weight agent model with NVFP4 recipes

Source: huggingface.co
Author: NVIDIA AI
Date: Published Oct 15, 2026

Context

Step 5 Preview is StepFun's flagship open-weights model for agentic work: long tasks in which a model repeatedly calls tools, runs code and revises its output. According to its model card, it is a sparse model with 600 billion parameters, of which 27 billion are active for each token, and it accepts up to a million tokens of context (Hugging Face model card). StepFun says it performs at frontier level on software engineering and professional knowledge work, with particular strength in finance. The benchmark tables behind that claim were not in the text available here.

The architecture is designed to keep long contexts affordable. SGLang's deployment guide says the language model has 92 layers, and each mixture-of-experts layer routes a token to 8 of 352 experts plus one shared expert (SGLang cookbook). Attention repeats a four-layer pattern. Three layers look only at the most recent 512 tokens. The fourth is sparse: it divides the earlier history into 8-token regions, uses a lightweight indexer to choose up to 512 of them, and attends to the actual tokens in those regions. Most layers therefore never read the whole history. The checkpoint also includes three extra prediction layers that draft upcoming tokens, so each step can advance by up to four tokens.

The checkpoint NVIDIA is promoting is the NVFP4 version. NVFP4 is a 4-bit number format that Blackwell GPUs handle natively. In the standard release, the routed experts are stored in 8-bit FP8. In this version they are stored in NVFP4, with the last three expert layers kept at BF16. SGLang says the smaller weights leave more GPU memory for the , the stored attention state that grows with context length. The trade-off is hardware: SGLang serves the NVFP4 version only on Blackwell, and it is not available on H200. vLLM's recipe serves it on four B300 GPUs with the context limit set to 320,000 tokens (vLLM recipe). The standard FP8 checkpoint also runs on four B300s, according to the model card; on H200 it needs eight GPUs, because SGLang says the FP8 weights do not fit on four. At release, SGLang support existed only in a preview Docker image.

NVIDIA's post says the model runs at nearly 8,000 tokens per second per GPU on GB300 with NVFP4, and that it is built for agent tasks lasting up to 24 hours (NVIDIA AI on X). Neither claim appears in the model card or the deployment guides, so both remain NVIDIA's. NVIDIA's NeMo AutoModel documentation also notes that the million-token figure is a configuration limit, not a validated training length. The model is licensed under the StepFun Model License 1.0, an Apache-2.0-style license with extra attribution and commercial-use conditions.

Key takeaways · AI-distilled

Step 5 Preview is a sparse MoE with 600B total and 27B active parameters and up to 1M tokens of context and output, which StepFun pitches at repository-level coding, long-horizon tool use and finance work.
StepFun's example BF16 layouts use eight B300 GPUs or two 8-GPU H200 nodes versus four B300s for FP8, and it warns they are a starting point for loading the weights that does not guarantee memory for a full 1M-token request.
On B300, the expert-parallel vLLM modes use the MegaMoE backend, which requires expert parallelism, while H200 uses the default MoE backend; the vLLM commands enable MTP with 3 tokens and SGLang uses EAGLE.
Setting --dtype bfloat16 on the FP8 checkpoint does not convert its weights, so BF16 needs the separate checkpoint, and StepFun says its BF16 Transformers shard workflow is not yet validated end to end.

Terms in this piece · Glossary

mixture-of-experts — A model built from many specialist sub-networks where only a few activate per token, giving big-model capability at small-model running cost.
KV cache — The memory a model keeps about text it has already read, so generating each new token doesn't require reprocessing the whole conversation.
speculative decoding — A speed trick where a small model drafts several tokens ahead and the big model verifies them in one pass, often doubling generation speed.
quantization — Shrinking a model by storing its numbers less precisely — like rounding — so it runs faster and fits on smaller hardware, at a small quality cost.

Read the source huggingface.co