DeepSeek V4 Models, Harness, and API Discount Windows: The Complete Guide (2026)

DeepSeek-V4.1-Flash: the model that replaced the flagship-killer (and now has eyes)

Every so often a "small" model comes along that makes the flagship look overpriced. On July 31, 2026, DeepSeek released the production version of V4-Flash and posted the weights on Hugging Face under the MIT license — they promptly hit the top of the trending charts. The 0731 in the name is just the release date: July 31. Independent testers found it beating DeepSeek's own flagship V4-Pro on several agentic benchmarks — at a fraction of the cost.

On September 10, 2026, DeepSeek went further and replaced the Flash tier outright with V4.1-Flash: a 552B-parameter causal encoder-decoder MoE (8B active on prefill, 16B on decode) with native image understanding — the first multimodal model DeepSeek has shipped on the API — a 1M-token context, 384K max output, and roughly a quarter of the previous KV-cache footprint. The weights are MIT-licensed on Hugging Face. The old Flash's fine-tune story (below) explains how a small model can outrun a flagship; V4.1-Flash is the same thesis with a new architecture and eyes.

The V4.1-Flash spec sheet (current)

A million tokens of context, MIT license, native vision, and prices that undercut most of the market. Only 8B–16B of the 552B parameters wake up for any given token — like a 552,000-person company where a few thousand people touch any one project. That's what makes it cheap to run.

The retired V4-Flash-0731 spec sheet (historical)

How it handles a million tokens without the bill exploding

The expensive part of long-context AI is the key-value (KV) cache — attention's working memory, which grows with every token you feed in. V4 attacks it from two directions. Some attention layers keep detailed notes, condensing every 4 tokens into one entry and only re-reading the relevant ones (CSA, Compressed Sparse Attention). Other layers keep summaries, condensing every 128 tokens into one entry that always gets read (HCA, Heavily Compressed Attention).

The payoff, per Goldman Sachs research: at a full 1M-token input, V4-Flash needs only ~10% of the compute and ~7% of the KV-cache memory of DeepSeek V3.2. A few more tricks stack on top:

• Speculative decoding via the attached DSpark draft module — a small "intern" model drafts several tokens ahead, and the main model checks them all in one pass instead of one at a time. vLLM and SGLang enable it with a single flag: --speculative-config.
• FP4 quantization for the MoE expert weights and FP8 for everything else, cutting KV-cache memory by up to 90%.
• A packaging change: Jinja chat templates are gone, replaced by a Python script package (encoding_dsv4) and a configurable reasoning_effort parameter (low / high / max).

How it was trained (the interesting bit)

Flash-0731 was pretrained on more than 32 trillion tokens, then fine-tuned in two stages. First, DeepSeek built a separate specialist model per domain — math, coding, agentic tasks — using supervised fine-tuning plus GRPO reinforcement learning. Then it merged the 10+ specialists via on-policy distillation: the merged model wrote its own answers, and training nudged each one toward how the best specialist would have answered. That's how one model inherits ten skills without averaging them into mush.

Two details worth knowing. The three reasoning levels (low / high / max) were trained as genuinely distinct behaviors with different length penalties and context windows — "max" prepends a system prompt pushing the model to fully decompose problems and test edge cases. And during tool-using agentic tasks, Flash keeps its entire reasoning history in context across every round, including across user messages — something V3.2 simply threw away.

What independent benchmarks say (August 2026)

The story in one line, per DeepLearning.AI's The Batch: Flash-0731 sits on Artificial Analysis' Pareto frontier for intelligence vs. cost per task — no tracked model is both smarter and cheaper. It also landed during a brutal pricing week: OpenAI cut GPT-5.6 Luna by 80%, Google shipped Gemini 3.6 Flash, and Thinking Machines released Inkling Small. The market's center of gravity is now intelligence-per-dollar.

What it cost before the price change

At launch, the first-party API charged a flat $0.0028 per million cached-input tokens, $0.14 per million input tokens, and $0.28 per million output tokens (≈¥0.02 / ¥1 / ¥2). The August 16 tariff overhaul replaced that flat rate with the peak/off-peak schedule — and the September 10 release of V4.1-Flash cut Flash prices again, between 9% (output) and 57% (cache-hit input) below the August card. Current numbers are in the pricing section.

DeepSeek-V4-Pro-0813: the flagship, with caveats

Pro is the 1.6-trillion-parameter flagship, and its August 13, 2026 "GA Release" was already the third V4-Pro drop in four months: an open preview on April 24, GA on July 19, then the quieter 0813 production build on August 13. Per DeepSeek's own change log, 0813 is mostly a serving-efficiency update — ~51.7B new parameters across four new DSpark speculative-decoding keys, not a new brain. On the API it simply serves as deepseek-v4-pro; no model-name migration needed.

The spec sheet

What's actually new under the hood

Two ideas carry the 1.6T model. mHC (Manifold-Constrained Hyper-Connections) keeps signal amplification under 2×, which keeps training a 1.6T model stable at only ~6.7% compute overhead. DSA (DeepSeek Sparse Attention) is the same hybrid compressed/hierarchical attention as Flash — CSA plus HCA — pushing context-cost growth closer to linear than quadratic. The result, per Goldman Sachs and DeepSeek's own figures: at the 1M-token setting, V4-Pro needs ~27% of the single-token inference compute and ~10% of the KV cache that V3.2 needed. The 0813 build then spends its ~51.7B new DSpark parameters on speculative decoding, i.e., faster and cheaper serving.

The benchmark reality check

DeepSeek's own numbers — run through DeepSeek Harness at max reasoning effort, versus the April preview — are big:

Independent labs (AIToolsReview, Aug 18, 2026) tell a more nuanced story:

The Terminal-Bench gap is the one to sit with: on a neutral harness, the smaller Flash scored 67.04% while Pro managed 54.68%. Treat vendor magnitudes as company-reported — the direction (large agentic gains) is credible and consistent across five benchmarks, but run your own evals before committing.

What it's like to actually use

Hands-on testing (via AIToolsReview) scored V4-Pro at 76.25% (61/80) on an 8-question practical test, with full marks on a hard math problem and a long-horizon agentic task. Front-end and one-shot UI generation are its clearest strength — Three.js scenes, app clones, physics demos. Known weaknesses: it overthinks and overengineers simple tasks, its honesty calibration is weak (see the AA-Omniscience row above), it's text-only, and there's no published agentic-safety evaluation.

DeepSeek Harness: DeepSeek's answer to Claude Code

On the same day as the Pro GA — August 13, 2026 — DeepSeek quietly shipped something arguably more interesting: DeepSeek Harness (dsh), an MIT-licensed, plugin-first agent framework, on GitHub at deepseek-ai/deepseek-harness. Its README states the organizing idea in three words: "everything is a plugin." DeepSeek used it internally to validate V4-Flash-0731 and to produce V4-Pro's benchmark table. Everyone calls it an open-source Claude Code rival — but the deliberate difference is that it's not locked to DeepSeek models at all.

Everything is a plugin — literally

The runtime is built on Cordis, a vendored dependency-injection framework (cordiverse/cordis, designed per A Programming Paradigm for Spatiotemporal Composability). Every part of the product is a plugin — the model adapter, tool registry, session log, agent loop, sandbox, even the web UI — so every part is replaceable from configuration. There's no privileged core to patch: extensions mount beside the other plugins, and registrations are reversible effects that unwind when a plugin unloads.

The docs describe eight independently swappable layers:

It speaks every provider

Despite the branding, the harness supports DeepSeek, Anthropic, OpenAI, Amazon Bedrock, Google Vertex, Azure, and any custom OpenAI-compatible endpoint as interchangeable inference providers. Swapping providers is a configuration change, not a rewrite — which makes dsh infrastructure a team can standardize on regardless of which model wins a given benchmark cycle.

The features that matter

• Capability seams — each swappable capability has three roles (Service Definition / Provider / Consumer). One provider swap can move Bash, PTY, LSP, and subprocess execution together to a remote sandbox, with no provider forks.
• The session log is the source of truth — "model-visible ⟺ logged": anything that reaches a model request must be reconstructable from the append-only log. Fork, resume, transcripts, telemetry, and persistence all derive from that stream.
• Typed event system — durable session events (session/event, turn/*, step/*, tool/*) plus live extension events (agent/*, tools/*) with waterfall semantics, letting plugins intercept, rewrite, or reject requests.
• Agent loop — steps (one model request + tool calls) compose into turns; agent/pre-step, agent/request, and llm/stream are the interception points.
• Sandboxing & approvals — filesystem, shell, subprocess, terminal, and sandbox are separate configurable plugins, and an approval layer gates privileged operations under the active permission policy (the Web UI asks before doing anything spicy).
• Goals, subagents, workflow, plan mode — same-session objectives (ctx.goals), subagent delegation with pluggable providers, workflow orchestration, and plan mode as logged state.
• Skills & hooks — a skill registry/provider plus Claude Code and Codex hook bridges.
• Self-modification — the agent can inspect and mount its own plugins (the demo:cordis demo modifies its live runtime).
• Python SDK — deepseek-harness-sdk drives the bundled runtime as a subprocess over newline-delimited JSON-RPC on stdio.

Ways to run it

• Web UI — npx @deepseek-ai/dsh web (or pnpm dsh web from source) serves a browser agent interface at http://127.0.0.1:3080.
• Headless — dsh --profile headless "task" runs one fresh persisted session and prints the final answer.
• ACP — an automation-only Agent Client Protocol (JSON-RPC stdio) server.
• Plugin management — dsh plugin --profile <name> <pnpm args> installs out-of-tree plugins per profile.
• Reported operational modes: standard (general tasks), code-focused (multi-app automation), creative (custom tools), and minimal (isolated testing — reportedly how DeepSeek tested V4-Flash before release).

Installing DeepSeek Harness from source on macOS

Two ways in: npx @deepseek-ai/dsh web if you just want to look around, or from source if you want to hack on it. Here's the from-source route on a Mac.

Prerequisites

The four commands

# 1. Clone the repository
git clone https://github.com/deepseek-ai/deepseek-harness.git
cd deepseek-harness

# 2. Install dependencies (pnpm workspace; postinstall sets up lefthook git hooks)
pnpm install

# 3. Build everything (host lib -> client lib -> web frontend)
pnpm run build

# 4. Launch the Web UI (serves at http://127.0.0.1:3080 by default)
pnpm dsh web

That's it. Open http://127.0.0.1:3080, head to Settings → Models, and add your DeepSeek API key — the model route becomes usable immediately, no server restart. Then choose a workspace (your project directory), and the session composer unlocks.

Configuration & useful commands

# One-shot headless task from source (needs DEEPSEEK_API_KEY)
pnpm dsh --profile headless "summarize this workspace"

# Inspect the composed plugin tree without booting
pnpm dsh --profile web --dump-config

# Frontend dev with hot reload (HMR) — requires the dev:web watcher running
pnpm run dev:web

# Credentials live in a gitignored .env at the repo root
#   DEEPSEEK_API_KEY=sk-...
#   DEEPSEEK_BASE_URL=https://...   # optional, defaults to public API

When it misbehaves

DeepSeek API discount windows, off-peak times, and prices

On August 13, 2026, DeepSeek announced something unusual for an LLM API: peak/off-peak (峰谷) tariffing — tokens priced like electricity. It took effect at 16:00 UTC on August 16, 2026 (00:00 Beijing time, August 17), and on August 24 the fine print changed again: peak hours now apply Monday through Friday only, with weekends fully off-peak. The September 10 release of V4.1-Flash then cut Flash prices while keeping the schedule. This is the money section.

The headline answer

• Total peak time is 7 hours per weekday, 35 hours per week — about 21% of the 168-hour week (it was 49 hours/week before the August 24 change). Everything else — 133 hours a week — is off-peak. Official DeepSeek docs: "Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday through Friday (all other hours are off-peak)."
• Practical read for the US: on Eastern time (summer), peak runs 21:00–00:00 and 02:00–06:00 — your 9-to-5 workday bills off-peak, and the overnight batch job someone scheduled "because nobody is using anything then" is the one that pays double. When US clocks fall back on November 1 (October 25 in the EU), each local window shifts one hour earlier. For China-based teams, lunch (12:00–14:00) and everything after 18:00 Beijing is off-peak.

Current per-1M-token prices (official, checked Sep 28, 2026)

deepseek-flash (V4.1-Flash) — concurrency 2,500. Legacy names deepseek-v4-flash and deepseek-v4-flash-vision-exp route here and bill at these rates. Image inputs are converted to tokens and billed with text input:

deepseek-v4-pro (Pro-0813) — concurrency 500, billing unchanged after the September 14 reroute was reversed:

Off-peak is exactly half of peak in every category. Base URLs: https://api.deepseek.com for OpenAI format, https://api.deepseek.com/anthropic for Anthropic format. Billing deducts from granted balance first, then topped-up balance.

What changed on September 10 (the price cut)

With V4.1-Flash, DeepSeek cut Flash rates between 9% and 57% versus the August card. The cache-hit cut is the steepest — the same stable-prefix workloads got dramatically cheaper:

The honest part: base prices are still above the original flat rate

The original July flat rates for V4-Flash were ¥0.02 / ¥1 / ¥2 (cache-hit-in / cache-miss-in / output) — about $0.0028 / $0.14 / $0.28. The new V4.1-Flash card is much closer to that floor than the August card was, but it hasn't fully returned to it:

deepseek-flash (V4.1-Flash) — increase over the original flat rate:

deepseek-v4-pro — increase over its GA flat rate (unchanged since August 16):

Three real levers to pull

1. Shift work to off-peak (50% off — and weekends are all off-peak). Best for batch data processing, bulk translation, data cleaning, offline analysis, overnight model evaluation, report generation — anything with loose latency requirements. Interactive chat, online agents, and real-time copilots generally can't wait. With the August 24 change, a weekend batch pays the off-peak rate all 48 hours.
2. Maximize cache hits (the biggest multiplier). Cache-hit input is ~50× cheaper than cache-miss for Flash ($0.003 vs. $0.15), ~30× for Pro ($0.022 vs. $0.66). Reuse stable system prompts, long shared contexts, and prefix-stable requests so more of your input tokens land on the cache — and note the September 10 cut hit cache prices hardest (−57%).
3. Pick the right tier for the job. Flash (deepseek-flash) has 5× the concurrency (2,500 vs. 500), ~3.3× cheaper output, native vision, and — per DeepSeek's own testing — beats Pro on performance, cost, speed and total runtime. Route high-throughput, multimodal, or non-thinking workloads to Flash, and reserve Pro for the complex agentic and front-end work where the 1.6T model's depth still earns its premium.

Why DeepSeek did this

Model inference occupies AI compute around the clock, but traffic concentrates in working hours while idle periods under-utilize the clusters. Pricing tokens like electricity (峰谷电价) uses the price lever to smooth demand, raise utilization, and relieve peak pressure — a sign the LLM price war is entering a "2.0" phase of fine-grained compute-scheduling economics (智东西/Zhidx, Techritual).

Frequently asked questions

Sources & further reading