StepFun Step 5 Preview: A 600B Sparse-MoE Flagship Cracks the Global Open-Source Top-3 on the AA Index, at 1/8 the Cost of Claude Opus 5
Introduction: A “Strong and Cheap” Flagship Raises the Bar
On September 20, 2026, StepFun, a Shanghai AI startup, dropped a heavy weapon it had been accumulating for a long time — a new generation flagship foundation model called Step 5 PreviewSource: IT Home. This was not a routine incremental update. For an open-source LLM company pushing toward a Hong Kong IPO, it was a re-anchoring of the industry’s coordinate system: a sparse mixture-of-experts (MoE) flagship with 600B total parameters and just 27B active parameters, scoring 44 points on the global Artificial Analysis Intelligence Index (AA Intelligence Index), ranking top-3 among open-source models worldwide; even more striking, its single-task cost is only one-eighth that of Anthropic’s Claude Opus 5Source: The Paper.
AI coding tools (Copilot, Codex, TRAE, etc.) have become one of the hottest commercialization tracks in large models, and a model’s performance on real-world agentic tasks has replaced “memorizing benchmark answers” as the core yardstick. The AA Index was just upgraded to v4.2 in early September — dropping the now-too-easy GPQA Diamond, adding two new evaluations, and doubling the private test set weight to 40% — an era in which models must demonstrate genuine reasoning on tasks they have never seen before“AA Intelligence Index v4.0 composition”.
Step 5 Preview enters precisely in this window where “real work” matters. This article unpacks its technology and business logic from multiple angles: the 600B sparse-MoE architecture, the economics of single-task cost, the AA evaluation methodology, the two vertical battlegrounds of coding and finance, and open-vs-closed-source cost competition.
First, an overview of its capability matrix:
Figure 1: Step 5 Preview Capability Matrix
┌─────────────────────────────────────────────────────────────┐
│ Step 5 Preview (600B total / 27B active) │
├─────────────┬───────────────────────────────────────────────┤
│ Architecture│ Sparse MoE, 600B total, 27B active (≈4.5%) │
│ Context │ 1M-token window │
│ Modality │ Native text + visual (image) input │
├─────────────┼───────────────────────────────────────────────┤
│ AA Index │ 44 points, top-3 open-source globally │
│ Single-task │ ≈1/8 cost of Claude Opus 5 │
│ Pricing │ $1 in / $2.7 out per 1M tokens │
│ Cost/task │ ≈$0.71 │
├─────────────┼───────────────────────────────────────────────┤
│ Software │ DeepSWE v1.1 67.7, tops open-source │
│ Finance │ FrontierFinance 66.4, #2 globally │
├─────────────┼───────────────────────────────────────────────┤
│ Open source │ Weights due 2026-10-15 │
│ Target │ AI coding / SWE / professional work / finance │
└─────────────┴───────────────────────────────────────────────┘
1. A 600B Sparse MoE: A “Team of Experts” That Summons Only 4.5%
Step 5 Preview uses a sparse Mixture-of-Experts (MoE) architecture. Today, MoE is mainstream in the large-model narrative: instead of one monolithic “omnipotent brain,” you have a row of specialists, and for each token only a small subset of experts actually computes, selected by a router — not the full parameter setSource: Shangguan News.
The official numbers: 600B total parameters, only 27B active — an activation ratio of roughly 4.5%. This means each inference only “wakes up” the 27B parameters chosen by the router; the remaining ~570B parameters sit idle as “knowledge reserves.” Such a design captures two windfalls at once: massive parameter capacity (knowledge coverage approaching trillion-parameter models) and disciplined per-inference compute cost (inference overhead approaching a small dense model of a few tens of billions).
Figure 2: Sparse-MoE Architecture (illustrative)
(Reconstructed from public descriptions of common MoE structure;
exact expert counts / per-layer allocations are not disclosed)
┌──────────────────────────────────────────────────────┐
│ Input Token (text/image) │
└────────────────────────┬─────────────────────────────┘
▼
┌──────────────────────────────────────────────────────┐
│ Router / Gating │
│ Block-wise Token Merging: merge high-overlap │
│ Top-k results → cut Indexer & Top-k cost ≈8× │
└──────┬──────────────┬──────────────┬─────────────────┘
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│Expert 1 │ │Expert 2 │ │Expert 3 │ ... ≈27B active
│(coding) │ │(finance)│ │(reason) │ only ≈4.5%
└────┬────┘ └────┬────┘ └────┬────┘
└───────┬──────┴──────┬───────┘
▼
┌──────────────────────────────────────────────────────┐
│ Weighted fusion → next layer (92-layer narrow/deep) │
└──────────────────────────────────────────────────────┘
Regarding MoE routing details, StepFun has only confirmed “sparse MoE, 27B active” without disclosing exact expert counts or per-layer configurations. Combined with industry convention and public technical descriptions, we can make a careful reading:
“Narrow and deep” depth scaling: According to a report by XinzhiYuan, Step 5 Preview uses a “narrow and deep” architecture that pushes Transformer depth to 92 layers, providing a longer propagation path for information during the long prefill phaseSource: XinzhiYuan. Deeper networks are friendlier to “long-distance information flow” under a 1M-token context — when context spans an entire codebase or an entire data room, longer inter-layer paths help model long-range dependencies. These are media-reported details; the exact layer count should be treated with caution pending the official tech report.
Sparsity is a systems problem, not just an algorithm one: Algorithmic sparsity does not automatically translate into faster systems. Sparse compute imposes different demands on GPU indexing and data-movement patterns — if implemented poorly, theoretical compute savings get eaten by fragmented memory access and inefficient attention. StepFun’s Block-wise Token Merging merges heavily-overlapping Top-k selection results across adjacent tokens, mitigating the GPU-utilization loss from fragmented compute — reportedly cutting Indexer and Top-k Selection cost by about 8×. This “last mile” from algorithmic sparsity to system efficiency is the engineering guarantee behind the “1/8 single-task cost” label.
What economic deal does MoE actually strike between params and activation? Understanding this is key to seeing why “600B yet cheap” is not contradictory. We quantify it with a cost model — the first core code block of this article:
TASKS = {
"step5": (1.0, 2.7),
"claude5": (8.0, 24.0),
"deepseek":(0.35, 1.0),
}
def cost(in_p, out_p, in_t=82000, out_t=95000):
return in_t/1e6*in_p + out_t/1e6*out_p
c = {n: cost(*p) for n, p in TASKS.items()}
for n in c: print(f"{n:>9}: ${c[n]:.2f}/task")
print(f"Step5 = 1/{c['claude5']/c['step5']:.1f} of Claude5")
This estimator reduces single-task cost to its simplest formula: cost = input tokens × input price + output tokens × output price, divided by number of tasks. For a medium-complexity coding/research deliverable, if token consumption is roughly equivalent, the cost gap is entirely decided by unit price — and higher unit price, compounded by inference that thrashes on speed, makes the per-task ledger ever harder to balance.
On the 4.5% activation point, a simplified simulation of the Top-k expert dispatcher shows why “many experts still don’t cost much.” Here is a Python reconstruction of the routing idea, plus a Go variant for reference:
import numpy as np
EXPERT = {0:"coding", 1:"finance", 2:"reasoning", 3:"vision"}
gating = np.array([0.1, 3.2, 1.5, 0.4]) # gate scores (illustrative)
probs = np.exp(gating - gating.max())
probs /= probs.sum() # softmax → normalized probs
top2 = np.argsort(probs)[::-1][:2] # simulate Top-k select (k=2)
active = {EXPERT[t]: round(float(probs[t]),3) for t in top2}
print("activated experts:", active)
total, active_params = 600, 27
print(f"activation ratio = {active_params/total*100:.1f}%")
print(f"forward touches only {len(active)} experts")
package main
import (
"fmt"
"math"
"sort"
)
func softmax(g []float64) []float64 {
m := g[0]
for _, v := range g[1:] {
if v > m {
m = v
}
}
s := 0.0
out := make([]float64, len(g))
for i, v := range g {
out[i] = math.Exp(v - m)
s += out[i]
}
for i := range out {
out[i] /= s
}
return out
}
func main() {
names := []string{"coding", "finance", "reasoning", "vision"}
scores := []float64{0.1, 3.2, 1.5, 0.4}
p := softmax(scores)
type kv struct{ name string; p float64 }
es := make([]kv, len(p))
for i := range p {
es[i] = kv{names[i], p[i]}
}
sort.Slice(es, func(a, b int) bool { return es[a].p > es[b].p })
for _, e := range es[:2] { // top-2 experts active
fmt.Printf("expert %-8s prob=%.3f\n", e.name, e.p)
}
fmt.Printf("active/total = %d/%d = %.1f%%\n", 27, 600, 27.0/600*100)
}
Both snippets demonstrate the same core message via softmax-normalized gate scores and a Top-k pick (illustrative k=2): a giant 600/27 split means a large knowledge space at a small per-call compute cost — that is the direct source of “cheap despite big.”
2. Single-Task Cost at 1/8: One Push of the Pareto Frontier
“Single-task cost is only 1/8 that of Claude Opus 5” — the sharpest marketing edge of Step 5 Preview, and also exactly the part that needs the most sober scrutiny. To understand this 1/8, one must distinguish unit price from cost-per-task.
On the AA accounting basis: Step 5 Preview costs roughly $0.71 per intelligence-index task, with input/output priced at $1 and $2.7 per million tokens, at about 100 output tokens per secondSource: Shangguan News. Claude Opus 5, as one of the most expensive closed-source flagships, is priced far higher; StepFun estimates that at comparable intelligence, its single-task cost is about one-eighth.
But a cold shower is warranted: this “1/8” reference is one of the most expensively priced models on the market. When we flatten the coordinates and compare under the same AA methodology against an open-source Chinese model of similar size, Step 5 Preview has not touched the industry’s cost floor. For example, DeepSeek’s latest V4.1 Flash completes a standard intelligence task at a weighted-average cost of about $0.27, versus $0.71 for Step 5 PreviewSource: National Business Daily.
This raises an interesting question: if only on absolute unit price Step 5 Preview does not win at a “floor price,” on what basis does it claim a cost advantage?
The answer is that StepFun is not fighting a price war; it is pushing the Pareto Frontier. In the industry, the Pareto frontier describes the optimal capability-vs-cost curve: each point is “the strongest intelligence currently achievable at this cost.” Pushing the frontier outward means the same cost buys stronger intelligence, and the same intelligence costs less. Step 5 Preview’s positioning is to move that line — achieving a 44-point AA intelligence score for $0.71 keeps it genuinely cheap in that score band, while DeepSeek V4.1 Flash pushing ~the same score for $0.27 flattens the cost axis even further. Each is advancing a different segment of the curve.
We use a multi-task cost simulation to show how single-task cost accumulates into an order-of-magnitude gap across a real agent workflow:
BATCH=[("bug",15000,4200),("feat",60000,48000),("ref",90000,61000),("env",45000,28000)]
MODELS={"step5":(1.0,2.7),"claude5":(8.0,24.0),"deepseek":(0.35,1.0)}
def batch(m):
ip,op = MODELS[m]
return sum(i/1e6*ip + o/1e6*op for _,i,o in BATCH)
c = {m: batch(m) for m in MODELS}
for m in c: print(f"{m:>9}: ${c[m]:.2f}/batch")
print(f"Step5 = 1/{c['claude5']/c['step5']:.1f} of Claude5")
print(f"Step5 = {c['step5']/c['deepseek']:.1f}× DeepSeek")
This simulation exposes a fact many overlook: single-task cost advantages are amplified exponentially through task duration and iteration count. A coding agent does not run once — it cycles through “read repo → write code → run tests → read errors → fix → re-run,” often a dozen or more times. Each iteration is an independent cost accumulation. So a “1/8 cheaper per call” can, in a long-horizon agent, end up as an order-of-magnitude gap in total batch cost.
To judge who actually sits on the Pareto frontier, we use the notion of domination: a model lies on the frontier when no competitor is both stronger and cheaper:
MODELS = {"step5":(44,0.71),"kimi_k3":(44,2.1),"deepseek_v41":(42,0.27),
"claude5":(52,5.6),"gpt6_astra":(52.8,4.8)}
def dominates(a, b): # a dominates b if no worse on both
ia,ca = a; ib,cb = b
return (ia>=ib and ca<=cb) and (ia>ib or ca<cb)
for n, p in MODELS.items():
beat = [m for m,q in MODELS.items() if m!=n and dominates(q,p)]
tag = "on frontier" if not beat else f"dominated by {','.join(beat)}"
print(f"{n:>13} ({p[0]}pts, ${p[1]}): {tag}")
The Pareto frontier is not a single point but a set of points no one beats in every dimension. Step 5 Preview’s 44pts/$0.71 stands on the “value” segment; DeepSeek’s 42pts/$0.27 pushes the cost axis lower; GPT-6 Astra sits at the “intelligence vertex” with 52.8pts/$4.8. They do not dominate each other; together they trace the true shape of the capability-cost frontier in September 2026.
Figure 3: Cost Comparison (AA accounting, illustrative)
Cost per completed AA intelligence task (input + output tokens)
$0.71 ─── Step 5 Preview ─── 44 pts
$0.27 ─── DeepSeek V4.1 Flash ─── similar pts
$5.6 ─── Claude Opus 5 (≈8× Step5) ┘
│
──────┴───────────────────────────────► cost higher
3. The AA Intelligence Index: From “Scoring High” to “Actually Working”
To appreciate the weight of Step 5 Preview’s 44 points, you must know the test it took. The Artificial Analysis Intelligence Index is one of the most respected comprehensive evaluations. Rather than a single benchmark, it decomposes AI capability into multiple deployable dimensions, runs them on standardized hardware, and produces a reproducible composite score“AA Intelligence Index v4.0 composition”.
Figure 4: AA Intelligence Index Dimensions (v4.x)
┌─────────────────────────────────────────────────────────┐
│ Artificial Analysis Intelligence Index │
├─────────────────────────────────────────────────────────┤
│ Agent real tasks GDPval-AA │
│ Tool use τ²-Bench │
│ Agent coding Terminal-Bench │
│ Coding ability SciCode │
│ Long-context AA-LCR │
│ Knowledge/anti-hallucination AA-Omniscience │
│ Instruction following IFBench │
│ Reasoning/knowledge Humanity's Last Exam │
│ Physics reasoning CritPt │
│ (v4.2+: two new evals; GPQA Diamond dropped as too easy;│
│ private test-set weight doubled to 40%) │
└─────────────────────────────────────────────────────────┘
Sensitivity to evaluation methodology is the core skill in reading this leaderboard. The AA Index was upgraded to v4.2 in early September: two new evaluations added, GPQA Diamond removed because it was too easy, and the weight of the largest private test set doubled to 40%Source: XinzhiYuan. The subtext is blunt — the era of memorizing answers is over. A 40%-weighted private test set means a model must score through genuine generalization on an AA-constructed task set it has never seen, rather than via training memory. Anyone whose training data leaked the eval questions will be severely punished by this change.
Against this harder test, Step 5 Preview earned 44 points. In the global frame: Claude Fable 5.1 leads at 53, GPT-6 Astra follows at 52.8, and Step 5 Preview’s 44 sits alongside the widely-discussed 2.8-trillion-parameter Kimi K3 (44), Zhipu’s GLM-5.3, and Qwen3.8 Max (45) — reaching the same score with less than one-fifth of Kimi K3’s parameter count, the most telling footnote to its efficiency narrativeSource: National Business Daily.
A benchmark is only an entry ticket; actually delivering is the report card. Here is a Python script that reproduces an AA-style evaluation pipeline (run benchmarks, normalize, weight-and-sum) with CLI parameterization, plus a context-window scheduler for the 1M-token scenario:
import json, subprocess, argparse
B = {"sci":("swe.jsonl",.15), "tau":("tau.jsonl",.15), "term":("term.jsonl",.15),
"hle":("hle.jsonl",.15), "lcr":("lcr.jsonl",.10), "omni":("omn.jsonl",.10),
"ifb":("ifb.jsonl",.10), "crit":("crit.jsonl",.10)}
def run(ds, ep):
cases=[json.loads(l) for l in open(ds)]
n=0
for cs in cases:
out=subprocess.run(["curl","-s",ep,"-d",json.dumps({"prompt":cs["prompt"]})],
capture_output=True,text=True).stdout
if cs["answer"].strip() in out: n+=1
return n/len(cases)
def index(ep, verbose=False):
w=0.0
for name,(ds,wt) in B.items():
acc=run(ds,ep); w+=acc*wt
if verbose: print(f" {name:>5}: acc={acc:.3f} w={wt}")
return w
if __name__=="__main__":
ap=argparse.ArgumentParser()
ap.add_argument("--ep",default="http://api.stepfun/v1/step5")
ap.add_argument("--verbose",action="store_true")
a=ap.parse_args()
print(f"AA-style composite ≈ {index(a.ep,a.verbose)*100:.1f}")
WINDOW = 1_000_000 # Step 5 Preview 1M context
class SlidingCtx:
def __init__(self, budget): self.budget=budget; self.buf=[]
def push(self, seg):
self.buf.append(seg)
total = sum(len(s) for s in self.buf)
while total > self.budget: # evict oldest when over budget
total -= len(self.buf.pop(0))
return total
sc=SlidingCtx(WINDOW)
for seg in ["<repo>...","<log>...","<doc>..."]*400000:
sc.push(seg)
print("kept tokens:", sum(len(s) for s in sc.buf))
This script turns “evaluation” from vague marketing into a repeatable engineering act: run each benchmark on a uniform corpus, compute accuracy, weight-and-sum, with CLI flags. It is also the standard workflow many open-source Chinese model teams use to gauge “how far from flagship we are.” The sliding-window scheduler illustrates how a 1M-token budget is kept “in front of the model” without running out during a long closed-loop task.
4. Coding Home Turf: StepCodeBench and the “3-Hour Self-Driven Hardware Hack”
If the AA Index is the overall standings, then software engineering is the battlefield Step 5 Preview truly wants to win — AI coding is the most mature, most crowded space in large-model commercialization. IDC data shows China’s AI coding market at about RMB 399 million in 2025, projected to surge to RMB 1.173 billion by end of 2026Source: National Business Daily. Copilot, Codex, and TRAE have already educated the market; the model’s underlying “code IQ” now sets the ceiling for all these tools.
Step 5 Preview’s software-engineering numbers are genuinely strong: 67.7 on DeepSWE v1.1, ahead of open-source peers like Moonshot’s Kimi K3 and Zhipu’s GLM-5.3, trailing only the two closed-source flagships GPT-6 Astra and Claude Opus 5Source: IT Home. Note that this is under long-horizon planning tasks — not solving LeetCode, but acting like a real engineer: taking over a project, reading existing code, planning a change, and landing it with verification.
StepFun built StepCodeBench specifically for this: 553 independent code repositories, 9 task types, 20 application domains, and 33 programming languages, covering bug fixes, feature development, refactoring, and environment configuration. In expert evaluations, about 70% of participants believed the new flagship can autonomously solve medium-to-high-complexity coding tasksSource: Shangguan News.
How do you run scored evals against a large code corpus in a disciplined way? The driver below mirrors the StepCodeBench-style loop: clone, perturb, run tests, decide pass/fail:
import subprocess, tempfile, shutil, glob, argparse
def run_stepcode(repo_url, task, ep):
d=tempfile.mkdtemp()
subprocess.run(["git","clone","--depth","1",repo_url,d],
check=True,capture_output=True)
tests = glob.glob(d+"/tests/test_*.py")[:8]
patch = gen_patch(task, ep)
if patch:
subprocess.run(["git","-C",d,"apply","-"], input=patch,
capture_output=True,text=True)
p = subprocess.run(["pytest","-q",*tests], cwd=d, capture_output=True)
shutil.rmtree(d, ignore_errors=True)
return "PASS" if p.returncode==0 else "FAIL"
def gen_patch(task, ep): # simplified: call model API → diff
return None
for repo in ["https://github.com/x/repo1","https://github.com/x/repo2"]:
print(repo, run_stepcode(repo,"bug_fix","http://api.stepfun/v1/step5"))
Automated real-repo evals (SWE-bench Verified, τ²-Bench) are, at heart, this loop: give a repo and a task, run tests, count pass rate. The value of long context hides precisely in operations like “read the whole repo, then change one spot,” which demand global understanding.
The experiment that best demonstrates “real work” is the one the media keeps citing: StepFun had Step 5 Preview, from a natural-language requirement, autonomously read extensive ESP32 device/API docs and turn an ESP32-S3 dev board into a Vibe Coding keyboard with Bluetooth buttons and voice input. It could not only write code but also access serial ports, take screenshots, call the camera, simulate mouse operations, and on the basis of real device status and errors continuously modify, run, and debug code — running autonomously for over 3 hoursSource: IT Home. This is not answering a question bank in a sandbox; it is acting as a remote engineer on physical hardware.
Why is long context so critical for coding agents? Because real development is not single-turn Q&A but a closed-loop workflow:
Figure 5: Coding-Agent Closed Loop (Step 5 Preview target scenario)
┌────────┐ ┌────────────┐ ┌─────────────┐ ┌─────────┐
│ Read │──►│ Plan/decompose│──►│ Write/refactor│──►│ Run tests│
│ repo │ │ (long-horizon)│ │ multi-lang │ │ CLI call │
│(1M ctx) │ │ │ │ + tools │ └────┬────┘
└────────┘ └────────────┘ └─────────────┘ │ error
┌─────────┐ ┌────────────┐ ┌──────────┐ │ retry
│ Deliver │◄──│ fit hardware│◄──│ env config│◄──┘
│ verify │ │ (physical) │ │ sandbox │
└─────────┘ └────────────┘ └──────────┘
In this loop, the model must continuously ingest new information (errors, logs, docs), revise its plan, and re-execute — without losing global understanding of the context. A 1M-token window exists precisely so that the entire task chain’s state stays “in front of its eyes,” rather than being forgotten as in earlier agents.
Self-correction and honesty also matter enormously in long-horizon agents. XinzhiYuan reports that Step 5 Preview’s data-production and training pipeline includes Anti-hacking checks, stopping the model from exploiting task or benchmark loopholes to “look successful” without really solving the problemSource: XinzhiYuan. This explains why it holds up on a v4.2 leaderboard with 40% private test weight — its training target is “solve” not “memorize.”
5. The Finance Front: From “Answering Right” to “Producing a Usable Report”
StepFun made finance a key validation scenario for Step 5 Preview, and this is not arbitrary. Finance connects macroeconomics, regulation, industry cycles, and company operations — demanding hard expertise like financial-statement analysis and valuation modeling, while testing cross-industry understanding, evidence verification, and complex problem decomposition. It is a microcosm of what large models face in “super-long task chains, super-long context, and tool use.” The gap between “can answer a finance question correctly” and “can produce a logically closed, evidence-traceable company research report” is enormous.
The external benchmark FrontierFinance contains 220 professional finance questions, 11,543 evaluation criteria, covering six investment application scenarios. Step 5 Preview scores 66.4, ahead of GPT-6 Astra and all other open-source contenders, ranked second globallySource: Shangguan News.
Even more notable are the internal evals. Around the hard “company research” workflow, StepFun built three internal evaluations (FinStepBench) testing the model’s ability to retrieve and verify real-time financial information, turn data and assumptions into reproducible valuations, and produce a complete research report. On all four finance benchmarks, Step 5 Preview achieved the leading open-source result.
Why does finance expose a model’s true quality? Because a financial researcher’s work is essentially a multi-level evidence chain: you cannot trust a data point directly; you must trace it, cross-verify it, check the timestamp and the accounting basis. Per XinzhiYuan’s testing, Step 5 Preview applies a seven-level priority for financial-fact verification (audit report > company restatement > first-hand verification > official press release > business plan > data platform > anonymous posts), plus auxiliary rules such as “basis precedes number” and “timestamp alignment”; in one check, seven factual items were all answered correctly, with 35 citations precise to file and line numberSource: XinzhiYuan. This “stand by the rules when intuition disagrees” ability is the joint product of long context, strong reasoning, and honest alignment.
Here is an SDK-style example packaging Step 5 Preview into a stateful, multi-turn investment-research agent (extract → verify → value → report, with a step trail):
import requests, json
class ResearchAgent:
EP="https://api.stepfun.ai/v1/research"
def __init__(self, doc): self.doc=doc; self.steps=[]
def _call(self, prompt, mx=800):
r=requests.post(self.EP,json={"model":"step-5-preview",
"messages":[{"role":"user","content":prompt}],"max_tokens":mx})
return r.json()["choices"][0]["message"]["content"]
def extract(self):
p=("Extract {revenue,gross_margin,net_income,rd_expense}; "
"mark [unverified] if not audited. JSON only.\n"+self.doc[:6000])
self.steps.append("extract"); return json.loads(self._call(p))
def verify(self, claim, srcs):
p=("Verify claim using sources ranked: audit>press>platform>anon.\n"
f"claim:{claim}\nsources:{json.dumps(srcs,ensure_ascii=False)}")
self.steps.append("verify"); return self._call(p)
def report(self, outline):
p=("Produce a complete research report following this outline "
"with citations to file+line.\n"+outline)
self.steps.append("report"); return self._call(p, mx=2000)
ag=ResearchAgent(open("r.txt").read())
print("metrics:", ag.extract())
print("trail:", ag.steps)
PRIORITY = ["audit","restatement","first_hand","press","plan","platform","anon"]
def verify_fact(claim, srcs):
ranked = sorted(srcs, key=lambda s: PRIORITY.index(s.get("kind","anon")))
for s in ranked:
s["weight"] = max(0.0, 1.0 - PRIORITY.index(s["kind"])*0.1)
prefs = [f"{s['file']}:{s['line']} [{s['kind']} w={s['weight']}]" for s in ranked]
return "basis-first, timestamp-aligned", prefs
print(verify_fact("rev +12% YoY", [
{"kind":"audit","file":"a.pdf","line":3},
{"kind":"anon" ,"file":"post.md","line":1}]))
This code turns an “investment-research agent” into an object with a step trail (extract→verify→report): it extracts structured metrics from financial text, cross-verifies key claims by source priority, and finally emits a fully cited report. The 1M context, long closed-loop tasks, and tool use emphasized earlier become real engineering value here — the model swallows the whole report context and returns judgments with traceable source priority.
6. From Flash to Flagship: A Three-Generation “Efficiency-First” Lineage
Step 5 Preview is not a spur-of-the-moment bet on efficiency; it is a main line already running for three generations. Stringing the three foundation models together reveals a company deliberately “constraining scale and grinding efficiency”:
| Model | Total | Active | Context | Positioning |
|---|---|---|---|---|
| Step 3.5 Flash | 196B | 11B | 256K | Agent brain |
| Step 3.7 Flash | 198B | ~11B | 256K | + native vision |
| Step 5 Preview | 600B | 27B | 1M | Flagship workhorse |
An easily missed detail: Step 3.5 Flash and Step 3.7 Flash kept total params nearly flat (196B → 198B), both with 11B active — StepFun deliberately held scale and earned efficiency within the same size before deciding to expand. Per analyst Tian Feng’s reading, this verify-then-scale rhythm demonstrates a more disciplined engineering self-restraint than a “bigger always wins” routeSource: National Business Daily.
This also taps a sector-wide inflection point. Anthropic CEO Dario Amodei has argued that Scaling laws themselves have not failed, but the efficiency of turning compute into intelligence is becoming the new dimension of competition. When the marginal benefit of adding transistors declines, Moore’s Law’s historic inflection shifted the competitive focus from “count” to “per-watt performance” — large models are replaying the same script. Moving from “more compute → stronger intelligence” to “more efficient compute → stronger intelligence” is Step 5 Preview’s strategic bet on its technical routeSource: media.
Training-wise, Step 5 Preview also made agent-oriented adjustments. Per XinzhiYuan: in its data-production pipeline, the agent not only generates samples but participates in knowledge exploration, task design, difficulty-and-diversity control, and dynamic orchestration of the whole flow; training is optimized across train-inference consistency, training efficiency, and long-trajectory learning; on the algorithmic side, Context Compaction and finer-grained reward allocation let the agent push through longer tasks within a limited contextSource: XinzhiYuan. This “agents produce data → feed back to agents” loop is the internal reason for its stability on long-horizon agent tasks.
7. The Chinese Coding-Model Landscape: Many Contenders, Each Holding a Slice
Pulling the lens back, Step 5 Preview is just one footnote in the “weekly reshuffle” of the September 2026 Chinese model wars. Placing the current leaders on one map:
Figure 6: Chinese Coding-Model Landscape (Sept 2026 overview)
┌─────────────────────────────────────────────────────────────┐
│ Model │ Scale │ Open │ Signature │
├──────────────────┼─────────────┼──────┼──────────────────────┤
│ Step 5 Preview │ 600B/27B │ open │ sparse-MoE efficiency │
│ Kimi K3 │ ≈2.8T │ open │ huge scale, agent │
│ Qwen3.8 Max │ undisclosed │ open │ general flagship, eco │
│ GLM-5.3 │ undisclosed │ open │ coding+agent, balance │
│ DeepSeek V4.1F │ sparse MoE │ open │ extreme value, floor │
│ GPT-6 Astra │ closed flag │ closed│ strongest all-around │
│ Claude Opus 5 │ closed flag │ closed│ agent+coding, costly │
└─────────────────────────────────────────────────────────────┘
This map surfaces several key divergences:
Open source is eating the “value” mindshare of closed source. The top of the AA leaderboard is mostly closed-source, but Kimi K3 entering the global top-5 with open weights was already a milestone; Step 5 Preview is another open-source player squeezing into the core competition zone — the ceiling of Chinese open-source capability is accelerating upwardSource: XinzhiYuan.
Competition is shifting from “price” to “ecosystem.” Industry reporting in mid-September repeatedly stressed that the core logic of Chinese model competition has moved from price war to ecosystem war. A flashy “low price” is easily covered by bigger players’ subsidy wars, and just as easily flattened by the industry-wide 12–18-month inference-cost decline. Step 5 Preview framing “cost advantage” as “efficiency is the method, cost is the result” is fundamentally accumulating engineering methodology for ecosystem competitionSource: National Business Daily.
Vertical finance is the differentiation blue ocean. Coding is a red ocean; finance is a blue one. When every flagship is competing on code, whoever also stands firm on “long-horizon planning + finance expertise + evidence verification” earns one more reason for developers to choose them. Step 5 Preview’s global #2 in finance is a deliberate differentiation play.
A sobering point: the dense cadence of Chinese model releases is diluting the value of “topping a chart.” As Tian Feng puts it: what matters is no longer a single ranking, but whether you can keep running a steeper slope than competitors between the cost curve and the intelligence curveSource: National Business Daily.
8. Open-Source Timeline and Ecosystem: The “Final Exam” on October 15
Step 5 Preview has already fully opened its third-party API, and StepFun has announced it will open-source the complete weights on October 15, 2026Source: The Paper. Until then, developers can only probe its ceiling via the API; what really decides whether it “returns to the global first tier” is the post-release “real-world test” — once anyone holds the weights, they can verify with their own benchmarks, private data, and real scenarios whether that 44-point score is genuine.
Figure 7: Open-Source Timeline
2026-09-20 Release Step 5 Preview, open third-party API
│ AA 44 pts / global open-source top-3
│ Co-launched: StepAudio 3 voice family
▼
2026-09-20~10-15 Developer API trial (long-agent/finance/coding)
▼
2026-10-15 Release complete weights (formal open source)
▼
post-open Community self-benchmarks / private deploy / tooling
StepFun’s “model + terminal” strategy is also charging for this open-source moment. Per public information, StepFun models have been installed in more than 42 million phones, serving nearly 20 million requests daily, and are embedded in more than half of leading Chinese handset brands; on the automotive side, the partnership with Geely has reached the whole-vehicle agent level (Super Eva)Source: XinzhiYuan. 42 million installs means StepFun models are continuously tested under real noise, complex environments, low compute, low latency, and high concurrency — real-world feedback that feeds back into flagship training and alignment. Open-sourcing Step 5 Preview is equivalent to opening its “efficiency engineering” base capability to the entire industry.
Figure 8: Finance Deployment Topology (illustrative private deployment)
┌──────────────────────────────────────────────────────────┐
│ Financial institution / R&D team │
│ │
│ ┌────────┐ ┌───────────────┐ ┌──────────────────┐ │
│ │Compliance│──►│ Step5 inference│◄───│ Local KB / RAG │ │
│ │(auth/audit)│ │ cluster (MoE/27B)│ │ (reports/filings)│ │
│ └────────┘ └──────┬────────┘ └──────────────────┘ │
│ │ │
│ ┌─────▼─────────────────────────────┐ │
│ │ Investment-research agent │ │
│ │ extract→verify→value→report │ │
│ └───────────────────────────────────┘ │
└──────────────────────────────────────────────────────────┘
package main
import "fmt"
type ctxWin struct{ budget int; buf []string }
func (w *ctxWin) push(seg string) int {
w.buf = append(w.buf, seg)
total := 0
for _, s := range w.buf {
total += len(s)
}
for total > w.budget && len(w.buf) > 0 {
total -= len(w.buf[0])
w.buf = w.buf[1:]
}
return total
}
func main() {
w := &ctxWin{budget: 1_000_000}
segs := make([]string, 0, 400)
for i := 0; i < 400; i++ {
segs = append(segs, "<repo>...<log>...<doc>...")
for _, s := range segs {
w.push(s)
}
}
fmt.Println("window budget:", w.budget)
fmt.Printf("active/total experts=%.1f%%\n", float64(27)/600*100)
}
DECK = {"coding":(1.0,2.7),"research":(0.9,2.4),"translation":(0.5,1.6)}
def schedule(tasks, budget):
plan=[]; spend=0.0
for name,in_t,out_t in tasks:
ip,op = DECK.get(name,(1.0,2.7))
step = in_t/1e6*ip + out_t/1e6*op
if spend+step <= budget:
plan.append((name,round(step,2))); spend+=step
else:
plan.append((name+":defer",round(step,2)))
return plan, round(spend,2)
plan,b = schedule([("coding",20000,34000),("research",40000,60000),
("translation",12000,9000)], budget=0.40)
for p in plan: print(p)
print("used:", b)
Conclusion: 44 Points Is the Entry Ticket; “1/8” Is the Mirror
Back to the opening judgment: Step 5 Preview is a by-the-book “pass,” but still a step short of a true generational leap.
The 44-point AA score, the global open-source top-3 ranking, the “1/8 single-task cost” marketing edge — all are real achievements worth recording. But treating “1/8” as a no-questions-passed ticket would ignore two uncomfortable facts: first, the reference is “the world’s most expensive closed model,” and when the coordinate shifts to DeepSeek, Step 5 Preview has not touched the cost floor; second, on both DeepSWE software engineering and FrontierFinance finance it ranks “just below closed-source flagships,” which means it has not yet genuinely surpassed the closed-source ceiling on any decisive test.
What makes Step 5 Preview truly worth the industry’s attention is not any single score, but that it has turned “efficiency” from a buzzword into verifiable engineering methodology — from the 4.5% activation of its sparse MoE, to the ~8× cost cut of Block-wise Token Merging, to the restrained three-generation “small-to-big” rhythm. As the whole industry moves toward a “capability × efficiency” comprehensive competition, this accumulation of “per-watt intelligence” is the deepest moat in the next reshuffle. The open-source release on October 15 is the ringing of the bell for this final exam.