Step 5 Preview Agent Cost: The Cache Decides

StepFun released Step 5 Preview (step-5-preview) on 8 October 2026. It is a 600B-parameter mixture-of-experts model with 27B active per token, a 1M-token context window and image and video input, and StepFun says open weights follow on 15 October. The pay-as-you-go price is $1.00 per million input tokens, $0.10 for cache hits and $2.70 for output.

On our standard 60-turn coding-agent session that works out to $1.25, a bit over half of what Claude Sonnet 5.5 or GPT-6.1 Sol cost for the same work. There's a condition attached. StepFun's cache is automatic, you can't pin it, and its docs say entries are evicted more aggressively at peak traffic. Every cache miss on the agent prefix bills at ten times the hit rate, and at a 75% hit rate the session costs more than Sonnet 5.5.

This post costs the session against six other models, shows how fast missed cache hits add up, and works out whether StepFun's Step Plan subscription is the cheaper way to run it inside Claude Code.

Table of Contents

• The rates, from StepFun's pricing page
• One agent session, seven models
• What a cache miss costs
• Reasoning tokens bill as output
• Step Plan credits vs pay-as-you-go
• Running it in Claude Code
• Benchmarks and the open weights
• FAQ
• Conclusion
• Sources

The rates, from StepFun's pricing page

Per million tokens, from StepFun's Pricing and Rate Limits page:

StepFun doesn't charge separately for cache writes. The page says the cache-miss price "includes writing new content to the cache", so the first time your prefix goes through, it bills at $1.00 like any other new input. Output includes reasoning tokens as well as the final answer.

OpenRouter lists Step 5 Preview with a $0.05 cache-read price, half of what StepFun's own page shows. I've used StepFun's $0.10 everywhere below. If you route through an aggregator, check what your invoice actually charges before trusting either number.

One agent session, seven models

This is the same session as our Sonnet 5.5 vs GPT-6.1 Sol comparison and the Mistral Large 4 preview post, so the numbers line up:

• 60 turns
• a 120,000-token prefix (system prompt, tool schemas, files read), written to the cache on turn 1 and re-read on the other 59 turns
• 3,000 new input tokens and 1,500 output tokens per turn

That is 7.38 million input tokens, 7.08 million of them cache reads, plus 90,000 output tokens. Every model below is priced at a 100% hit rate on the prefix.

*20 sessions a day for 22 working days (440 sessions). Totals use unrounded rates, so a row can be a cent off its rounded columns. Sonnet 5.5 uses the $0.10 cache-read rate Anthropic set on 7 October.

Cache reads cost exactly the same on Step 5 Preview as on Sonnet 5.5 and GPT-6.1 Sol: $0.10 per million, $0.71 for the session. The saving is all in the other three columns. New input is half the price, output is 27% of the price, and there's no $2.50 cache-write premium. On an agent workload where cache reads are 96% of input tokens, that adds up to a 45% smaller bill, and much less than the 50% to 73% you'd guess from the headline rates.

What a cache miss costs

Anthropic lets you mark cache breakpoints and pay for a one-hour cache. StepFun's prompt cache docs describe something looser: caching switches on above 256 tokens, eviction is LRU, and "during peak traffic, unused cache entries are evicted more aggressively". You can't force a hit. The FAQ says so directly.

So what you pay depends on a number you don't control. When a prefix read misses, those 120,000 tokens bill at $1.00 instead of $0.10.

Each 10 points of hit rate costs $0.64 a session, about $280 a month at 440 sessions. Below about 84%, a fully cached Sonnet 5.5 session is cheaper, and with explicit breakpoints and a one-hour cache option, a near-100% hit rate is easier to arrange on Anthropic's side.

You can measure this. Every response carries usage.cached_tokens next to usage.prompt_tokens. Log both for a day of real sessions and divide. If the ratio sits in the high 90s, Step 5 Preview is the cheaper model. If it drops in your working hours, run long sessions off-peak, which StepFun's docs suggest themselves, or keep the prefix shorter.

Three things break the hit rate in agent harnesses, and all of them are fixable:

1. A timestamp or session ID near the top of the system prompt. Put changing values at the end.
2. Tool schemas serialised in a different order on each request.
3. Long pauses between turns. An agent waiting on a human review comes back to a cold cache.

Reasoning tokens bill as output

Step 5 Preview always reasons. It supports low, medium and high reasoning effort, with medium as the default, and StepFun's pricing note says output tokens include the reasoning process. Our session assumes 1,500 output tokens per turn. If reasoning doubles that to 3,000, the session goes from $1.25 to $1.49. At 4,500 it's $1.74.

Output is cheap on this model, so reasoning hurts much less than a cache miss. Set reasoning_effort to low for turns that only read a file or run a command. The Chat Completions API takes reasoning_effort. The Messages API, which Claude Code uses, takes output_config.effort.

Step Plan credits vs pay-as-you-go

StepFun also sells Step Plan, a monthly subscription for coding tools like Claude Code, Cursor and OpenClaw. Usage is counted in Credits, and the overview page gives the conversion as roughly 7 million Credits to $1 of model usage.

At $1.25 a session, one session uses about 8.8M Credits. Our 440-session month needs about 3,850M, which fits inside Flash Pro at $29. The same month on pay-as-you-go costs $550.

That is a big gap, and I'd test it before relying on it. The conversion is described as approximate, the docs don't say whether a cache miss uses Credits at the miss rate, and Credits expire at the end of each month. Credits are still the right place to start for solo coding work. Run a week on Flash Plus, compare the Credits dashboard against your own count from usage, and only then commit to a yearly plan. Pay-as-you-go suits production traffic, where rate limits are set by your top-up tier: an individual account under $15 gets 100 requests and 500,000 tokens per minute.

Running it in Claude Code

StepFun publishes a Claude Code setup that points the client at its Anthropic-compatible Messages endpoint. Merge this into ~/.claude/settings.json, keeping your existing permissions and hooks:

{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "YOUR_STEP_API_KEY",
    "ANTHROPIC_BASE_URL": "https://api.stepfun.ai/step_plan"
  },
  "model": "step-5-preview"
}

That base URL is the Step Plan channel. Claude Code appends /v1/messages to it. StepFun tested the setup against Claude Code 2.1.209. Two optional variables are worth knowing about: CLAUDE_CODE_SUBAGENT_MODEL can send subagent work to the cheaper step-3.7-flash, and CLAUDE_CODE_AUTO_COMPACT_WINDOW sets when Claude Code compacts the conversation. Compaction rewrites the history, so the turn after it pays the miss rate on most of the prompt. That means a later compaction point is cheaper on this model as long as you stay inside the context you need.

If you'd rather paste the settings file than edit it by hand, run it through the JSON Formatter first. A trailing comma makes the file invalid JSON, and the settings won't load the way you expect.

Benchmarks and the open weights

StepFun's launch page compares Step 5 Preview at high effort against Kimi K3, GLM-5.3, GPT-6 Astra and Claude Opus 5, all at max effort:

It is close to GLM-5.3 on most rows and a long way behind on Terminal-Bench v4, which measures long shell-driven tasks. StepFun says itself that "on the most challenging long-running tasks, a meaningful gap to the frontier remains." If your agent mostly runs commands and reads their output, expect more turns per finished task, and cost those extra turns before you compare session prices. StepCodeBench is StepFun's own benchmark.

The open weights are due on 15 October. At 600B parameters the weights alone come to about 559 GiB at 8 bits and about 279 GiB at 4 bits, before any KV cache. That's eight 80 GB GPUs for an 8-bit copy, without leaving room for a 1M-token context. The AI VRAM Calculator gives the full figure once the config is published. Our local LLM VRAM guide explains why total parameters, not active ones, set the memory bill for a mixture-of-experts model.

FAQ

How much does Step 5 Preview cost? $1.00 per million input tokens on a cache miss, $0.10 on a cache hit and $2.70 per million output tokens, on StepFun's pay-as-you-go API. There is no separate cache-write charge.

Is Step 5 Preview cheaper than Claude Sonnet 5.5? For a 60-turn agent session with a fully cached prefix, yes: $1.25 against $2.27. The advantage disappears if fewer than about 84% of prefix reads hit the cache, because misses bill at $1.00 per million.

Can I control Step 5 Preview's prompt cache? No. Caching is automatic above 256 tokens, eviction is LRU and more aggressive at peak traffic, and StepFun does not support forced cache hits or manual clearing. Check usage.cached_tokens to see your hit rate.

Does Step 5 Preview work with Claude Code? Yes. Set ANTHROPIC_BASE_URL to https://api.stepfun.ai/step_plan, put your Step API key in ANTHROPIC_AUTH_TOKEN and set the model to step-5-preview. That route uses a Step Plan subscription.

When are the Step 5 Preview open weights released? StepFun says 15 October 2026. The model has 600B total and 27B active parameters.

Conclusion

Step 5 Preview runs our standard agent session for $1.25, 45% less than Sonnet 5.5 or GPT-6.1 Sol. The saving comes from cheaper new input and output, since cache reads cost the same $0.10 on all three. That makes the cache hit rate the number to watch. StepFun's cache is automatic and gets evicted harder at peak, and below about 84% hits the model is no longer the cheaper option. Log cached_tokens for a day, fix anything that changes the top of your prompt, and try Step Plan before paying per token for coding work. Plug your own token counts into the API Cost Calculator, which now lists Step 5 Preview and Step 3.7 Flash.

Sources

• StepFun, "Step 5 Preview: Advancing the Pareto Frontier" (stepfun.com/step-5-preview): 600B total / 27B active MoE, 1M context, vision input, open weights on 15 October, benchmark table and the long-running-task caveat.
• StepFun Docs, Step 5 Preview model page: model ID, 1M context, 64K max output, reasoning effort levels, prompt caching support.
• StepFun Docs, Pricing and Rate Limits: $1.00 / $0.10 / $2.70 for step-5-preview, step-3.7-flash and step-3.5-flash rates, cache-write note, individual account rate-limit tiers.
• StepFun Docs, Prompt cache best practices: 256-token minimum, LRU eviction, peak-traffic eviction, cached_tokens field, no forced hits.
• StepFun Docs, Step Plan Overview: plan tiers, monthly Credits, $1 ≈ 7M Credits conversion.
• StepFun Docs, Claude Code integration: settings.json fields, Step Plan base URL, tested Claude Code version.
• OpenRouter models API: listing date (8 October 2026) and the $0.05 cache-read figure that differs from StepFun's page.
• Comparison rates for GPT-6.1 Sol, Claude Sonnet 5.5, GLM-5.3, Mistral Large 4 and DeepSeek V4 Pro are from the ToolMintX API Cost Calculator dataset, which is read from each provider's pricing page. Session, hit-rate and Credit figures are calculated by ToolMintX from those rates.