27B active, 650 GB on disk: how to size an MoE model

On 15 October 2026, StepFun, a Chinese AI lab, published the weights for its flagship model, Step 5 Preview, on Hugging Face. The company had announced the model on 20 September and said then that the weights would follow on 15 October. StepFun's own model card describes it as a sparse Mixture-of-Experts (MoE) model with 600B total parameters and 27B active parameters per token. According to the same card, it supports a context window of up to 1M tokens and accepts text, image and video input.

Almost every headline repeats that pair of numbers: 600B total, 27B active. If you run a box at home, 27B active sounds like a mid-size model, the kind you might fit on a couple of GPUs. It is not. The 27B is a compute figure. The memory figure is the other number in the same sentence, and the FP8 checkpoint alone is about 650 GB of weights. I have not run this model myself. Everything below comes from StepFun's model card and deployment table, the files published on Hugging Face, and the repository listing.

MoE VRAM requirements: two sizes, one model

In a dense model, every parameter takes part in every token. That is why size and cost move together. A 70B dense model does roughly 70B parameters' worth of work per token, and it needs roughly 70B parameters' worth of memory.

A sparse MoE model splits much of its network into many smaller blocks called experts. A small router decides, token by token, which few experts handle that token. So the active count, 27B here, is roughly what one token costs in compute. It sets the speed and the price per token.

The total count, 600B here, is what has to sit in memory. The router can send any token to any expert, and you cannot know in advance which experts the next token will need. All of them have to be loaded and ready. Compute follows the active parameters. Memory follows the total.

That gives you a rule you can apply before you download anything:

weight memory (GB) ~ total parameters (billions) x bytes per parameter

600B x 2 bytes (BF16) ~ 1,200 GB (1.2 TB)
600B x 1 byte (FP8) ~ 600 GB
600B x 0.5 byte (4-bit) ~ 300 GB

27B x 1 byte (FP8) ~ 27 GB <- what the headline makes you picture

FP8 stores about 1 byte per parameter and BF16 about 2. At FP8, Step 5 Preview needs roughly 600 GB for the weights alone; at BF16, roughly 1.2 TB. The published FP8 repository, stepfun-ai/Step-5-Preview, is split into 24 safetensors shards totalling roughly 650 GB. You can check that yourself by opening the repository's file list on Hugging Face and reading the sizes. Real checkpoints rarely land exactly on the estimate, but the rule puts you in the right range in ten seconds.

For any sharded checkpoint, two files save you the download. model.safetensors.index.json usually records the total size in its metadata. config.json usually shows how many experts the model has and how many are used per token.

What StepFun's deployment table actually says

The model card includes a deployment table from StepFun with these reference configurations:

• FP8 (stepfun-ai/Step-5-Preview): a single B300 node with 4 GPUs, or a single H200 node with 8 GPUs.
• BF16 (stepfun-ai/Step-5-Preview-BF16): a single B300 node with 8 GPUs, or two H200 nodes with 16 GPUs.

StepFun says to serve the model with vLLM or SGLang through an OpenAI-compatible API. There is also an NVFP4 variant. Notice that BF16 doubles the GPU count in every row. That matches the arithmetic: twice the bytes per parameter means twice the hardware.

Be honest with yourself about what this table describes. These are datacenter servers, each packed with several datacenter GPUs, usually rented by the hour. They are not cards that slot into a tower under your desk. The smallest configuration in the table is still a full server node.

The table also answers only one question: where the weights fit. It does not tell you how much context you get or how many people you can serve at once. That depends on what is left over.

KV cache: the weights are only the first bill

As the model reads and writes, each token in the context leaves behind keys and values. The server keeps these in memory so it does not have to recompute them. That is the KV cache, and it grows with two things: how long each conversation is, and how many conversations run at the same time.

This is why a 1M-token window is a ceiling, not a default. You can only use as much context as you have memory left after the weights are loaded. StepFun itself notes that usable context depends on the checkpoint, the serving framework and how the KV cache is allocated. I am not going to invent a per-token memory figure here. It depends on the model's architecture and on how the server stores the cache.

What you can do is set the limits on purpose instead of accepting the defaults. In vLLM, these are the flags that decide it:

• --max-model-len caps the context length per request.
• --max-num-seqs caps how many sequences run at once.
• --gpu-memory-utilization sets how much of each GPU vLLM may claim. Whatever is left after the weights goes to the KV cache.
• --tensor-parallel-size splits the model across the GPUs in a node.

When you size your own box, start from the context you actually use, not the number on the model card. If your real work is 16K-token chats for one person, size for that. Then multiply by the number of users or agents that will hit it at once. The same habit applies if you plan to share one GPU between several models: every model loaded is weights plus cache, and the cache is the part people forget.

What the 27B active count does buy

The active count is still useful. Each token only passes through a fraction of the network, so a sparse MoE model is cheaper and faster per token than a dense model of comparable total size. Once you have hardware big enough to hold it, that hardware can produce a lot of tokens, and token throughput is what hosting providers are paying for.

That is why models in this class show up high on usage-based leaderboards. OpenRouter's usage leaderboard, which ranks models by tokens processed through its API, had Step 5 Preview at number 2 for the week ending 15 October 2026, with about 19.5 trillion tokens processed.

Now the counterweight. Hugging Face's own counts, as of 16 October 2026, show about 144 downloads for the FP8 repository and about 126 for the BF16 one. Trillions of tokens on one side, a few hundred downloads on the other. For nearly everyone, running Step 5 Preview means calling an API on someone else's hardware.

How to size any MoE model before you download it

Go through these in order. Each step can end the conversation, so there is no point doing the later ones first.

1. Total parameters. Ignore the active count for memory. Read the total from the model card or config.json.
2. Bytes per parameter at the quantisation you would actually use. About 2 for BF16, about 1 for FP8, about 0.5 for 4-bit. Multiply. Quantisation changes the bytes per parameter, but not the instruction. A 4-bit version of a 600B model is still on the order of 300 GB, which is why there is no consumer-grade version of this one to download. By the same arithmetic, even the NVFP4 variant StepFun publishes stays in datacenter territory.
3. KV cache for the context you want, times concurrency. Leave real headroom after the weights, or the context window on the model card is a number you will never reach.
4. The licence. Step 5 Preview ships under the StepFun Model License 1.0, which makes it open weights under a custom licence, not an OSI-approved open-source licence. Read it before you build on it; our licence and memory checklist for open-weight models covers what to look for.
5. Can I rent it instead? The seller lists the hosted API at $1 per million input tokens and $2.70 per million output tokens. For short experiments, you can also rent a node that matches StepFun's deployment table by the hour. For a model this size, renting is usually the right call.

For the box at home, move down a tier. A smaller MoE or dense model whose total parameters times bytes per parameter fits your VRAM, with room left for the cache, will do more for you than a 600B model you cannot load. The checklist above works the same way at every size.

Allowed to run it is not the same as able to run it

Open weights mean you are allowed to run Step 5 Preview. They do not mean you can. The number that decides it is the 600B total, not the 27B active. The next time a headline leads with an active count, multiply the total by the bytes per parameter before you get excited.

If you want someone to size and plan a local AI stack that fits the hardware you actually have, see the services page. Fiverr: hiteshsaini459 - Upwork: hiteshsaini25