DeepSeek-V4-Flash: Local Deployment, Quantization, and Agent Testing

One-sentence takeaway

Whether V4-Flash can run locally depends on multi-GPU/quantization choices and remaining context headroom; the two small Open Code Agent projects behaved coherently but still produced real data errors, so deployment decisions cannot be based on benchmarks or token prices alone.

Use cases

• Suitable tasks: Teams with existing dual DGX Spark systems or comparable VRAM resources, for code Agents, data residency, controllable latency, and long-term API cost assessment.

• Unsuitable tasks: Plug-and-play deployment on a single ordinary GPU, native visual/audio input, and factual applications that require no human verification.

• Applicable model versions: The article discusses DeepSeek-V4-Flash 0731 and local weights with the same architecture; the specific quantization file versions are not given in the article.

• Applicable clients, Agents, or APIs: A local Open Code harness; the article also discusses the DeepSeek API.

• Recommended inference tier and parameters: The article does not disclose complete API parameters or the Agent system prompt; do not treat approximately 25–30 tok/s as the default for all hardware configurations.

Test environment, inputs/configuration

• Local hardware: A cluster of two NVIDIA DGX Spark systems; the article also discusses a single 128 GB system with Dwarf Star SSD offload, KV cache operations, and mixed-precision approaches.

• Quantization estimates: 4-bit requires approximately 168 GB of VRAM; 3-bit requires approximately 110 GB, neither including the additional memory required for usable context.

• Inference engine/Agent: Open Code; Dwarf Star as another engine strategy for reducing VRAM pressure.

• Tasks: Build a Pokémon encyclopedia website; build a space station tracker that calls a real-time API.

• Complete inputs and configuration: The article does not disclose the complete prompt, tool schema, number of repetitions, quantization file hash, or code repository, so this cannot be treated as a strictly reproducible benchmark.

Results

• The article reports that DeepSweep rose from approximately 7% to 54%, emphasizing that the improvement came mainly from post-training; this figure is taken from the official/article discussion and is not an independent score rerun by the author.

• Open Code testing on two DGX Spark systems achieved approximately 25–30 tokens/s.

• The Pokémon project consumed approximately 19,000 tokens; the author observed that the model maintained a visible todo list and produced output that was more structured and less redundant than early DeepSeek models.

• Neither Agent project produced “major errors”; the space station tracker had a more complete interface, but its location data showed only North America, creating a factual/data correctness issue.

• The API reference prices given in the article are approximately 0.02 USD per million input tokens and 0.30 USD per million output tokens; prices change over time and with peak/off-peak periods, so the official price list should be checked before procurement.

Conclusion

The main bottleneck for local deployment is VRAM and context headroom, not whether the model can start; two DGX Spark systems can reach interactive speeds. For production Agents, the article's most valuable signal is that “planning and todo maintenance remain good” and “real data can still be wrong” at the same time. Data validation, source verification, and human acceptance testing should therefore remain in place.

Limitations

• This is a single-author field report, not a blind test or controlled multi-model experiment; it lacks the complete prompt, tool records, failure rate, number of repetitions, and quantization file version.

• The article explicitly warns that DeepSeek's Agent scores use a proprietary optimized harness, and harness differences may significantly change the benchmark; its local Open Code results likewise cannot be directly equated with the bare model's capabilities.

• The 4-bit/3-bit VRAM figures are model-loading estimates, not minimum configurations that include long contexts, KV cache, concurrency, and system overhead.

• The article's API prices are approximate values from the collection date and cannot replace the official 0731/current prices.

Reproduction steps

1. Fix the specific V4-Flash weights, quantization format, inference engine version, and VRAM layout, and record whether SSD offload/KV cache optimizations are enabled.

2. Run the Pokémon encyclopedia and space station tracker with the same Open Code harness, saving the system prompt, tool schema, commit, token count, speed, and error logs.

3. Repeat the runs at least several times and add data-source validation tests, paying particular attention to the real-time API's geographic coverage and timestamps.

4. Record throughput, time to first token, peak VRAM, cost, and task success criteria separately in single-GPU, dual-DGX-Spark, and API environments.

5. Run a baseline without the DeepSeek-specific harness in parallel to isolate model improvements from orchestration improvements.

Original evidence and data

The key deployment figures given in the article are 4-bit 168 GB, 3-bit 110 GB, and approximately 25–30 tok/s on two DGX Spark systems; the case-study data is approximately 19K tokens for Pokémon, with the space station tracker showing a North-America-only location-data error. The author also warns that the harness's impact on Agent benchmarks cannot be ignored.

Source excerpt or observation (for compliant short quotation only)

The article summarizes the actual results as “Both tasks ran without major errors,” but immediately records that the tracker's location data was inaccurate; this is precisely the boundary between “code generation succeeded” and “the product's facts are correct.”