AutomaterThe DeepSeek Effect: Open Models and the Collapsing Cost of Running Agents
DeepSeek collapsed the cost of running AI agents. We price one real workflow across three tiers — down to $0.14/M — and show you which steps to re-route.
Go deeper. Build your own.
Most DeepSeek coverage litigated geopolitics and one very bad day for Nvidia’s stock price. The durable story was always unit economics — and nobody feels unit economics like people who run agents all day. This is analysis for those people: what cheap open-weight models actually change about your token budgets, your routing, and which automations are worth running. If you came looking for an app download or a chatbot review, this will be a fast bounce, and that’s fine.
Here is the multiplier that makes agent builders the most affected audience. An agent task burns 10–100x the tokens of a chat exchange, because the loop re-sends growing context on every step. So a 25–45x price gap between model tiers doesn’t make your automation slightly cheaper — it flips whole categories of automation from not-viable to viable. We work the real arithmetic below.
The thesis, stated once: DeepSeek and the open-weight wave it accelerated have permanently lowered the floor price of an agent step, and the floor keeps dropping. As of August 2026 it sits at $0.14 per million input tokens — DeepSeek V4 Flash. The rest of this piece is what to do about that.
Where DeepSeek came from: the quant-fund origin
DeepSeek is a Chinese AI lab founded in 2023 in Hangzhou by Liang Wenfeng and owned by High-Flyer, the quantitative hedge fund he co-founded. It is known for open-weight models released under MIT licenses at prices far below Western frontier labs — currently the DeepSeek V4 line.
One paragraph of origin explains most of the behavior. High-Flyer had accumulated GPU clusters for trading research; those clusters became LLM training infrastructure, and the fund’s profits meant the lab never needed venture money or a consumer franchise. A self-funded lab with no subscription business optimizes differently: publish the weights, price near cost, ship on your own cadence. That explains the pricing strategy better than any conspiracy theory does.
| Fact | Detail |
|---|---|
| Founded | 2023, Hangzhou, China |
| Founder | Liang Wenfeng |
| Ownership | High-Flyer (quantitative hedge fund) |
| Known for | Open-weight models under MIT licenses at disruptive prices |
| Notable releases | V2 (May 2024), V3 (Dec 2024), R1 (Jan 2025), V4 (Apr 2026) |
| Current line | DeepSeek V4 Pro and V4 Flash; V3 and R1 deprecated July 24, 2026 |
The releases that moved markets
DeepSeek V2, May 2024. A large mixture-of-experts model priced at roughly $0.14 per million input tokens on the API — low enough that ByteDance, Alibaba, and Baidu cut prices within weeks. The Chinese LLM price war started here, and it was the first evidence that pricing itself was the product strategy.
DeepSeek V3, December 2024. The release behind the famous $5.6M number, which deserves handling responsibly: per DeepSeek’s own technical report, that figure covered the final training run’s GPU time (about 2.8M H800 GPU-hours), not total R&D — no research iterations, no ablations, no salaries. Correct the misreading, but concede the point underneath it: the efficiency genuinely shocked people who train models for a living.
DeepSeek R1, January 2025. Open-weight reasoning in the o1 class, MIT-licensed, with the training recipe described in public. The consumer app hit #1 on the U.S. App Store within days, and on January 27, 2025, Nvidia lost nearly $600B in market value — the largest one-day loss for any company to that date. The market was repricing a belief about how much compute frontier capability requires.
The pattern across all three: each release attacked one assumption about cost or capability, and open weights amplified every shock — because anyone could download the model, verify the claims, and re-host it at their own margin.
What DeepSeek shipped after R1
The post-R1 cadence stayed busy through 2025: an R1 refresh mid-year, V3.1 with hybrid reasoning in August, and a V3.2 efficiency release late in the year built on sparse-attention work, each arriving with another price cut.
Then the current era. DeepSeek V4 arrived April 24, 2026, and hit general availability July 19, 2026, in two forms, per the mid-2026 open-model roundups: V4 Pro, a 1.6T-parameter MoE with 49B active parameters and a vendor-reported ~80.6% on SWE-bench Verified, and V4 Flash, a 284B/13B-active model priced at $0.14 per million input tokens and $0.28 per million output — the credible price floor for agentic coding. Both are MIT-licensed with 1M-token context. The symmetry is worth savoring: $0.14/M is the sticker V2 wore in 2024, now attached to a model that can drive a harness credibly.
Five days after GA, on July 24, 2026, DeepSeek deprecated V3 and R1 on the first-party API. The open-weights asterisk matters: deprecation kills the endpoint, not the model — the weights remain downloadable via Hugging Face and third parties still serve them. But if your pipelines called deepseek-reasoner or V3-era aliases, you have migration work; our DeepSeek V4 migration guide walks through it.
Current lineup, verified as of August 27, 2026:
| Model | Released | License | Context | API price (per 1M in / out) | Status |
|---|---|---|---|---|---|
| DeepSeek V4 Pro | Apr 24, 2026 (GA Jul 19) | MIT | 1M | see api-docs.deepseek.com | Flagship |
| DeepSeek V4 Flash | Apr 24, 2026 (GA Jul 19) | MIT | 1M | $0.14 / $0.28 | The floor |
| DeepSeek V3 line | Dec 2024–2025 | MIT | 128K | — | API deprecated Jul 24, 2026; weights remain |
| DeepSeek R1 | Jan 2025 | MIT | 128K | — | API deprecated Jul 24, 2026; weights remain |
Why the costs actually collapsed
Sparsity. V4 Pro has 1.6T parameters, but only ~49B are active for any given token — about 3%. You pay inference on the active slice, not the whole model; that is the core trick of mixture-of-experts economics, and DeepSeek pushed it further than most.
Attention and precision. Two one-sentence versions: latent-attention KV-cache compression shrinks the memory an agent’s long context drags around, and low-precision (FP8-class) training cuts the cost of making the model in the first place. The honest note is that these gains compound — sparsity times cache compression times cheap training is how you get a 10x, not any single trick.
Distillation. Reasoning behavior gets compressed into small Llama- and Qwen-based variants that run on hardware you already own. That is the trickle-down mechanism: the frontier release this year becomes the laptop model next year.
And the real multiplier: open weights. MIT-licensed weights mean any host can compete on serving price, which drives hosted pricing toward marginal compute cost. Closed vendors now price against that floor whether they acknowledge it or not. This — not any single release — is the DeepSeek effect.
Agents are token loops: the economics nobody prices in
An agent task is a loop: plan, act, observe, retry, evaluate. Every arrow in that loop is tokens — and the quiet multiplier is that the context gets re-sent on every step. The tokens you were billed for are not the size of the conversation; they are the size of the conversation times the number of times the model re-read it. This is the defining cost structure of agentic software, and chat-era intuitions consistently underestimate it.
Here is the accounting from a real “fix this failing test” session in our own archive, not invented round numbers:
task: fix a failing pytest case (one-file patch, CI logs attached)
model calls: 14
context at call 1: 9,100 tokens (system + repo map + failing test)
context at call 14: 51,700 tokens (+ diffs, test output, retry state)
cumulative billed input: 387,400 tokens (context re-sent every call)
cumulative billed output: 11,240 tokens (plans, patches, tool arguments)
cache-hittable share: ~70% (stable prefix: system, repo map, files)Note the ratio: cumulative billed input is about 7.5x the final context size. Input, not output, dominates agent spend, which is why prompt caching matters more to agents than to any chat product — caching discounts exactly the re-sent prefix.
The loop bills you for the same context again and again: 14 calls turned a 52K-token task into 387K billed input tokens.
Now the threshold effect, which is the point most analysis misses. Chat pricing changes how much you spend; agent pricing changes what you attempt. A $2.20-per-run bug triage agent is not something you attach to every CI failure across forty repositories. A $0.02-per-run version of the same agent is. The task flips from not-viable to viable the moment per-run cost drops below what the outcome is worth — and a 40x price collapse crosses a lot of thresholds at once.
For anyone shipping agent features inside a product, the corollary is blunt: token price is a margin input and a strategy input, not a line item to reconcile at month-end. The operational discipline for treating it that way is the subject of our AgentOps guide.
The worked cost model: one workflow, three price tiers
Take the exact workload above — 387,400 input tokens (70% cache-hittable), 11,240 output tokens, 14 calls — and price it across three tiers as of August 27, 2026. Quality matters as much as price, so the last column is the pass rate on this task class from our own 50-run eval; without it the table would read as “cheap always wins,” which it doesn’t.
| Tier | Input $/M | Output $/M | Cache-read $/M | Per task (no cache) | Per task (70% cached) | Per 1,000 tasks | Pass rate (our eval, n=50) |
|---|---|---|---|---|---|---|---|
| Claude Fable 5 (frontier) | $5.00 | $25.00 | $0.50 | $2.22 | $1.00 | $998 | 92% |
| Claude Sonnet 5 (mid) | $3.00 | $15.00 | $0.30 | $1.33 | $0.60 | $599 | 88% |
| DeepSeek V4 Flash (floor) | $0.14 | $0.28 | $0.014 | $0.057 | $0.023 | $23 | 71% |
Two things the table earns. First, the spread: $998 versus $23 per thousand tasks — about 43x at list prices, and still 26x against the mid tier. That difference is not “savings”; it is the boundary between automations you run on everything and automations you ration. Second, the pass-rate column keeps the table honest: 71% versus 92% means the floor tier needs an escalation path, not blind trust. Run the cascade arithmetic and it stays compelling: send all 1,000 tasks to V4 Flash ($23), escalate the 290 failures to Claude Fable 5 ($290), and you land near $313 per thousand — roughly 69% off all-frontier — though escalated tasks are the hard subset, so expect the frontier pass rate on them to dip below its overall 92%.
Cache economics deserve their own sentence because they change agent math more than list prices do. Anthropic’s cache reads price at a small fraction of input with a write premium (terms in the Claude docs), and DeepSeek’s context caching is automatic, with cache hits at about a tenth of the input price — and since 70% of our workload was re-sent prefix, caching roughly halved the frontier bill in the table above. Your cache ratio depends on how your harness structures context; measure it before trusting anyone’s table, including this one.
Same workflow, three tiers: $998 vs $599 vs $23 per thousand runs — with the pass-rate caveat attached.
The routing pattern: frontier plans, cheap models grind
The pattern that falls out of the table: spend on steps where errors compound — planning, review, final verification — and route bulk steps (boilerplate, summarization, retries, test grinding) to cheap models. Three concrete shapes:
- Cascade with escalation. Cheap model first; escalate to frontier on a failed gate. Use when: high volume and a mechanical pass/fail check exists — tests, linters, schema validation.
- Planner/worker split. Frontier model writes the plan and reviews the result; cheap workers execute the steps. Use when: long multi-file tasks where a bad plan poisons everything downstream.
- Cross-family verification. A second model family reviews the first one’s diff or claims. Use when: correctness beats cost — different families have decorrelated blind spots.
The plumbing exists and is boring, which is a compliment: OpenAI-compatible gateways and routers (LiteLLM-class proxies, OpenRouter) and per-step model selection in most agent frameworks. By mid-2026, every serious CLI harness accepts at least one of OpenAI-compatible or Anthropic-Messages endpoints, per the mid-2026 harness map — so re-pointing a step is configuration, not surgery. Our best agentic AI tools guide covers which harnesses make per-step routing painless.
Routing has failure modes of its own. Model families drift on tool-call formats — the cheap path can fail on JSON quirks rather than reasoning — and an eval suite that only covers your frontier path is a blind spot generator. The rule: route only what you can evaluate.
Running DeepSeek and open-weight models in practice
Three paths, in decision-tree order. Pick the first one your constraints allow.
1. First-party API — cheapest, minutes of effort. Sign up at platform.deepseek.com, create a key, and point anything OpenAI-compatible at the endpoint:
export DEEPSEEK_API_KEY=sk-... # created at platform.deepseek.com
curl https://api.deepseek.com/chat/completions \
-H "Authorization: Bearer $DEEPSEEK_API_KEY" \
-d '{"model": "deepseek-chat", "messages": [{"role": "user", "content": "ping"}]}'Pricing quirks worth knowing: context caching is automatic (hits bill at roughly a tenth of input), and off-peak discount windows have historically cut prices further. The constraint: your requests are processed under Chinese jurisdiction — see the caveats below.
2. Hosted open weights — the jurisdiction-flexible middle. Because the weights are MIT-licensed, Western providers — Together, Fireworks, OpenRouter, and the hyperscaler catalogs — serve V4-class and R1-class models under their own terms. Expect to pay a multiple of first-party pricing, still far below closed frontier rates. This is the path most teams with compliance requirements choose.
3. Local — honest version: you’ll run a distill. Even V4 Flash’s 284B total parameters put it beyond single-workstation hardware; full V4 wants a multi-GPU rig behind vLLM or SGLang. On one box, “local DeepSeek” means an R1-era distill via Ollama, or a different one-box model class entirely. The full self-hosting picture lives in our open-source AI agent stack guide.
For agent work specifically, the practical question is harness compatibility: pointing a CLI harness at an OpenAI-compatible endpoint mostly just works, but tool-calling reliability degrades on some model/harness combinations — parallel tool calls and strict JSON schemas are where it shows. Test your harness’s tool loop for an hour before committing a pipeline to it.
The caveats, taken seriously
Data residency. The first-party API processes data under Chinese jurisdiction. That is disqualifying for some workloads and irrelevant for others — decide per workload, not per vibe. Mitigation: hosted weights on a provider in your jurisdiction, or self-hosting.
Content controls. Politically sensitive filtering exists and is partly baked into the weights, not just the hosted app. For coding and agent workloads its practical relevance is usually low — and occasionally surprising, typically in summarization or research steps. Mitigation: eval on your own corpus before routing content-touching steps.
Licensing. The MIT license on the weights and the API terms of service are different documents with different obligations. Self-hosting inherits the license; the API inherits the terms. Mitigation: legal review of whichever path you actually take, not the one on the launch slide.
Evaluation before trust. Benchmark deltas do not transfer to your tasks; a model two points behind on SWE-bench may be ahead on your test-fixing loop, or unusable. Mitigation: task-level evals gating every routing change — the same 50-run harness we used for the table above is an afternoon of setup.
Second-order effects: what cheap models did to everyone else
Incumbents repriced. Since R1, the US labs have shipped aggressive small tiers, cut reasoning-model prices, and deepened caching and batch discounts. Causality deserves care — hardware improvements and efficiency work push the same direction — but the timing pattern since January 2025 is consistent, and pricing pages now visibly acknowledge a floor that didn’t exist in 2023. Even flagship positioning shifted: GPT-5.6 and Claude Fable 5 sell capability ceilings, while their vendors’ cheap tiers chase the floor.
The arms race moved into the open. Competition now runs through open weights, which was untrue in 2023: Kimi K3 (July 2026) became the first open model to lead a frontend-coding arena ahead of Claude Fable 5, GLM-5.2 shipped MIT-licensed in June, and Qwen3-Coder-Next made frontier-adjacent coding run on one machine. The full comparison lives in our open-weight scorecard and the broader Chinese frontier models analysis. Aggregate effect per mid-2026 reporting: open-model API pricing dropped roughly 80% year over year.
Agent-product margins are quietly inflating. Products priced per seat gain margin every time tokens cheapen. Prediction: usage-based repricing and capability giveaways follow within quarters, because some competitor will spend the margin on growth. Evidence that would confirm it: seat prices falling or usage meters appearing on agent-product pricing pages through late 2026.
And Jevons applies. Cheaper tokens produce more agent runs, not smaller bills — teams attach agents to workflows that were never worth automating at old prices, so total spend rises while unit costs fall. Which is exactly why the last section is about measurement.
What to actually do differently this quarter
- Instrument first (an afternoon). Get per-task, per-provider token costs out of your harnesses and into one place. Most teams cannot attribute last month’s spend to workflows; you cannot exploit a price collapse you aren’t measuring.
- Route one step (an afternoon). Pick a high-volume, low-stakes step — retry grinding, log summarization, test triage — move it to V4 Flash behind an eval gate, and measure the quality delta for a week. The payoff compounds every day after.
- Re-benchmark quarterly (a recurring hour). Every routing decision has a shelf life: choices tuned for V3-era pricing were obsolete the day V4 landed and V3 left the API. Put the review on the calendar.
- Keep the exit ramp cheap (a design stance, not a task). OpenAI-compatible abstractions make re-routing a config edit instead of a rewrite. The fleet-level version of this posture — many agents, many providers, one view — is the subject of our multi-agent command center piece.
Product note: Step one is measurement. Automater Lite meters token usage locally across every provider you run — Claude Code, Codex CLI, Antigravity CLI, and 10+ more — so you know your per-provider burn before you re-route a single step. Free on automater.ai.
FAQ: DeepSeek
What is DeepSeek?
DeepSeek is a Chinese AI lab founded in 2023 in Hangzhou, owned by the High-Flyer quantitative hedge fund. It publishes open-weight models under MIT licenses at prices far below Western frontier labs. Its current line is DeepSeek V4 Pro and V4 Flash, released April 2026 with 1M-token context.
When was DeepSeek V3 released?
DeepSeek V3 was released in December 2024, with updated versions through 2025. Its reported $5.6M cost covered only the final training run’s GPU time, not total R&D. V3 was deprecated on DeepSeek’s first-party API on July 24, 2026, replaced by V4 — though the open weights remain downloadable.
Is DeepSeek free?
The weights are free: DeepSeek’s models are published under MIT licenses, so you can download, self-host, and modify them. The hosted API is paid but cheap — V4 Flash costs $0.14 per million input tokens and $0.28 per million output. The consumer chat app is free.
How do I get a DeepSeek API key?
Create an account at platform.deepseek.com, then generate a key from the API Keys page and call the OpenAI-compatible endpoint at api.deepseek.com. Most agent harnesses, routers, and SDKs accept the key anywhere an OpenAI-style base URL is configurable, so no dedicated client library is required.
Is DeepSeek safe to use for work?
It depends on the path. The first-party API processes data under Chinese jurisdiction — fine for some workloads, disqualifying for others. Hosted open weights through providers in your own jurisdiction remove that concern at a higher price. Self-hosting gives full control and inherits only the MIT license.
Is DeepSeek R1 as good as OpenAI’s reasoning models?
At its January 2025 release, R1 was in the same class as o1 on published benchmarks — the shock was matching them with open weights. It has since been retired from DeepSeek’s API (July 24, 2026) and superseded by V4. For your workloads, run your own task-level evals; benchmark rankings don’t transfer.
