This guide uses source checks from Sep 3, 2026. Provider and gateway prices can change; preserve the checked date with every forecast.
Why This Topic Matters Now
The Sep 2 keyword report again points toward DeepSeek pricing, V4 access, OpenAI-compatible setup, and developer discussion around production routes. The useful update is not another Pro versus Flash ranking. It is a capacity runbook: how many concurrent agent steps are allowed, which price window was assumed, what happens when the cache pattern changes, and when a retry should stop.
This article is for Tier 1 and Tier 2 teams running coding agents, research workers, internal copilots, and long-context analysis jobs. It uses DeepSeek official pricing docs checked on Sep 3, 2026 and AIWave live gateway rows checked the same day. Direct-provider facts and gateway facts are intentionally separated so a buyer can compare options without blending different contracts into a single unverifiable number.
Source Facts Checked Today
DeepSeek official pricing docs checked on Sep 3, 2026 list V4 Flash and V4 Pro with OpenAI and Anthropic base URL notes, 1M context, 384K maximum output, cache-hit input, cache-miss input, and output token rows. The same table lists weekday peak and off-peak windows and says prices may vary. It also lists account-level concurrency limits of 2500 for Flash routes and 500 for Pro.
The Sep 2 keyword report captured the direct DeepSeek rows as follows: Flash cache-hit input at $0.007 off-peak and $0.014 peak, cache-miss input at $0.22 off-peak and $0.44 peak, and output at $0.66 off-peak and $1.32 peak per 1M tokens. Pro cache-hit input was $0.022 off-peak and $0.044 peak, cache-miss input $0.66 off-peak and $1.32 peak, and output $1.98 off-peak and $3.96 peak per 1M tokens.
AIWave /api/pricing checked on Sep 3, 2026 returned success=true, 63 records, pricing_version a42d372ccf0b5dd13ecf71203521f9d2, default group ratio 3, and VIP group ratio 1. Parsed DeepSeek gateway examples before account-group math were V4 Flash at $0.638 input, $1.914 output, and $0.020288 cache-hit input per 1M tokens, and V4 Pro at $1.914 input, $5.742 output, and $0.063736 cache-hit input.
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.
| Capacity field | Failure it prevents | Runbook rule |
|---|---|---|
| route_class | Pro tasks fall to short-execution routes silently | Classify planning, execution, review, and fallback |
| concurrency_budget | Worker pool exceeds provider cap | Set per-route worker ceilings below tested limits |
| price_window | Forecast assumes the wrong time band | Store UTC window and checked source date |
| cache_basis | Prompt change resets expected cache share | Version stable prefixes and reference packs |
| retry_class | Auth and capacity errors get the same retry | Use a controlled failure enum |
| max_output | Agent produces unbounded explanations | Set model-specific output caps |
| account_group | Finance cannot reproduce the bill | Record effective group and pricing_version |
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")
ROUTES = {
"planning": {"model": "deepseek-v4-pro", "max_tokens": 900, "max_workers": 20},
"execution": {"model": "deepseek-v4-flash", "max_tokens": 500, "max_workers": 80},
}
def run_agent_step(route_name: str, prompt: str):
route = ROUTES[route_name]
response = client.chat.completions.create(
model=route["model"],
messages=[{"role": "user", "content": prompt}],
temperature=0.15,
max_tokens=route["max_tokens"],
)
return {
"route": route_name,
"model": route["model"],
"usage": response.usage,
"max_workers": route["max_workers"],
}
Separate Price Windows From Gateway Rows
DeepSeek direct pricing has time-window rows. AIWave gateway rows checked today are stable gateway rows for the published route card and should not be described as DeepSeek direct peak or off-peak prices. Keep the two columns separate: direct provider, checked date, UTC window, model ID, token class, and amount in one table; AIWave gateway, pricing_version, account group, model ID, token class, and amount in another. That prevents procurement from approving a blended assumption.
Turn Concurrency Into a Budget
A published account-level concurrency limit is not the same as a safe worker pool size. Reserve headroom for retries, manual probes, background jobs, and bursty user actions. If direct V4 Pro concurrency is 500, a production runbook might start far below that during canary. If AIWave is used, the team should still set its own per-route worker ceilings and alert before saturation rather than waiting for user-visible errors.
Use Failure Classes
Agents should not retry every error the same way. Authentication errors should stop. Context overflow should reduce prompt size or route to a long-context plan. Capacity or rate errors can retry with backoff. Provider generation failures may retry once or move to a manually approved fallback. Store failure_class, attempt_number, model, route, price source, and stop reason with each attempt.
Protect Cache Assumptions
DeepSeek pricing separates cache-hit and cache-miss input. A repeated coding-agent preamble may look stable during testing and then change after policy text, repository summaries, tool manifests, or file selections are updated. Version the stable prefix and record cache-hit share when visible. If the prefix changes, mark the ledger as a new cost assumption instead of comparing it directly with last week's run.
Cap Output by Task Type
V4 Pro planning and V4 Flash execution should not share one max token setting. A planning task may need a longer rationale; an execution step may only need a patch outline or command list. Output can dominate spend, so the route config should contain max_tokens, temperature, and stop conditions per task class. Store the output cap beside the request so reviewers can reproduce quality tradeoffs.
Internal Links for DeepSeek Buyers
Readers evaluating DeepSeek should move through Pricing, Chat Completions, Models docs, Trust, the 1M-context access guide, and the 10M-token cost ledger. The internal path should make capacity and billing evidence easier to inspect.
Procurement Review
Procurement should ask which price window was used, whether the team compared direct and gateway rows separately, what account group applied, what concurrency ceiling was configured, and whether retries were bounded. Engineering should provide at least one redacted success row and one failure-class example. Security should verify that no production data was needed to prove the route mechanics.
Final Checklist
A DeepSeek V4 agent runbook is ready when route classes are named, concurrency budgets are lower than tested capacity, price windows are source-dated, cache assumptions are versioned, output caps are task-specific, retries are classified, and account group is recorded. Recheck DeepSeek and AIWave rows before procurement review because stale price assumptions are the easiest part of the system to miss.