DeepSeek V4 Flash 0731: The $0.07 Game Demo, API Pricing, Architecture, and Coding Benchmarks
DeepSeek V4 Flash 0731 has created an unusual combination of reactions. Developers are impressed by its coding-agent scores. Infrastructure teams are interested in its 1-million-to
DeepSeek V4 Flash 0731: How a Re-Post-Trained Model Triggered a Global Price War
Introduction
DeepSeek V4 Flash 0731 has created an unusual combination of reactions.
Developers are impressed by its coding-agent scores.
Infrastructure teams are interested in its 1-million-token context and low active parameter count.
AI platforms are offering free usage and aggressive discounts.
And social media is filling with screenshots of prototypes whose reported inference bills are measured in cents rather than dollars.
The most widely shared examples in the source article included:
- A small 3D space-shooter prototype reportedly generated for about RMB 0.07.
- A Counter-Strike-style prototype reportedly produced for roughly RMB 0.50.
- A personal usage dashboard showing 87 million tokens for RMB 31.57.
- OpenCode reporting 8 trillion DeepSeek Flash tokens on August 1.
- Cline increasing its free quota after finding the model cheaper to subsidize than expected.
- Nous Portal temporarily discounting V4 Flash 0731 by 90%.
These examples capture the excitement, but they can also blur several distinct things:
- DeepSeek's official API price.
- Cache-hit and cache-miss pricing.
- Free or subsidized third-party access.
- The number of tool calls an agent makes.
- The amount of output and hidden reasoning generated.
- The cost of the model alone versus the cost of the complete product.
The model is genuinely inexpensive.
That does not mean every application will cost seven cents.
The useful question is not whether one viral demo is reproducible exactly. It is how DeepSeek achieved such a large capability jump without changing the base architecture—and what the new economics mean for developers.
The Global Discount Cycle
The official API price was already low before third-party promotions were applied.
DeepSeek currently lists the following prices per million tokens:
| Usage type | DeepSeek V4 Flash price |
|---|---|
| Input, cache hit | $0.0028 |
| Input, cache miss | $0.14 |
| Output | $0.28 |
The API supports:
- A 1-million-token context window.
- Up to 384K output tokens.
- Thinking and non-thinking modes.
- Three reasoning-effort levels in the 0731 model card:
low,high, andmax. - Tool calls.
- JSON output.
- Chat prefix completion in beta.
- FIM completion in non-thinking mode.
- OpenAI-compatible Chat Completions.
- The Responses API.
- An Anthropic-compatible interface.
- A published concurrency limit of 2,500 per account for V4 Flash.
Those official prices are the baseline.
Platforms can then choose to:
- Pass the price through.
- Add a markup.
- Subsidize usage.
- Offer a limited free model.
- Bundle the model into a subscription.
- Apply promotional credits.
- Route traffic through another inference provider.
This is why one developer may pay DeepSeek's list price while another pays nothing for a limited period.
OpenCode Reports Eight Trillion Tokens in One Day
OpenCode publicly said DeepSeek Flash processed 8 trillion tokens on August 1 through its platform.
The post breaks the figure down as:
5T tokens of free usage
+
3T tokens through OpenCode Go
OpenCode's August 3rd tweet shows DeepSeek Flash processed 8 trillion tokens on August 1st—5 trillion free, 3 trillion via OpenCode Go. The tweet is an official statement of those figures, breaking down free versus paid usage and supporting context around DeepSeek Flash's token processing volume.
OpenCode's current Zen documentation lists a DeepSeek V4 Flash Free option available for a limited time.
This is an important distinction.
The eight-trillion-token figure describes traffic through OpenCode, not direct usage reported by DeepSeek across every platform.
It is still a strong signal that low-cost models can generate enormous demand when they are placed inside a popular coding-agent workflow.
Nous Portal Temporarily Cuts the Price by 90%
Nous Research announced a seven-day promotion offering DeepSeek V4 Flash 0731 at a 90% discount through Nous Portal in partnership with Novita Labs.
The promotional post compared the discounted cost with Claude Fable 5 and claimed a more than 1,000-fold price difference on comparable tasks.
That comparison depends on several choices:
- Which provider price is used.
- Whether input or output dominates.
- Whether caching is available.
- Which reasoning setting is selected.
- How many tokens each model needs to finish the task.
- Which benchmark or workflow defines "comparable."
A price-per-token comparison is useful, but the more meaningful metric is:
Total cost per accepted task
A model that uses fewer expensive tokens can be cheaper than a low-priced model that retries repeatedly.
Conversely, when a low-priced model is also capable enough to finish the task quickly, the cost advantage can become enormous.
Cline Triples Its Free Quota
Cline initially announced free V4 Flash 0731 usage through its coding agent.
A later public post said the free quota had been tripled because the economics appeared sustainable.
Cline's current model catalog and ClinePass material include DeepSeek V4 Flash as a fast, value-oriented option for focused coding tasks.
Free quotas and model availability can change, so users should check the live provider page rather than relying on an old screenshot.
The broader lesson is more durable.
When inference becomes cheap enough, an agent platform can use free access as customer acquisition without absorbing
the same cost it would face with a premium frontier model.
Community Cost Screenshots Need Context
The source article includes a dashboard showing:
- RMB 31.57 in spending.
- 2,282 API requests.
- 87,027,995 tokens.
The screenshot is useful because it demonstrates the order of magnitude developers may see under favorable usage patterns.
It does not reveal enough information to reconstruct the bill exactly.
Missing variables include:
- Input versus output token ratio.
- Cache-hit percentage.
- Model version used on each date.
- Reasoning effort.
- Tool-call count.
- Failed requests.
- Promotional credits.
- Provider discounts.
- Whether all tokens were billable at the same rate.
A long repeated system prompt can be extremely cheap when it hits cache.
A long unique prompt sent once is billed at the cache-miss input price.
Output is also much more expensive than cached input.
For agent systems, these differences dominate the final bill.
Flash Blitz: What Changed on July 31
DeepSeek V4 Preview launched on April 24, 2026.
The family contained:
- DeepSeek V4 Pro.
- DeepSeek V4 Flash.
The Preview release established the main architecture:
- Sparse Mixture of Experts.
- 1-million-token context.
- Efficient long-context attention.
- Low active parameter counts relative to total capacity.
- Thinking and non-thinking modes.
- Open weights under the MIT License.
V4 Flash Preview was positioned as the smaller, faster, cheaper alternative to V4 Pro.
The July 31 update changed its competitive position.
DeepSeek states that V4 Flash 0731 uses the same model architecture and size as V4 Flash Preview.
The update was produced by running a new post-training process.
In simplified form:
Same pretrained base architecture
+
new post-training and agent optimization
=
much stronger coding-agent behavior
This matters because it shows how much capability can remain latent in a pretrained model.
Architecture and parameter count are not the whole product.
Post-training determines how effectively the model:
- Uses tools.
- Plans multi-step work.
- Handles terminal feedback.
- Recovers from errors.
- Writes and edits files.
- Follows an agent protocol.
- Allocates reasoning effort.
- Works within a harness.
Base Architecture and Checkpoint Details
The original V4 Flash model card describes the base model as:
| Specification | DeepSeek V4 Flash |
|---|---|
| Total base MoE parameters | 284B |
| Activated parameters | 13B |
| Context length | 1M |
| License | MIT |
| Main modality | Text |
| Base precision | FP8 / mixed low precision depending on checkpoint |
The 0731 model card says the new release has the same structure as the DSpark variant and includes an attached speculative-decoding module.
This explains why some model-file metadata may show
Compared to the 284B-base MoE figure, the total checkpoint count is now larger.
The cleanest way to put it is:
V4 Flash’s underlying MoE model remains roughly 284B total parameters with 13B active, while the 0731 release adds the DSpark speculative-decoding component to the published checkpoint.
DSpark Speculative Decoding
Speculative decoding uses a fast draft model to propose several future tokens.
The main model then verifies those proposals.
When predictions are accepted, the system can generate multiple tokens with less sequential work.
DeepSeek’s 0731 model card provides explicit DSpark support for vLLM and SGLang.
For vLLM, the relevant configuration is:
--speculative-config '{"method":"dspark","num_speculative_tokens":7,"draft_sample_method":"greedy"}'
For SGLang, the model card uses:
--speculative-algorithm DSPARK
DSpark does not improve the model’s reasoning by itself.
It is an inference optimization intended to reduce decoding latency or increase throughput while preserving the target model’s output distribution under the supported configuration.
The Benchmark Jump
DeepSeek publishes the following comparison for V4 Flash 0731:
| Benchmark | V4 Flash 0731 | V4 Flash Preview | V4 Pro Preview |
|---|---|---|---|
| Terminal Bench 2.1 | 82.7 | 61.8 | 72.1 |
| NL2Repo | 54.2 | 39.4 | 38.5 |
| CyberGym | 76.7 | 38.7 | 52.7 |
| DeepSWE | 54.4 | 7.3 | 12.8 |
| Toolathlon-Verified | 70.3 | 49.7 | 55.9 |
| Agents’ Last Exam | 25.2 | 15.8 | 16.5 |
| AutomationBench Public | 25.1 | 10.8 | 12.8 |
| DSBench-FullStack | 68.7 | 37.0 | 41.8 |
| DSBench-Hard | 59.6 | 25.8 | 31.1 |
The most dramatic increase is DeepSWE:
7.3 → 54.4
CyberGym nearly doubles:
38.7 → 76.7
Terminal Bench 2.1 rises by more than twenty points:
61.8 → 82.7
The new Flash model also exceeds V4 Pro Preview on every benchmark in DeepSeek’s published table.
That is a major change for a model originally positioned mainly as the cheaper and faster option.
Benchmark Methodology Matters
The table should not be read as a pure comparison of raw checkpoints.
DeepSeek’s model card includes several important notes.
For public code-agent tasks, the company used:
DeepSeek Harness minimal mode
Reasoning effort: max
Temperature: 1.0
Top-p: 0.95
DeepSeek Harness had not been publicly released at the time of verification.
This means outside researchers may not yet be able to reproduce the exact software environment used for the published code-agent results.
Two tests are also internal:
- DSBench-FullStack.
- DSBench-Hard.
Internal benchmarks can be useful for product development, but independent teams cannot inspect their hidden tasks or contamination controls.
The correct interpretation is:
DeepSeek reports a large improvement under its chosen agent stack and evaluation setup. Public reproducibility will improve when the harness, prompts, logs, and complete evaluation configuration become available.
Harness Quality Can Change the Score
A coding benchmark often measures a complete system:
Model
+
system prompt
+
repository tools
+
terminal
execution
+
context management
+
retry policy
+
test feedback
+
patch submission logic
The same model can score differently when one component changes.
A better harness may:
- Select more relevant files.
- Preserve useful terminal output.
- Prevent context overflow.
- Retry failed commands intelligently.
- Stop unproductive loops.
- Apply patches more reliably.
- Give the model clearer test results.
This does not make the model irrelevant.
It means the benchmark result belongs to the model-and-harness combination.
The strong 0731 numbers suggest DeepSeek improved both the model’s agent behavior and the surrounding evaluation process.
Artificial Analysis Scores It at 50
Artificial Analysis reports an Intelligence Index score of approximately 50 for DeepSeek V4 Flash 0731, around ten points above the previous Flash version.
The independent model-analysis firm also describes V4 Flash as exceptionally inexpensive relative to other well-known frontier systems.
Reuters summarized Artificial Analysis’s findings by reporting an average benchmark-test cost of roughly three U.S. cents under its methodology.
That comparison supports the value argument.
It does not mean every production task costs three cents.
Artificial Analysis also reports weaker results on some knowledge-reliability measures.
Its V4 Flash 0731 article notes:
- Omniscience accuracy remained around 37%.
- The hallucination rate fell but remained high at approximately 84% under that evaluation.
Those figures are a useful reminder.
A model can be:
- Very strong at coding agents.
- Extremely cheap.
- Competitive on a composite index.
- Still unreliable on some open-world factual questions.
“Best value” is not the same as “best for every task.”
Official API Pricing
The direct DeepSeek API price is:
| Billing category | Price per 1M tokens |
|---|---|
| Cache-hit input | $0.0028 |
| Cache-miss input | $0.14 |
| Output | $0.28 |
The pricing gap between a cache hit and cache miss is enormous:
$0.14 ÷ $0.0028 = 50
Cached input is fifty times cheaper than uncached input.
For long-running agents, prompt structure becomes cost architecture.
Example Cost Calculation
Assume one request uses:
100,000 uncached input tokens
20,000 output tokens
The direct model cost is:
Input:
100,000 / 1,000,000 × $0.14
= $0.014
Output:
20,000 / 1,000,000 × $0.28
= $0.0056
Total:
$0.0196
That is less than two U.S. cents.
Now assume the same 100,000-token prefix is cached:
Cached input:
100,000 / 1,000,000 × $0.0028
= $0.00028
Output:
20,000 / 1,000,000 × $0.28
= $0.0056
Total:
$0.00588
The output now dominates the bill.
These examples explain why low-cost coding prototypes are plausible.
They do not include:
- Provider markup.
- Tool API charges.
- Browser or search costs.
- Sandboxed compute.
- Storage.
- Repeated failed attempts.
- Human development time.
Why Agent Bills Can Still Grow
Agentic coding is rarely one request.
A typical workflow may include:
- Read the repository.
- Search for relevant code.
- Plan the change.
- Edit several files.
- Run tests.
- Inspect the
failure.
7. Edit again.
8. Run tests again.
9. Review the diff.
10. Produce the final answer.
Every step may create another model call.
A seemingly small task can become expensive when:
- The repository context is repeatedly uncached.
- The model generates long reasoning traces.
- Tests fail many times.
- The agent reads large files unnecessarily.
- Several parallel agents duplicate work.
- Context compaction causes important information to be resent.
- The model does not stop after reaching a good solution.
V4 Flash reduces the price of these mistakes.
It does not eliminate them.
Context Caching Is the Main Cost Lever
DeepSeek uses disk-based context caching.
When the same prefix is reused, the matching input tokens can receive the lower cache-hit price.
Good candidates for a stable prefix include:
- System instructions.
- Repository policies.
- Tool definitions.
- Long reference documents.
- An unchanged project snapshot.
- Repeated enterprise context.
A simplified prompt design is:
Stable reusable prefix
+
new user request
+
latest tool result
A less cache-friendly design is:
Reordered instructions
+
rewritten repository summary
+
changing timestamps
+
random request metadata
+
new user request
Small prefix changes can reduce cache reuse.
Developers should inspect token-usage fields rather than assuming a long prompt was cached.
DeepSeek also offers user_id isolation for privacy and scheduling. Cache reuse and user isolation should be designed together so one customer’s context is not accidentally mixed with another’s.
API Quick Start
The official base URL remains:
https://api.deepseek.com
The model ID is:
deepseek-v4-flash
DeepSeek says the stable API ID automatically serves the latest official Flash version.
That is convenient, but production teams should record the returned model fingerprint and test changes because the behavior behind a stable ID can be upgraded.
Python Example
from openai import OpenAI
client = OpenAI(
api_key="YOUR_DEEPSEEK_API_KEY",
base_url="https://api.deepseek.com",
)
response = client.chat.completions.create(
model="deepseek-v4-flash",
messages=[
{
"role": "user",
"content": "Review this function and propose a safe refactor.",
}
],
)
print(response.choices[0].message.content)
cURL Example
curl https://api.deepseek.com/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $DEEPSEEK_API_KEY" \
-d '{
"model": "deepseek-v4-flash",
"messages": [
{
"role": "user",
"content": "Write a small Python CLI that validates JSON files."
}
]
}'
Developers should check the live API reference for the exact reasoning-effort and thinking-mode fields supported by their endpoint and SDK version.
Thinking History Must Be Preserved
DeepSeek’s thinking-mode documentation says that when a turn includes tool calls, the reasoning_content from the assistant message must be passed back in subsequent requests.
A multi-turn agent should preserve:
content
reasoning_content
tool_calls
Dropping the reasoning state may reduce continuity or cause request-validation problems.
This is especially relevant when integrating through an OpenAI-compatible client that normally ignores provider-specific reasoning fields.
OpenAI, Anthropic, and Responses Compatibility
DeepSeek provides more than one interface.
OpenAI Chat Completions
Use the standard DeepSeek base URL and the model ID:
deepseek-v4-flash
Anthropic-Compatible API
DeepSeek also documents an Anthropic-format interface.
This can help software built around Claude-style messages connect to DeepSeek with fewer application changes.
Compatibility does not guarantee identical behavior.
Provider-specific fields, reasoning history, tool schemas, safety behavior, and error handling still require testing.
Responses API
DeepSeek says the 0731 release natively supports the Responses API format and has been adapted for Codex-style use.
This matters for coding-agent products that increasingly depend on stateful response objects, tool calls, and structured agent loops.
Open Weights Under the MIT License
DeepSeek has released V4 Flash 0731 weights on Hugging Face under the MIT License.
That allows developers to inspect, modify, deploy, and redistribute the model subject to the license terms.
The open-weight release provides more control than an API-only model.
Teams can:
- Run the model on private infrastructure.
- Study its architecture.
- Build quantized variants.
- Adapt inference kernels.
- Fine-tune or specialize it.
- Integrate it into internal systems.
- Avoid sending sensitive code to a third-party API.
The practical barrier is hardware.
“Open weights” does not mean “runs on a normal laptop.”
vLLM Deployment
The official 0731 model card provides a vLLM example for a single 4×GB300 node:
vllm serve deepseek-ai/DeepSeek-V4-Flash-0731 \
--trust-remote-code \
--kv-cache-dtype fp8 \
--block-size 256 \
--data-parallel-size 4 \
--enable-expert-parallel \
--moe-backend deep_gemm_mega_moe \
--attention-config '{"use_fp4_indexer_cache": true}' \
--speculative-config '{"method":"dspark","num_speculative_tokens":7,"draft_sample_method":"greedy"}'
This example demonstrates the infrastructure class expected for full-quality serving.
It should not be interpreted as the only supported configuration.
The vLLM recipe may add support for other GPU topologies over time.
SGLang Deployment
The official SGLang example is:
sglang serve \
--trust-remote-code \
--model-path deepseek-ai/DeepSeek-V4-Flash-0731 \
--tp 4 \
--moe-runner-backend flashinfer_mxfp4 \
--speculative-algorithm DSPARK \
--mem-fraction-static 0.90 \
--chunked-prefill-size 4096 \
--swa-full-tokens-ratio 0.1
The target and draft weights come from the same checkpoint, so the documentation says not to set a separate speculative draft-model path.
Inference engines evolve quickly.
Use the current model card and serving-engine recipe rather than copying an old launch command from the Preview release.
Local Deployment Is Still an Infrastructure Project
Even though only about
For any given token, 13B parameters are active, meaning the complete model weights must remain available throughout the serving system.
Deployment planning must account for:
- Total model storage.
- GPU memory.
- Expert parallelism.
- Interconnect bandwidth.
- Long-context KV cache.
- Quantization support.
- DSpark kernels.
- Batch size.
- Concurrency.
- Prefill latency.
- Decode throughput.
Smaller quantizations may enable experimentation on different hardware, but they can alter quality, speed, or supported context length.
For most individual developers, using the direct API or a hosted provider will be easier and more cost-effective than self-hosting.
Official API Versus Third-Party Providers
There are three common ways to use V4 Flash.
| Route | Main advantage | Main trade-off |
|---|---|---|
| DeepSeek API | Official pricing and current official model | Data leaves your environment; stable ID may be updated |
| Third-party platform | Free quotas, integrated agents, easier billing | Promotions and routing can change |
| Self-hosted weights | Maximum control and privacy | Significant hardware and engineering requirements |
The most cost-effective route depends on your workload.
A free Cline or OpenCode quota may be ideal for experimentation.
The direct API may be best for predictable, small-scale usage.
Self-hosting may only become attractive with sufficiently high, sustained volume or when privacy requirements take priority.
The Best Era for Prototyping
The source article compares inexpensive AI to the mass production of automobiles.
The analogy is imperfect but useful.
When a technology becomes dramatically cheaper, the market doesn't simply buy the same amount for less money.
New use cases become possible.
Low-cost agent models can support experiments that would previously have been rejected before testing.
Examples include:
- A student building a first software prototype.
- A solo founder generating and testing several landing-page ideas.
- A small team running code review on every pull request.
- An open-source project offering free issue triage.
- A researcher processing a large code or document collection.
- A company creating internal agents for repetitive work.
- A game developer testing generated mechanics and levels.
The value isn't that the model replaces all software engineering.
It lowers the cost of asking:
Is this idea worth building further?
A Prototype Is Not a Product
Cheap generation can produce a convincing first demo.
A production product still requires:
- Product design.
- Security.
- Testing.
- Accessibility.
- Performance.
- Monitoring.
- Deployment.
- Data protection.
- Legal review.
- Maintenance.
- Customer support.
A seven-cent model bill doesn't mean a seven-cent business.
It means the first computational experiment may be cheap enough to attempt.
That changes who can participate and how many ideas can be tested.
An Example Community-Built Workspace
The source article includes a lightweight document workspace shown as one example of what developers were building with inexpensive coding agents.
A screenshot cannot establish how much of the application was produced by the model, how much human editing was required, or whether the product is secure and maintainable.
It does show the kind of project that low-cost coding models make easier to prototype.
Where V4 Flash Fits Best
V4 Flash 0731 is especially attractive when:
- The task is code- or tool-heavy.
- Cost matters strongly.
- Large context is useful.
- High request volume is expected.
- The workflow can validate outputs.
- Occasional retries are acceptable.
- A larger fallback model is available for difficult cases.
It may be less suitable when:
- Open-world factual accuracy is critical.
- A polished first answer matters more than cost.
- The task requires image understanding.
- The organization cannot validate generated code.
- A managed compliance guarantee is required.
- The workflow depends on stable, version-pinned API behavior.
A model router can combine Flash with a stronger or more specialized system.
For example:
Routine repository edits
→ V4 Flash
High-risk architecture or security decisions
→ stronger model + human review
Cheap Models Change Agent Architecture
When model calls are expensive, developers try to minimize every request.
When calls become cheap, an agent can afford to:
- Ask another model to review the patch.
- Run a separate test-analysis pass.
- Generate several candidate solutions.
- Compare alternative implementations.
- Use one model for planning and another for execution.
- Recheck its work before submission.
This can increase reliability.
It can also waste tokens.
The right objective is not minimum token usage.
It is:
Lowest total cost that reaches the required quality
The Main Risks Behind the Price Story
1. Public Beta Can Change
DeepSeek describes the official Flash API as a public beta.
Pricing, behavior, limits, and model versions may change.
Production teams should maintain regression tests.
2. Benchmark Scores Depend on DeepSeek Harness
The strongest code-agent results use an unreleased harness configuration.
Exact independent reproduction is not yet straightforward.
3. Cheap Input Does Not Guarantee a Cheap Agent
Output, retries, tools, and uncached context can dominate the final cost.
4. Long Context Is Not Free
A 1-million-token window is a capacity limit, not a recommendation to send one million tokens in every request.
Large prefill workloads increase latency and cost.
5. Open-World Reliability Still Needs Work
Independent evaluation shows that value and coding strength can coexist with a high hallucination rate on factual tests.
Critical facts should be checked against sources.
6. Generated Code Requires Review
Low-cost models can generate more code than a team can safely inspect.
Automated tests, static analysis, dependency scanning, and human review remain necessary.
7. Promotional Access Is Temporary
Third-party free models and discounts can disappear.
Do not build a permanent business model around a seven-day or limited-time subsidy.
8. Stable API IDs Can Hide Upgrades
The deepseek-v4-flash model ID points to the current version.
An upgrade behind that ID may change outputs without a code change in your application.
Practical Cost-Control Checklist
1. Stabilize Reusable Prefixes
Keep system instructions and tool definitions consistent to improve cache reuse.
2. Track Cache-Hit Tokens Separately
Do not rely only on total input tokens.
3. Limit Unnecessary Output
Set a realistic output budget for the task.
4. Use Lower Reasoning Effort for Routine Work
Reserve max for tasks that benefit from longer deliberation.
5. Cap Agent Steps
Stop loops that are not making progress.
6. Run Cheap Validation Before Another Model Call
Use linters, tests, schema validators, and deterministic checks.
7. Route Difficult Cases
Escalate only when the task fails a test or exceeds a risk threshold.
8. Measure Cost per Accepted Result
Include failed attempts and human review.
One More Thing: DeepSeek Harness
The source article ends with a possible next step in DeepSeek's developer ecosystem.
Tianyi Cui, identified in the source as the person responsible for DeepSeek Harness, posted a recruitment message for developers of open-source agent-harness projects.
The message invited interested developers to share a GitHub account and representative open-source work to participate in internal testing.
DeepSeek's own July 31 change log also says the minimal mode of DeepSeek Harness used for benchmark evaluation is "to be released soon."
As of verification, I did not locate:
- A public official DeepSeek Harness repository.
- A stable product page for "DeepSeek Code."
- Public installation instructions.
- Pricing.
- A release date.
- A complete feature specification.
The evidence supports this narrower conclusion:
DeepSeek is testing an agent harness and intends to release at least part of the framework, but the final product name, public scope, and launch timing remain unconfirmed.
The model, API, and open weights are available now.
The harness is still a future ecosystem component.
Why a DeepSeek Harness Could Matter
A first-party harness could help DeepSeek control the full coding-agent stack.
It could provide:
- Native reasoning-history handling.
- Model-specific prompt formats.
- Tool-call parsing.
- Context management.
- Repository search.
- Terminal execution.
- Benchmark reproducibility.
- Responses API integration.
- Codex-compatible workflows.
- Cost controls.
- Automatic routing between Flash and Pro.
DeepSeek already documents integrations with external harnesses and coding agents.
A first-party tool could turn benchmark-specific optimizations into a product that ordinary developers can use.
It could also reveal how much of V4 Flash 0731's benchmark jump comes from the checkpoint and how much comes from the agent runtime.
What to Watch Next
Several developments will determine whether the V4 Flash moment becomes a lasting ecosystem shift.
Official V4 Pro Release
DeepSeek says the official V4 Pro release will follow the Flash update.
The performance and pricing gap between Pro and Flash will affect routing decisions.
DeepSeek Harness Availability
A public release would improve benchmark reproducibility and give developers a model-native agent framework.
Price Stability
The direct price is already low, but third-party promotions may not remain.
Provider Capacity
Cheap inference attracts very high traffic.
Latency, rate limits, and reliability will matter as usage scales.
Open-Source Inference Support
vLLM, SGLang, hardware vendors, and quantization projects will determine how accessible self-hosting becomes.
Independent Evaluations
More public evaluations should test:
- Coding.
- Security.
- Factual reliability.
- Long context.
- Tool use.
- Cost per successful task.
- Performance under different harnesses.
FAQ
What is DeepSeek V4 Flash 0731?
DeepSeek V4 Flash 0731 is the official July 31 release of V4 Flash, currently served through the deepseek-v4-flash API in public beta. DeepSeek says it keeps the Preview model's base architecture and size while substantially improving agent capabilities through new post-training.
How much does DeepSeek V4 Flash cost?
DeepSeek's official API lists $0.14 per million cache-miss input tokens, $0.0028 per million cache-hit input tokens, and $0.28 per million output tokens. Third-party platforms may offer different prices, free quotas, or temporary discounts.
Does a 3D game really cost only RMB 0.07 to generate?
The source article cites a community example with that reported model cost. The example is not accompanied by complete prompts, token logs, cache data, retries, tool costs, or human-work records, so it should be treated as an anecdote rather than a guaranteed budget.
What are the main V4 Flash 0731 benchmark scores?
DeepSeek reports 82.7 on Terminal Bench 2.1, 76.7 on CyberGym, 54.4 on DeepSWE, 70.3 on Toolathlon-Verified, and 54.2 on NL2Repo. Public code-agent evaluations used the unreleased minimal mode of DeepSeek Harness with maximum reasoning effort.
Is DeepSeek V4 Flash 0731 open source?
The model weights and repository are released under the MIT License, so "open-weight" and broadly permissive use are accurate descriptions. Running the complete checkpoint still requires substantial multi-GPU infrastructure.
Can DeepSeek V4 Flash run locally?
Yes, DeepSeek publishes weights and serving instructions for vLLM and SGLang. The official full-scale examples use advanced multi-GPU hardware, so a normal laptop is not the target environment for the complete model.
What is the context window?
The official API and model card specify a 1-million-token context window. The API also lists a
maximum output length of 384K tokens, but using the maximum context or output can significantly increase latency and resource use.
Has DeepSeek Code or DeepSeek Harness been released?
DeepSeek has publicly referenced a Harness minimal mode and recruited open-source harness developers for internal testing. A complete public repository, final product specification, and confirmed release date were not located during verification.
Related Tools
- DeepSeek API: The official platform for API keys, billing, and direct access to DeepSeek models.
- DeepSeek V4 Flash 0731 on Hugging Face: Official open-weight checkpoint, model card, benchmark table, license, and deployment instructions.
- vLLM: An open-source high-throughput serving engine with DeepSeek V4 and DSpark support.
- SGLang: An open-source serving framework with a published V4 Flash 0731 deployment path.
- OpenCode: An open-source coding agent whose Zen service currently lists a limited-time free V4 Flash option.
- Cline: An open-source coding agent and model platform that offers DeepSeek V4 Flash through its provider ecosystem.
- Nous Portal: A multi-model inference platform that ran a limited DeepSeek V4 Flash promotion.
- Artificial Analysis: An independent model-analysis platform covering intelligence, speed, price, and benchmark cost.
Related Links
- DeepSeek July 31 Change Log: Official release status, benchmark results, methodology notes, API scope, and post-training statement.
- DeepSeek Models and Pricing: Current official prices, context length, output limit, features, and concurrency.
- DeepSeek V4 Flash 0731 Model Card: Architecture notes, benchmark comparison, reasoning-effort levels, DSpark configuration, and MIT License.
- DeepSeek V4 Technical Model Card: Original V4 architecture, parameter counts, technical report, and model-family evaluation.
- DeepSeek Thinking Mode Guide: Official guidance for reasoning output and preserving
reasoning_contentacross tool calls. - DeepSeek Agent Integrations: Official example for connecting V4 Flash to a terminal coding harness.
- OpenCode Zen Models: Current model catalog and limited-time free-model information.
- Artificial Analysis V4 Flash 0731 Evaluation: Independent composite score, price, agent evaluation, and reliability observations.
Summary
DeepSeek V4 Flash 0731 keeps the Preview model’s base
The architecture and size remain the same, but new post-training techniques deliver a major leap in coding-agent performance. DeepSeek reports scores of 82.7 on Terminal Bench 2.1, 76.7 on CyberGym, and 54.4 on DeepSWE, although the strongest public code-agent results rely on an unreleased DeepSeek Harness configuration.
The official API pricing is unusually low: $0.14 per million uncached input tokens, $0.0028 per million cached input tokens, and $0.28 per million output tokens. Third-party free quotas and discounts can make access even cheaper, but those promotions are temporary and should not be mistaken for the permanent list price.
The open-weight MIT release, 1-million-token context window, Responses and Anthropic-compatible APIs, and support in vLLM and SGLang make the model accessible across both hosted and self-managed deployment routes. Full local deployment remains a serious multi-GPU infrastructure undertaking.
The viral seven-cent and fifty-cent prototypes are plausible illustrations of how low the marginal model bill can go, but they are not complete product-cost analyses. Agent loops, output length, cache misses, tools, testing, and human effort still matter.
DeepSeek V4 Flash 0731 matters not because every application now costs just a few cents, but because capable agentic coding has become affordable enough for far more developers to experiment at a meaningful scale.