This guide uses source checks from Sep 17, 2026. Provider and gateway prices can change; preserve the checked date with every forecast.
Why This Topic Matters Now
Agent teams often promote a model because the first demo feels fast. That is not enough for production API budgets. StepFun's public platform was reachable during the Sep 17 source check, and search-indexed documentation describes Step 3.7 Flash and Step 3.5 Flash as agent-oriented routes compatible with common agent harnesses. The budget question is not whether a request can run; it is whether the agent stops predictably, reports usage clearly, and avoids hidden retry loops.
This guide creates a StepFun canary process for AIWave users. It uses current AIWave base rows for step-3.5-flash and step-3.7-flash, keeps live group ratios explicit, and builds a route ledger that product, finance, and reliability reviewers can read together. The result is a repeatable acceptance gate before a tool-using agent workload is allowed to move from staging to production.
Source Facts Checked Today
AIWave /api/pricing checked from the production server on Sep 17, 2026 returned HTTP 200, success=true, 64 live rows, pricing_version a42d372ccf0b5dd13ecf71203521f9d2, auto_groups=['default'], and group_ratio default=1 and vip=0.9. The static /api/v1/pricing endpoint checked during the same run returned HTTP 200, checked=2026-09-10, currency=USD, unit=per_1m_text_tokens, pricing_version 8c7a0c0b30661ccbc13d142cb54d1e4ae445fe774b2c6fa501080db97c7a3e56, and 64 model rows. VIP-key estimates multiply the same base rows by 0.9; the public base table itself remains default x1.
AIWave public pricing JSON checked on Sep 17, 2026 lists step-3.5-flash with effective_date 2026-08-27 at $0.21 input, $0.042 cache-hit input, and $0.63 output per 1M tokens. It lists step-3.7-flash at $0.40 input, $0.08000000000000002 cache-hit input, and $2.4000000000000004 output per 1M tokens. The live route table confirms both routes are enabled for default, vip, and svip groups through the OpenAI-compatible endpoint type.
StepFun's public platform page returned HTTP 200 in the Sep 17 check. Search-indexed text from the official platform describes Step 3.7 Flash as a high-efficiency Flash model for production-grade agents and mentions tool-calling protocols and common agent harnesses. Treat that as capability context, then confirm the route behavior in an AIWave canary before moving real workloads.
The Sep 15 keyword report still emphasized brand/API discovery, official pricing pages, and production routing evidence. A StepFun article therefore should not make broad provider claims. It should show how to run small route canaries, capture cost and stop behavior, and keep model routing auditable for Tier 1 and Tier 2 developer teams.
Planning Matrix
A source-dated planning matrix keeps the page useful for engineers and procurement reviewers. It turns a search query into an auditable route decision instead of a loose model preference.
| Canary check | Failure it catches | Evidence |
|---|---|---|
| Prompt class | Demo prompt differs from production tasks | task label and owner |
| Output cap | Agent expands answers unexpectedly | max_tokens by route |
| Retry ceiling | Transient errors multiply calls | retry count and final state |
| Stop reason | Agent keeps planning without stopping | finish reason or timeout |
| Cache policy | Repeated context assumptions are wrong | cache-hit row and measured share |
| Key group | Forecast applies wrong multiplier | default or vip receipt field |
Implementation Pattern
The implementation pattern keeps credentials as placeholders, pins the AIWave base URL, records the model, and leaves room for route-specific controls. Production applications should move credentials into environment or secret storage.
from openai import OpenAI
client = OpenAI(api_key="YOUR_API_KEY_HERE", base_url="https://aiwave.live/v1")
CANARIES = [
{"name": "short_plan", "model": "step-3.5-flash", "max_tokens": 350},
{"name": "agent_review", "model": "step-3.7-flash", "max_tokens": 800},
]
def run_stepfun_canary(canary, prompt):
response = client.chat.completions.create(
model=canary["model"],
messages=[{"role": "user", "content": prompt}],
temperature=0.1,
max_tokens=canary["max_tokens"],
)
return {
"canary": canary["name"],
"model": canary["model"],
"pricing_checked_at": "2026-09-17",
"usage": response.usage,
"finish_reason": response.choices[0].finish_reason,
}
Keep the Canary Set Small
A canary set should be small enough to run before every promotion. Use five to ten prompts that represent real agent work: planning, tool selection, code review, short synthesis, and error recovery. Do not include private customer data. The point is to observe route behavior, cost movement, and stopping behavior under controlled prompts before broader teams adopt the route.
Compare Flash Routes by Job
Step 3.5 Flash and Step 3.7 Flash may both be appropriate, but not for the same job. A short planning task can use a tighter output cap and lower-cost route. A deeper agent review may need the stronger route and a larger cap. The canary matrix should record which route won which task and why. That prevents a one-size-fits-all route from silently expanding spend.
Require Stop-Reason Receipts
Agent workloads need stop-reason evidence. If a canary returns because it completed, hit a token cap, timed out, or failed after retries, store that state. A useful canary record includes model, prompt class, source date, group, input tokens, cache-hit tokens when available, output tokens, retry count, finish reason, and final reviewer decision. Without stop reason, a passing canary can hide loop behavior.
Handle Retries as Budget Events
Retries are not merely reliability behavior; they are budget events. A StepFun route policy should define which errors are retryable, how many retries are allowed, and when the caller stops and escalates. Store the retry count in the ledger. This keeps transient capacity events from turning into uncontrolled repeated generation, and it gives support teams a clear artifact when a request fails.
Separate Tool Permission From Model Choice
The model route should not imply permission to use every tool. A canary may allow no tools, one retrieval call, or a small web-search allowance depending on task. Tool permission belongs in route configuration and should be visible in release review. That distinction lets the team promote a StepFun text route while keeping broader tool-using agent behavior in staging.
Internal Links for StepFun Readers
StepFun readers should be routed to Chat Completions, Models docs, Pricing JSON, Status, Trust, and retry-pattern controls. Those links turn agent-route interest into evidence-backed testing.
Procurement Notes
Procurement should receive one row per canary, not one blended paragraph. Each row should include route name, source date, base price, key group, prompt class, output cap, retry ceiling, tool permission, and result. If a route needs VIP-key estimates, show the default row and the 0.9 multiplier separately. That keeps the forecast auditable when a route moves between staging and production.
Final Checklist
A StepFun route is ready when the canary set passes, stop reasons are captured, retries are capped, tools are explicitly allowed or blocked, output caps match the task, cache assumptions are measured, and live pricing evidence is dated. Re-run the canaries before each route promotion or material prompt-template change.