DeepSeek V4 Flash Built a 3D Shooter for $0.07—Here Is Why the Model Is So Cheap

Introduction

DeepSeek V4 Flash 0731 entered public beta with a familiar promise: stronger coding and agent capabilities at a very low API price.

Developers quickly turned that claim into practical experiments.

One of the most widely shared examples came from a Hermes Agent run in which DeepSeek V4 Flash generated a playable first-person 3D shooting game from a single initial prompt. The project reportedly took 32 minutes and cost $0.07 in model usage.

The result included:

• First-person movement.
• Jumping.
• Shooting.
• Physical collision with the environment.
• Cover objects and targets.
• An ammunition counter in the interface.

The viral conclusion was simple: at that rate, two dollars could support a full day of experimentation.

That statement should not be interpreted as a universal daily cost guarantee. Agent expenses depend on prompt length, output volume, retries, tool use, cache hits, framework overhead, and the complexity of the task.

Still, the demo captures the central appeal of V4 Flash: the model is inexpensive enough that developers can let an agent iterate rather than treating every attempt as a costly event.

The model’s official API pricing helps explain why.

DeepSeek V4 Flash 0731 Is Now the Official Flash Release

DeepSeek released the production version of V4 Flash to public API beta on July 31, 2026.

The API model name remains:

deepseek-v4-flash

Requests using that model now access DeepSeek-V4-Flash-0731.

DeepSeek says the 0731 release replaces the preview model and substantially improves agentic capabilities.

The update applies specifically to:

• The DeepSeek V4 Flash API.
• The public V4 Flash model weights.
• Responses API compatibility.
• Codex-oriented integration.

It did not simultaneously replace:

• The DeepSeek V4 Pro API.
• Models used in the DeepSeek web application.
• Models used in the DeepSeek mobile application.

DeepSeek also says the official V4 Pro release will follow separately.

The Official API Price Is Extremely Low

DeepSeek currently lists the following regular API prices per one million tokens:

Billing Item	DeepSeek V4 Flash
Input with cache hit	$0.0028
Input with cache miss	$0.14
Output	$0.28
Context length	1 million tokens
Maximum output	384,000 tokens
Default reasoning mode	Thinking
Concurrency limit	2,500

The cache-hit price is especially low.

At $0.0028 per million cached input tokens, a long-running agent can repeatedly reuse a stable prefix—such as system instructions, tool schemas, or repository context—without paying the full uncached rate each time.

DeepSeek has also announced a future peak and off-peak pricing policy.

When that policy becomes effective, all listed prices will be doubled during these Beijing-time periods:

09:00–12:00
14:00–18:00

DeepSeek had not yet specified the final effective date on the pricing page reviewed for this article.

Applications should therefore check the official pricing page before relying on one fixed long-term rate.

One Cent Versus One Dollar

The original article compares DeepSeek V4 Flash with Claude Opus 5 through a small space-shooter project.

Both versions reportedly implemented:

• Spaceship movement.
• Shooting.
• Destructible asteroids.
• Collectable items.
• A playable game loop.

The difference appeared in the path to completion.

According to the developer comparison:

Detail	DeepSeek V4 Flash	Claude Opus 5
Attempts before acceptable result	3	1
Approximate code size	900 lines	Nearly 3,000 lines
Reported model cost	$0.01	$1.00

The Opus result was completed in one pass, while V4 Flash needed additional iteration.

The final projects were described as functionally similar enough that the 100× reported cost difference became the main point of discussion.

This was not a controlled model benchmark.

The comparison did not publish a complete reproducibility package covering:

• Identical agent frameworks.
• Exact prompts and follow-up messages.
• Tool-call logs.
• Runtime limits.
• Token accounting rules.
• Model effort settings.
• Human intervention.
• Whether assets or boilerplate were provided.

The result should therefore be treated as a useful developer anecdote, not proof that V4 Flash is always exactly 100 times cheaper than Opus 5 for equivalent work.

DeepSeek V4 Flash Versus GPT-5.6 Sol

Another comparison asked DeepSeek V4 Flash and GPT-5.6 Sol to build a small 3D river-navigation game.

Both reportedly produced:

• A complete river scene.
• Left and right movement.
• Obstacle collisions.
• Score tracking.
• Trees and distant scenery.
• Similar core interactions.

The reported costs were:

Model	Reported Cost
DeepSeek V4 Flash	$0.05
GPT-5.6 Sol	$2.47

That is close to a 50× difference in the specific run.

The visual quality was described as broadly similar, although the DeepSeek version used a smaller-scale environment.

Again, the comparison is anecdotal.

GPT-5.6 Sol and DeepSeek V4 Flash have different default reasoning behaviors, pricing structures, context-management systems, agent harnesses, and token accounting.

A fair production comparison should measure:

total task cost
÷
number of successful, acceptable outcomes

The cheapest individual request is not always the cheapest completed project.

A model that needs many retries, creates maintenance-heavy code, or requires extensive human review can lose its initial price advantage.

Token Volume Can Change the Cost More Than Visual Quality

The article also describes a test in which GPT-5.6 Luna and DeepSeek V4 Flash generated a 3D Pokémon-style model from the same requirement.

The reported visual results were difficult to rank clearly, but the output-token totals were very different:

Model	Reported Output
GPT-5.6 Luna	More than 2.3 million tokens
DeepSeek V4 Flash	About 477,000 tokens

The source reports a total task-cost difference of nearly 14×.

The key lesson is not that one model always uses exactly this many tokens.

It is that agent economics depend on more than the list price per million tokens.

Total cost is shaped by:

• Output verbosity.
• Repeated file rewrites.
• Tool-call transcripts.
• Reasoning tokens.
• Failed attempts.
• Context replay.
• Cache reuse.
• Generated code volume.
• Agent framework behavior.

A model can have a relatively low token price and still become expensive if it produces unnecessary output.

V4 Flash’s value proposition combines a low list price with relatively compact execution in several of the reported examples.

Two Hours of Experimentation for Seven Cents

Another developer said they had spent almost two hours experimenting and paid only seven cents.

The comment illustrates how low marginal cost changes user behavior.

When a model call feels expensive, developers tend to:

• Limit iterations.
• Shorten prompts.
• Avoid exploratory branches.
• Stop after a result is “good enough.”
• Reserve agents for high-value work.

When the cost is measured in cents, developers can allow more:

• Trial and error.
• Parallel ideas.
• Automated testing.
• Repair attempts.
• Long-running background work.
• Small experiments that might otherwise be skipped.

That does not mean compute is free.

At enterprise scale, fractions of a cent multiplied by millions of calls still become a significant expense.

The more meaningful change is that the threshold for experimentation becomes much lower.

Why Is DeepSeek V4 Flash So Cheap?

The article attributes V4 Flash’s low cost to several architectural and systems-level choices.

The main factors are:

1. Sparse Mixture-of-Experts computation.
2. Compressed long-context attention.
3. Low-precision model weights.
4. Speculative decoding through DSpark.
5. Post-training improvements without another full pretraining run.
6. High-concurrency API serving.

Each part reduces a different category of cost.

A 284B Model That Activates Only 13B Parameters

The core DeepSeek V4 Flash model uses a Mixture-of-Experts architecture.

The technical report lists:

Architecture Detail	DeepSeek V4 Flash
Core model parameters	284 billion
Parameters activated per token	13 billion
Context length	1 million tokens
Training data	More than 32 trillion tokens
Core precision	FP4 + FP8 mixed precision

Although the model stores hundreds of billions of parameters, each token does not run through all of them.

A routing mechanism selects a small subset of experts.

That reduces the active computation needed for each token while preserving access to a much larger parameter pool.

A simplified comparison looks like this:

Dense model:
every token → most or all model weights

MoE model:
every token → selected experts only

This is one reason a large MoE model can be much cheaper to serve than a dense model with a similar total parameter count.

Why Some Pages Show 304B Parameters

The Hugging Face metadata for the complete DeepSeek-V4-Flash-0731 repository currently displays approximately 304B parameters.

That does not contradict the 284B core-model figure in the technical report.

The 0731 release includes an attached DSpark speculative-decoding module. Repository metadata may count the target model and attached draft components together.

For architecture discussions, DeepSeek’s technical report remains the clearest source:

• 284B total parameters in the core V4 Flash model.
• 13B activated parameters per token.
• Additional DSpark weights for speculative decoding in the 0731 release.

CSA and HCA Reduce Long-Context Costs

DeepSeek V4 supports a one-million-token context window.

A conventional attention system can become extremely expensive at that scale because each new token may need to examine a large amount of prior context and maintain a large KV cache.

DeepSeek’s technical report describes a hybrid attention design combining:

• Compressed Sparse Attention (CSA)
• Heavily Compressed Attention (HCA)

The broad strategy is to avoid performing full, expensive attention over the entire history at every step.

The system compresses and filters context so the model can focus computation on the most useful information.

DeepSeek reports that, in a one-million-token context setting, V4 Pro requires:

• 27% of the single-token inference FLOPs used by DeepSeek V3.2.
• 10% of the KV-cache capacity.

Those exact percentages are reported for V4 Pro in the technical paper, not as a separate audited number for Flash.

V4 Flash uses the same architectural family, so it benefits from the same long-context design principles.

The practical effects include lower:

• KV-cache memory.
• GPU memory pressure.
• Data movement.
• Per-token compute.
• Long-context serving cost.

FP4 and FP8 Reduce Storage and Memory Traffic

The released V4 Flash model uses mixed low-precision weights.

DeepSeek lists:

FP4 + FP8 mixed precision

Lower precision reduces the amount of data that must be stored, loaded from memory, transferred between devices, and processed during inference.

This matters because modern language-model inference is often limited by memory bandwidth rather than raw arithmetic alone.

A smaller representation can increase throughput if the hardware and kernels are designed to execute it efficiently.

Low precision is not automatically free.

Poor quantization can reduce model quality.

DeepSeek’s release is designed and trained around the selected precision scheme rather than relying only on an after-the-fact community quantization.

The Architecture Did Not Change Between Preview and 0731

DeepSeek states that the official 0731 release keeps the same model architecture and size as V4 Flash Preview.

The company did not perform another full pretraining run for the update.

Instead, it redid the post-training process.

The source article summarizes the change as:

• New supervised fine-tuning.
• New GRPO reinforcement learning.
• DSpark speculative decoding.
• Better agent behavior.
• Higher serving throughput.

DeepSeek’s technical report describes the broader V4 post-training process as:

1. Independent development of domain-specific experts.
2. Supervised fine-tuning and reinforcement learning with GRPO.
3. On-policy distillation.
4. Consolidation of specialist capabilities into one model.

The 0731 update focuses on improving how those capabilities appear in practical agent workflows.

DSpark Accelerates Token Generation

DeepSeek-V4-Flash-0731 ships with a DSpark speculative-decoding module.

Speculative decoding uses a smaller or cheaper draft path to propose several future tokens.

The main model verifies those proposals in a batch.

A simplified flow is:

draft module proposes tokens
→ main model verifies them together
→ accepted tokens are emitted
→ rejected path is corrected

When the draft predictions are accurate, the system can generate several accepted tokens with fewer expensive sequential passes through the main model.

DeepSeek provides DSpark support for both vLLM and SGLang.

For vLLM, the official model card uses:

--speculative-config '{"method":"dspark","num_speculative_tokens":7,"draft_sample_method":"greedy"}'

For SGLang, the corresponding option is:

--speculative-algorithm DSPARK

DeepSeek says the target and draft weights are stored in the same checkpoint, so SGLang does not require a separate draft-model path.

Speculative decoding primarily improves serving speed and throughput.

It does not explain the model’s reasoning improvements by itself.

Those come from the updated post-training process.

The Official Release Improved Agent Benchmarks

DeepSeek reports large gains over V4 Flash Preview across several agent-focused tests.

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

DeepSeek says public code-agent benchmarks were run using:

DeepSeek Harness minimal mode
reasoning_effort = max
top_p = 0.95
temperature = 1.0

The harness had not yet been released at the time of the official update.

DSBench-FullStack and DSBench-Hard are internal DeepSeek benchmarks.

That means their scores are useful as company-reported evidence but are not as independently inspectable as fully public benchmark suites.

What Terminal Bench and Toolathlon Measure

Terminal Bench 2.1

Terminal Bench evaluates agents completing tasks inside a terminal environment.

The model may need to inspect files, run commands, install dependencies, debug failures, modify code, and verify completion.

A high score reflects the combined performance of the model, agent harness, tool policies, reasoning budget, and runtime environment.

Toolathlon-Verified

Toolathlon evaluates long-horizon tasks across many software applications and tools.

The benchmark includes scenarios involving calendars, file systems, Notion, WooCommerce, Kubernetes, and BigQuery.

Tasks require multiple tool interactions and are checked through execution-based evaluators.

The 70.3 score reported by DeepSeek represents a major gain over the preview model.

It should not be interpreted as a 70.3% guarantee for every real business automation.

Benchmark Gains Do Not Guarantee Every Game Works in One Prompt

The source’s game examples reveal an important difference between benchmark performance and creative coding.

V4 Flash performed strongly in official agent evaluations, but one game comparison still needed three iterations.

A benchmark can measure success on a defined task set with known evaluation rules.

A creative project may include ambiguous visual requirements, browser compatibility problems, physics bugs, missing assets, subjective quality, and no single test suite that defines success.

A low-cost model is particularly useful in this setting because the workflow can afford iteration.

Its value is not necessarily perfect first-pass generation.

It may be:

acceptable quality
×
many affordable attempts

V4 Flash Supports Multiple API Formats

DeepSeek exposes the model through:

• OpenAI-compatible Chat Completions.
• OpenAI-compatible Responses API.
• Anthropic-compatible API.
• JSON output.
• Tool calls.
• Chat prefix completion.
• Fill-in-the-middle completion in non-thinking mode.

The OpenAI-compatible base URL is:

https://api.deepseek.com

The Anthropic-compatible base URL is:

https://api.deepseek.com/anthropic

DeepSeek says V4 Flash is the only current V4 API model with Responses API support.

V4 Pro support is planned separately.

The Responses API compatibility also allows the model to be used through Codex with DeepSeek’s documented configuration.

Thinking Mode Is Enabled by Default

DeepSeek V4 Flash supports thinking and non-thinking modes.

Thinking mode is the default.

For local inference, the official model card supports three reasoning-effort levels:

low
high
max

DeepSeek recommends:

temperature = 1.0
top_p = 0.95

for agentic scenarios.

For high and max reasoning effort, the company recommends allowing a maximum output length of up to 384K tokens.

Higher reasoning settings can improve difficult tasks, but they can also increase latency, output volume, API cost, and agent-loop duration.

Production systems should evaluate the lowest effort level that reliably meets the task requirement.

The Weights Are Available Under the MIT License

DeepSeek publishes the V4 Flash 0731 weights on Hugging Face under the MIT License.

That makes the model unusually permissive compared with many large commercial releases.

Developers can use the official model repository with supported engines including:

• vLLM.
• SGLang.
• Transformers.
• Docker Model Runner.
• llama.cpp-compatible quantizations.
• LM Studio-compatible community builds.

The model is large.

The core model has 284B parameters, with an additional DSpark component in the 0731 checkpoint.

Running it at useful speed requires substantial memory and hardware.

The fact that weights are downloadable does not mean the full model runs comfortably on an ordinary consumer laptop.

Community quantizations can reduce memory requirements, but they may alter accuracy, throughput, context capacity, DSpark behavior, and tool-call reliability.

Is V4 Flash Always the Best Value?

The source concludes that V4 Flash may not produce the best result in every comparison, but it is difficult to beat on value.

That is a reasonable summary of the examples, with one important condition:

Value depends on the complete workflow.

V4 Flash is especially attractive when:

• Request volume is high.
• Errors are easy to detect.
• Tasks can be retried automatically.
• Context caching works well.
• Human review is inexpensive.
• Compact code is acceptable.
• The application can use an open-weight model.

A more expensive frontier model may still be cheaper overall when:

• One failed result creates a large loss.
• First-pass reliability is critical.
• The task requires deeper knowledge.
• The agent cannot safely retry.
• Human review is expensive.
• A smaller model creates difficult-to-maintain output.

The correct comparison is not:

price per token

It is:

cost per verified successful task

How to Evaluate V4 Flash for a Real Project

Step 1: Choose Representative Tasks

Do not test only a polished demo.

Use tasks that match the production workload, including difficult and messy cases.

Step 2: Fix the Agent Environment

Keep the prompt, tools, time limit, retry policy, framework, sandbox, test suite, and reasoning setting consistent across models.

Step 3: Record Full Cost

Track uncached input, cached input, output tokens, tool calls, retries, runtime, human review, and failed attempts.

Step 4: Measure Acceptance, Not Visual Similarity Alone

For code, run tests and inspect maintainability.

For games, check controls, collisions, performance, and browser compatibility.

Step 5: Test Cache Behavior

A model with a very low cache-hit price becomes more valuable when stable context is reused across many agent steps.

Step 6: Compare First-Pass and Final Success

A model that succeeds after three cheap attempts may be a better value than a model that succeeds once at a high price.

The opposite can also be true when retries are slow or risky.

常见问题

What is DeepSeek V4 Flash 0731?

DeepSeek V4 Flash 0731 is the official post-trained release of DeepSeek’s smaller V4 Mixture-of-Experts model. It replaces the preview version, adds a DSpark speculative-decoding module, and focuses heavily on coding and tool-using agent tasks.

How much does the DeepSeek V4 Flash API cost?

DeepSeek currently lists regular prices of $0.0028 per million cache-hit input tokens, $0.14 per million cache-miss input tokens, and $0.28 per million output tokens. The company has announced a future policy that will double prices during specified peak hours.

Did DeepSeek V4 Flash really build a 3D game for $0.07?

A developer reported that a Hermes Agent run produced a playable first-person shooter in 32 minutes for $0.07. This is a social-media case study rather than a standardized benchmark, so other tasks may cost more or less.

How many parameters does DeepSeek V4 Flash have?

The V4 technical report lists the core Flash model at 284B total parameters with 13B activated per token. The complete 0731 repository may display roughly 304B because it includes the attached DSpark speculative-decoding component.

Why is DeepSeek V4 Flash so cheap?

Its low cost comes from sparse MoE activation, compressed long-context attention, FP4/FP8 mixed precision, prompt caching, speculative decoding, and high-concurrency serving. Only a small fraction of the total experts is activated for each token.

Is DeepSeek V4 Flash better than Claude Opus 5 or GPT-5.6?

It is much cheaper under current API pricing and performed competitively in several community demos. Opus 5 and GPT-5.6 may still provide stronger first-pass reliability or quality on some tasks, and the viral comparisons were not controlled benchmarks.

Can DeepSeek V4 Flash run locally?

Yes. DeepSeek publishes the weights under the MIT License and provides guidance for vLLM and SGLang. The full model is extremely large, so practical local deployment requires substantial accelerator memory or aggressive community quantization.

Does V4 Flash support Codex and the Responses API?

Yes. DeepSeek says the official Flash release natively supports the Responses API and is adapted for use with Codex. The current V4 Pro API does not yet support the Responses API.

相关工具

• DeepSeek API: The official hosted endpoint for DeepSeek V4 Flash and other supported models.
• DeepSeek V4 Flash 0731: The official model repository, weights, benchmarks, license, and deployment guidance.
• vLLM: A high-throughput inference engine with an official recipe for V4 Flash and DSpark.
• SGLang: An LLM serving framework with documented V4 Flash and DSpark support.
• DeepSpec: DeepSeek’s repository for speculative-decoding research and the DSpark method.
• Codex: An agentic coding environment that can connect to V4 Flash through DeepSeek’s Responses API compatibility.

Related Links

• DeepSeek V4 Flash Official Update: The July 31 changelog with the official release status, benchmarks, and API scope.
• DeepSeek API Models and Pricing: Current token prices, context length, output limit, concurrency, and future peak-pricing notice.
• DeepSeek V4 Technical Report: The primary paper describing the MoE architecture, CSA/HCA attention, precision, training, and million-token context.
• DeepSeek V4 Flash Model Card: Official 0731 benchmark table, chat encoding, DSpark configuration, and MIT license.
• DeepSeek Codex Integration: Official instructions for using V4 Flash through Codex and the Responses API.
• Toolathlon Paper: The research paper describing the long-horizon multi-tool benchmark used in the official evaluation.
• V4 Flash vLLM Recipe: Hardware and serving guidance for V4 Flash deployments.

Summary

DeepSeek V4 Flash 0731 attracted attention because developers reported building complete interactive demos for only a few cents. A first-person shooter reportedly cost $0.07, while other social-media comparisons showed task costs dozens of times lower than Claude Opus 5 or GPT-5.6.

Those examples are not controlled benchmarks, but the official API prices support the underlying point. V4 Flash costs $0.14 per million uncached input tokens and $0.28 per million output tokens, with an unusually low $0.0028 cache-hit rate.

The economics come from the entire system: a 284B MoE core that activates 13B parameters per token, compressed long-context attention, FP4/FP8 weights, a one-million-token context window, efficient serving, and DSpark speculative decoding. The 0731 update keeps the preview architecture and improves agent behavior through new post-training.

The strongest official evidence is the benchmark improvement. Terminal Bench 2.1 rose from 61.8 to 82.7, and Toolathlon-Verified increased from 49.7 to 70.3, while the model retained the Flash pricing tier.

V4 Flash’s advantage is not that it wins every comparison—it is that its low marginal cost makes repeated agentic experimentation practical at a scale that would be difficult with many frontier-priced models.