The Same Hour the Weights Went Open, Domestic Chips All "Lit Up": Step 5 Preview's Day0 Adaptation and the Ecosystem That Is Closing"

If the past year’s open-source rhythm for Chinese LLMs was “a model launches, then chip vendors gradually adapt over the following weeks,” then October 15, 2026 rewrote that pace entirely. That day, Stepwise released the full weights of Step 5 Preview, and within the same hour, Huawei Ascend, Hygon DCU, Muxi Xivy, Biren Bili, Moore Threads MTT S5000, Kunlunxin… nearly all announced “Day0 adaptation complete.” No “weeks-long window,” no “please wait”—the weights landed and ran at once.

This isn’t an ordinary model release; it marks a scene becoming unusually smooth: large-model weights and domestic chips are shifting from “post-hoc software porting” to “born-together ecosystem co-development.” In this article, I want to unpack the technical details, the industrial logic, and what it means for China’s AI ecosystem, layer by layer. Anyone following the “model × chip” thread shouldn’t just stare at those glossy posters.

Part One: An Open-Source Checklist and a Closing Loop

First, the basics. On October 15, Stepwise officially opened the full weights of Step 5 Preview, releasing both BF16 and FP8 precision versions, along with a technical report, companion open-source tooling, and deployment guides. The weights went live on both Hugging Face and ModelScope; developers could stand up an OpenAI-compatible API service via vLLM or SGLang, or run offline inference with Transformers. In other words, the path from “getting the weights” to “running a service” was already quite mature.

What made this day special was the cascade of announcements that followed. Huawei said Ascend achieved 0Day support the day the weights went open, based on the vLLM reasoning engine and optimized around both the model architecture and the hardware’s characteristics; notably, the first 1,024-card Atlas 950 SuperPoD liquid-cooled supernode lit up the same day, claiming performance on par with advanced overseas compute. Hygon said its DCU completed Day0 inference adaptation and full-pipeline deep tuning; Muxi said its Xivy C series completed Day0 deep adaptation; Biren, Moore Threads, and Kunlunxin all jumped in, too.

Compressed into one sentence: a 600-billion-parameter flagship MoE went from “weights online” to “running stably on five or six domestic chips” in almost the span of a single press event. Two years ago that was almost unthinkable. It means the collaboration between model vendors and chip vendors has evolved from “you ship, I port” to “co-develop and jointly tune.” I call this “the ecosystem loop closing”—not because it’s one or two isolated adaptation stories, but because a repeatable, predictable coordination mechanism is beginning to take shape.

Part Two: What Step 5 Preview Actually Is—A Sparse MoE Built for Long-Horizon Agents

For that “closing loop” claim to hold, we first need to say why this particular model is special. Step 5 Preview isn’t a generic LLM that “changed the rules and climbed the leaderboard”; it’s an explicit “task machine.”

It uses a sparse MoE (mixture of experts) architecture with 600 billion total parameters, yet activates only about 27 billion per token during inference—a classic “big but sparse” design: the model “knows” a lot but only wakes the most relevant small team for each job, balancing capability against cost. It supports a 1 million-token context window, natively takes both text and vision input, and is optimized mainly for software engineering, professional knowledge work, and finance—the scenarios where real “long jobs” get done.

Its design orientation matters even more. According to the technical report, Step 5 Preview uses a 92-layer narrow-and-deep architecture, Sparse GQA (grouped-query attention), and heavy training-stability optimization. It folds context compression into end-to-end policy training—meaning the model learns how to compress “all the task state it has seen” into a compact, usable summary, so an Agent can maintain state, remember progress, and keep executing over the long haul instead of forgetting the beginning midway. It’s backed by “million-scale verifiable environments” and dedicated “long-horizon reinforcement learning,” so this long-range ability is forged from data and reward, not hand-written rules.

An analogy: if a general LLM is a “pundit who can chat about anything,” Step 5 Preview is closer to a “project veteran who can take on multi-week projects, remember every step, and know what to do next.” It wasn’t born to chat and climb; it was born to let an Agent actually finish the job.

In engineering terms, “big-but-sparse” works because of a clever expert-routing mechanism. Here’s a very simplified Go snippet to feel what “wake on demand” actually does for MoE routing:

// expert_router.go -- minimal MoE expert routing sketch (600B params / 27B active)
package main

import "fmt"

func route(token string, experts []int) []int {
	key := 0
	for _, c := range token {
		key += int(c)
	}
	start := key % len(experts)
	picked := make([]int, 0, 3)
	for i := 0; i < 3 && start+i < len(experts); i++ {
		picked = append(picked, experts[start+i])
	}
	return picked
}

func main() {
	experts := make([]int, 600) // total "knowledge surface"
	for i := range experts {
		experts[i] = i
	}
	for _, tok := range []string{"write code", "analyze finance", "reason step by step"} {
		picked := route(tok, experts)
		fmt.Printf("token=%q -> wake %d/%d experts, rest dormant\n", tok, len(picked), len(experts))
	}
}

This is highly illustrative, but it captures MoE’s core idea: total parameters set the “upper bound of what the model knows,” while routing decides “what each computation actually costs.” Step 5 Preview achieves 600B total / 27B active precisely by unifying “big storage” with “small compute”—broad memory with fast inference—at the architecture level, on top of this wake-on-demand foundation. That’s also why chip vendors’ Day0 adaptation must make routing dispatch fast and steady on their own silicon—it’s the doorknob through which this sparse architecture realizes its value.

Part Three: Is Open-Source Just “Posting Weights”? The Three Grinds Behind Day0

Many assume “open-sourcing weights” means uploading a file, and “chip adaptation” means running a hello world. In reality it’s far more complex—which is why Day0 adaptation carries genuine technical weight.

To get a 600-billion-parameter MoE “running and tuned the same day” on domestic chips, at least three things must be cleared. First, per-operator alignment. Attention, MoE expert routing, and various activations may map to different operator instructions and accelerated primitives on different chips; vendors must map each operator to their most efficient implementation and do fused-operator optimization (Ascend C, Triton, etc.), evening out compute bubbles. Second, memory and bandwidth scheduling. A 600B model, even FP8-quantized, needs hundreds of GB of memory to hold weights and KV cache; MoE also requires dynamic expert activation per token, demanding enormous inter-chip and memory bandwidth—why Huawei’s Atlas 950 supernode stresses 256TB unified memory addressing, TB-class inter-card bandwidth, and sub-3-microsecond latency: it’s built to serve this “big-but-sparse” dispatch. Third, deep reasoning-framework integration. From vLLM, SGLang to various custom engines, everything must be co-optimized against model architecture and hardware—speculative decoding, NPU graph execution, multi-stream parallelism—each the difference between “runs” and “runs fast.”

So you’ll notice these chip vendors’ wording almost always stresses “reasoning framework + software stack + hardware” as a full pipeline, not merely “I loaded the weights.” Adaptation is never a one-line command; it’s a recalibration of an entire inference system. When that recalibration is compressed to “release day,” it means the two sides began joint development long before launch—which is precisely the mark of a mature ecosystem.

To make “why a 600B model can fit in finite memory” more concrete, here’s a short Python snippet that estimates weight memory at different precisions and the cost saving of MoE routing:

# moe_memory_estimate.py -- rough weight-memory & activation saving for sparse MoE
def mbits(total_b, active_b, bytes_per_param):
    weight_full = total_b * 1e9 * bytes_per_param
    active_per_tok = active_b * 1e9 * bytes_per_param
    return weight_full / 1e9, active_per_tok / 1e9  # -> GB

for name, prec, bpp in [("BF16", "2B/param", 2), ("FP8", "1B/param", 1)]:
    full_gb, _ = mbits(600, 27, bpp)
    print(f"[{name} ({bpp} B/param)] full weights ≈ {full_gb:.0f} GB, "
          f"only 27B params activated per token")

activation_ratio = 27.0 / 600.0
print(f"MoE activation ratio: {activation_ratio*100:.1f}% of params per token "
      f"(the key to running a 600B model)")

The key line is activation_ratio—a 600-billion model needs to wake only 4.5% of its expert parameters per token, and with FP8 the weights’ footprint halves again, sharply cutting memory pressure and bandwidth demands. This is the core guarantee of “big but sparse”: the model “knows a lot” without “computing everything.” Day0 adaptation is precisely about landing that routing and dispatch efficiently on domestic silicon.

Part Four: Three Days in a Row: Agent Phones, a Price Hike First, Then Open Weights

If you only watch “open-source” and “adaptation,” you’ll miss Stepwise’s full chessboard. From October 13 to 15, the company made one move per day: an agent phone on the 13th, a Step 5 Preview API price adjustment on the 14th, and open-sourced weights on the 15th—spanning terminal, pricing, and model lines in quick succession.

The most “counterintuitive” move was the 14th’s API repricing: cache-hit input price doubled to 0.7 yuan per million tokens, while cache-miss input and output stayed flat. Under the dominant “LLM price-cuts” narrative, a non-Tier-1 model firm raising prices looks out of step. But read with timing, it makes sense—the weights were opening the next day; once users could self-host and bypass the API, the API had to first prove its price holds: the cache-hit premium becomes defensible now that they save the self-hosting-cluster cost. And putting the agent phone before open-sourcing aims to tell the model’s real-terminal scenario story first, so the “model + terminal + ecosystem” narrative stands before the weights flow.

This “three-day combo” is the product of a company weighing capital, competition, and product all at once: use open-source to gain ecosystem mindshare and developer hearts; use the terminal to tell scenario stories; and use sensible pricing to hold the API’s commercial floor. Open-source is never “giving it away free”—it’s a strategic move to be planned carefully.

Part Five: A Ladder View: Price, Benchmarks, Valuation, and IPO Rumors

Pull the lens back and Stepwise today sits in an interesting coordinate system. On OpenRouter, Step 5 Preview’s token usage briefly hit global No. 2 (weekly and daily), a hard-won position for one of China’s “Big Six” LLM startups. But its API price has no obvious edge over the tier’s top players—using DeepSeek-V4.1-Flash as reference, the latter’s cache-miss input and output prices at peak are roughly 11%, 29%, and 40% of Step 5 Preview’s current prices. In other words, Step 5 Preview wins on “differentiated capability for Agent and long-horizon tasks,” not “cheapest.”

On the capital side, Stepwise has long been swirled in “Hong Kong IPO” rumors. As early as May this year, reports said it closed a ~$2.5B raise and dismantled its red-chip structure to accelerate a HK listing. Though unlisted with no public books, its chairman Yin Qi also chairs Qianshi Technology: in H1 2026 that firm posted revenue of about 5.12 billion yuan, up 22.36% YoY, with adjusted net profit of ~55.7 million yuan turning around from losses—a “window” that adds concrete imagination about the model company’s supply-chain synergy. Of course, capital cares about two things: whether the post-reprice revenue elasticity holds, and whether the agent and terminal bets yield real paying users and profit. Many moves is one thing; a commercial loop is another.

Part Six: Three Judgments for Observers

Tying this together, here are three judgments worth considering.

First, don’t treat “domestic Day0 adaptation” as a one-off marketing gimmick—it’s a signal that “model × chip” is moving from cases to mechanism. When five or six domestic chip vendors can fully tune a 600B flagship model on the same day, long-term joint development and toolchain accumulation must be behind it. Once that capability forms, it compounds: the next model’s adaptation window keeps shrinking. That’s concrete progress against “compute being held hostage.”

Second, open-source and business aren’t at odds; being calculating is more mature. Stepwise’s “raise API price and ship a terminal before opening weights” gives every model firm that wants open-source ecosystem a mirror: weights can be open, but an API’s differentiated value, terminal scenario binding, and deep enterprise service are where mindshare turns into revenue. Open-source is open-source; business is business—they’re not mutually exclusive.

Third, the real divide isn’t “can it run” but “runs well and creates value.” Day0 solves “can it run,” but whether the model reliably creates value in real long-horizon tasks and complex software engineering—and whether developers stay and pay—is the test ahead. The ecosystem loop is closing on the technical end, but that’s only the first half.

The Day0 lighting is a declaration that “China’s LLMs and domestic chips are moving in sync.” It shows compute autonomy no longer depends solely on a single chip breaking through in isolation, but increasingly on “model, operator, framework, chip” advancing together across four layers. The substance of this picture weighs far more than an adaptation poster. How fast this loop spins, and how much real money it mints—time will tell.

• ←Previous
• Next→