Your agent loop is a token furnace, and the model you feed it decides whether the monthly bill looks like a coffee habit or a car payment. DeepSeek V4 — the model family that powers the DeepSeek Harness (dsh) agent framework by default — is priced at roughly $0.14 per million input tokens and $0.28 per million output tokens. On a single real task that burns half a million tokens, that works out to about a dime. The same task on a flagship-tier model is a different order of magnitude, and that gap changes how often you are willing to let an agent run at all.
This article walks through the numbers as the DeepSeek ecosystem’s own documentation presents them, does the arithmetic transparently with the assumptions labeled, and gives you a practical rule for when a cheap engine is the right call and when you should still reach for a flagship.
The price, as published
The figure appears in two of the source documents about the DeepSeek Harness:
The comparison post “DeepSeek Harness vs Claude Code / Codex / OpenCode” lists dsh’s cost as starting from $0.14/$0.28 per million tokens, attached to its default model, DeepSeek V4 Flash.
The post “DeepSeek Harness: What It Is” describes DeepSeek V4 pricing as about $0.14 / $0.28 per million tokens and calls it a fraction of flagship-model pricing.
So the working numbers you can rely on: ~$0.14 per M input, ~$0.28 per M output. Everything below is computed from those two rates.
V4 Flash vs V4 Pro
The DeepSeek V4 family in the ecosystem’s model list has two working tiers:
deepseek-v4-flash— the default engine for dsh, and the tier the $0.14/$0.28 rate is attached to.
deepseek-v4-pro— the higher tier, listed alongside Flash. The published docs do not give Pro’s per-token rate, so I won’t invent one; treat Flash as the cheap workhorse and Pro as the step-up option.
Both also ship as free preview models — deepseek-v4-flash-free and deepseek-v4-pro-free — which is where the rate limits come in (more in the limitations section).
Why cheap engines power agent stacks
The agent-loop pattern is what makes price per token the decisive variable. As the comparison post puts it, an agent loop is a token black hole — a real task consuming 500,000 tokens is common. The harness (the loop, tools, file system, shell) decides how many tokens a task spends; the model decides what each of those tokens costs. DeepSeek Harness is explicitly model-agnostic: it defaults to DeepSeek V4 but can be pointed at any OpenAI-compatible endpoint with one environment variable. Its sharpest selling point, though, is unit economics — running agents 30–100x cheaper. The same post states that the identical workload often comes to one-hundredth of the cost of a Claude Code flagship session or a Codex GPT-5.6 session.
Part of the discipline is architectural, not just about the model. dsh is built on the idea that Agent = Model + Harness: the model is the brain, and the harness is everything else — tools, file system, shell, sub-agent orchestration, context access, and knowing when to stop. Because the harness decides what the model actually sees, it also controls the token bill. Its spill storage, for example, writes oversized tool output to disk and hands the model only a locator, so context is no longer blown up by huge text blobs — the source describes this as the real origin of dsh’s “token-saving” reputation. The everything-is-a-plugin design also means you can trim a capability surface (give the agent terminal and file access, but not the network) or swap the provider with one environment variable, without patching a core.
The strategic bet, in the source’s own framing, is that agent frameworks have to be cheap enough to actually run at scale. The popularity numbers back that up: dsh crossed 20,000 GitHub stars in roughly an hour after open-sourcing, and the first day carried it into the 28,000–31,000 range.
The economics math
Let’s do the arithmetic on the source’s own “500K tokens per real task” figure. Agent loops are input-heavy: the bulk of tokens are context, file contents, and tool results, with a smaller share of model-generated output. I’ll show two splits so you can see the sensitivity, and the assumption is right there in the table:
Split (input / output) Input @ $0.14/M Output @ $0.28/M Total per task
80/20 → 400K in, 100K out $0.056 $0.028 ≈ $0.08
50/50 → 250K in, 250K out $0.035 $0.070 ≈ $0.11
At either split, one heavy task is roughly eight to eleven cents on DeepSeek V4 Flash. Run ten of those a day and you are under a dollar and a half. Run fifty and you are still in single-digit dollars per day.
Now compare against the flagship direction, using only the explicit numbers the sources give. A heavy Claude Code session on default flagship models runs to several to tens of dollars, and the same workload on DeepSeek V4 Flash is described as often one-hundredth of that. Eight cents against eight dollars is exactly that ratio, and the 30–100x unit-economics claim brackets the same range. On the Codex side the comparison post is blunter still: GPT-5.6 is a medium-cost default, and Fast mode bills at 2x the standard rate on top. The point isn’t that every task lands at exactly these cents — it’s that the order-of-magnitude gap is real, and it’s arithmetic, not marketing.
When cheap makes sense — and when it doesn’t
The same sources are refreshingly honest about the trade-off, and their selection rule is worth reproducing in substance:
Quality-first → Claude Code, whose reasoning depth and tool reliability remain the benchmark. When one correct answer saves you hours, the flagship premium pays for itself.
Ecosystem-first → Codex, if you are already inside OpenAI/ChatGPT and value Fast mode speed and OAuth login convenience.
Cost-first / high-frequency → dsh + DeepSeek V4 Flash or Pro. When agents run all day, per-token price is the whole game.
The practical pattern most people land on is routing by task: hard problems to a flagship Claude, high-volume daily work to cheap DeepSeek. One harness, two models, and the expensive model only appears when the cheap one’s ceiling is actually the bottleneck.
Honest limitations
dsh is a developer preview. Version 0.1.0-rc.5, explicitly labeled with breaking changes to come. Bet on the concept, not the API surface.
Cheap does not mean flagship quality. Reasoning depth and tool reliability on the flagship tier are still the benchmark; the V4 family trades those for price. If your agent’s correctness ceiling matters more than its burn rate, that is a real cost — just not a per-token one.
Free preview tiers are rate-limited. deepseek-v4-pro-free allows 50 requests per day and deepseek-v4-flash-free allows 200 per day. When the quota is exhausted, the docs tell you to switch to the paid deepseek-v4-pro / deepseek-v4-flash.
Latency is not free either. Large models in these stacks can take seconds to tens of seconds to emit a first token during the thinking phase — a fact the integration docs flag as normal rather than a failure.
Ignore the “Claude Code killer” framing. The sources explicitly call it media narrative — a 0.1.0-rc.5 preview “replacing” a mature product is premature. What is real is the architectural direction, not the headline.
Conclusion
DeepSeek V4’s ~$0.14/$0.28 per million tokens is not a marginal improvement; it moves an agent-heavy workload from “watch the bill” to “forget the bill exists.” The honest counterweight is equally clear in the sources: flagship models still own reasoning depth and tool reliability, so the winning setup is usually a mix — cheap engine for volume, flagship for the hard calls. Price per token decides how many agents you can afford to run; quality per token decides which tasks you should let them touch.
Top comments (0)