StepFun Step 5 Preview: 27B active, but you still pay for 600B of memory
StepFun's Step 5 Preview has been on OpenRouter since October 8, 2026. StepFun had promised open weights for October 15, and the official Hugging Face repos (FP8, BF16 and a new NVFP4 build) were last updated that day. The card describes a sparse MoE with 600B total parameters, 27B active, and up to 1M tokens of context. The license is StepFun's own, not Apache or MIT.
"27B active" is the number people quote and the number that misleads. Active parameters set your per-token compute and decode bandwidth. Total parameters set how much memory you buy. This post covers that memory arithmetic and the license terms that decide whether you can use it commercially.
What actually shipped
From the model card and config.json:
| Item | Detail |
|---|---|
| Size | 600B total / 27B active. Hugging Face counts 604.3B parameters in the FP8 repo. |
| Architecture | 92 layers, mostly MoE with 352 routed experts, 8 per token, plus a shared expert. Attention mixes sliding-window layers (512-token window) and full-attention layers at roughly 3:1, using GQA with 4 KV groups and a head dimension of 192. Three MTP layers drive speculative decoding. |
| Context | Up to 1M tokens. OpenRouter caps output at 64K. |
| Checkpoints | FP8 (default), BF16, and an official NVFP4 build. Serving goes through dedicated vLLM and SGLang images. |
StepFun's validated hardware list matters more than any benchmark:
| Precision | StepFun-listed hardware |
|---|---|
| FP8 | 1 node × 4 B300, or 1 node × 8 H200 |
| BF16 | 1 node × 8 B300, or 2 nodes × 8 H200 |
8×H100 is not on the list, and the next section shows why.
Numbers that matter
Weights (illustrative arithmetic, 604B params):
| Format | Bytes/param | Weights |
|---|---|---|
| BF16 | 2 | ~1.21 TB |
| FP8 (E4M3, block scales) | ~1 | ~604 GB |
| ~4.5-bit (NVFP4 / Q4-class GGUF) | ~0.56 | ~340 GB (my estimate) |
KV cache (my arithmetic from config.json, BF16 KV as in the SGLang command): one full-attention layer stores 4 groups × 192 dims × 2 (K and V) × 2 bytes = 3,072 bytes per token. With about 23 full-attention layers that comes to roughly 70 KB per token. Sliding-window layers add a fixed ~100 MB per sequence, because their cache is capped at 512 tokens. I left the sparse indexer out of this. A 128K-token session is 131,072 × ~70 KB ≈ 9 GB; a 1M-token session is 1,048,576 × ~70 KB ≈ 74 GB.
What that means for hardware:
| Setup | Verdict |
|---|---|
| 8×H100 (640 GB HBM) | FP8 weights take ~604 GB, leaving ~36 GB across eight GPUs for KV, activations, CUDA graphs and MTP heads. It may load, but it won't serve. On H100, only a ~4-bit build would leave real headroom, and StepFun lists no Hopper path for FP4. Use H200 or B300 for FP8. |
| 8×H200 (8 × 141 GB ≈ 1.13 TB) | After FP8 weights there are ~500 GB of headroom. The vLLM example allows 64 concurrent sequences. At 128K each that's 64 × 9 GB ≈ 590 GB of KV, so concurrency rather than weights sets your ceiling. Plan on fewer long sessions or a shorter --max-model-len. |
| Mac Studio M5 Ultra, 512 GB | A ~4.5-bit build at ~340 GB plus 9 GB of KV for 128K fits comfortably. Decode is bandwidth-bound. 27B active × ~0.56 bytes ≈ 15 GB read per token, and 1.2 TB/s divided by 15 GB gives a theoretical ceiling of ~80 tok/s. My guess is that real-world speed lands at half that or less. Prefill is the real problem. Feeding a 1M-token context to an Apple GPU is a coffee break, not an interactive step. |
API pricing (OpenRouter, as listed): $1.00 per M input, $2.70 per M output, and $0.10 per M cache reads ($0.05 on inference.net). An illustrative agent task with 2M input tokens at a 90% cache hit rate and 40K output tokens costs 0.2M × $1.00 + 1.8M × $0.10 + 0.04M × $2.70 = $0.20 + $0.18 + $0.11 ≈ $0.49. For comparison, DeepSeek's MIT-licensed V4.1-Flash-1017 (552B total, 8B/16B active) is listed at $0.15 / $0.60 off-peak.
"27B active" is the number people quote and the number that misleads: active parameters set your per-token compute and decode bandwidth, total parameters set how much memory you buy.
The license is the real constraint
The card calls the StepFun Model License 1.0 "Apache-2.0-style". The grant is broad (use, modify, distribute, patents), but three clauses matter.
The first is an attribution trigger: if a commercial product using the model passes 100M monthly active users or US$20M in monthly revenue, you must display "Powered by StepFun AI". The second requires a separate commercial license for (i) hardware makers who ship the model's capabilities on devices such as phones, cars and wearables, and (ii) any company running a model-as-a-service business whose group revenue exceeds US$20M over 12 months; internal use that exposes nothing to third parties is exempt. The third makes distillation count as a derivative: "A model trained to a material extent on outputs of the Model is deemed to reproduce or contain a substantial part of the Model." If you planned to use Step 5 as a teacher, the license follows the student.
My read: for an in-house agent this is effectively open. For an inference provider or a device OEM, it's a sales conversation.
Where it sits
Vendor numbers relayed by Developers Digest put Step 5 Preview (High) at 67.7% on DeepSWE v1.1. That's level with Kimi K3 (67.5%) and GLM-5.3 (66.9%), and below V4.1-Flash-1017 (77.0%, DeepSeek-reported). Artificial Analysis gives it an Intelligence Index of 44 and calls it verbose. See also the trillion-scale tier and the Chinese share of OpenRouter usage.
What I'd do
Size for KV, not weights. Decide your max context and concurrency first, then pick FP8 on 8×H200 or 4×B300. Don't try FP8 on 8×H100. Treat the Mac Studio as a lab box: it works at ~4-bit on the 512 GB M5 Ultra for single-user evaluation at ≤128K, but don't plan on long-context production there.
Prefer the official NVFP4 build over community quants if you're on Blackwell, and re-run your own evals on it; StepFun publishes no FP4-vs-FP8 accuracy delta. Get legal to read section 2(c) before anything customer-facing, and before any distillation project. And budget for verbosity: if Artificial Analysis is right about output volume, output tokens will drive your per-task cost.
What I couldn't verify
I couldn't confirm the exact public date of the weights. The repos were created September 20 and updated October 15, and a third-party GGUF repo appeared October 2, but I couldn't confirm when the FP8 weights first became publicly downloadable. On benchmarks, StepFun's chart is an image; the numbers above are vendor-reported, relayed by an aggregator, and measured at the "High" setting. The NVFP4 size and accuracy are unknown: mine is an estimate, and StepFun publishes neither. The KV figures are my own arithmetic from config.json; engines may allocate differently, especially for the sparse indexer and MTP layers. Artificial Analysis rank and speed differ between snapshots (88 vs 220 tok/s), so I didn't use them.
I'll revisit when someone publishes measured decode and prefill numbers for the NVFP4 build on a single B300 node.
Sources
Primary: stepfun-ai/Step-5-Preview model card (Hugging Face); StepFun Model License 1.0 (LICENSE.txt); stepfun-ai/Step-5-Preview-NVFP4 (Hugging Face). Pricing and evaluation: OpenRouter: StepFun Step 5 Preview; Artificial Analysis: Step 5 Preview; Developers Digest: Step 5 Preview open weights Oct 15. Context: 9to5Mac: Apple unveils Mac Studio with M5 Max and M5 Ultra; DeepSeek-V4.1-Flash-1017 model card (Hugging Face).