On July 31, 2026, DeepSeek officially released an API update via
their Changelog,
introducing a Public Beta version with the build name
DeepSeek-V4-Flash-0731, while the API model alias remains
deepseek-v4-flash. This update only upgraded the
DeepSeek-V4-Flash API; neither the web interface nor the V4-Pro API
received updates. At the underlying architectural level, it shares the
same structure as the April Preview version—still an MoE architecture
with 284B total parameters and 13B activated parameters per token—and
has simply undergone re-post-training (Re-post-trained).
Self-media and social feeds were quickly flooded with headlines claiming 0731 achieves legendary performance, approaches Opus 4.8, and sets a cost-effectiveness “execution line.” On paper alone, its pricing has a clear low-cost advantage: during a cache miss, the input price is $0.14 / 1M tokens and the output price is $0.28 / 1M tokens; when a long-context Context Cache Hit is triggered, a 98% discount drops the input price to $0.0028 / 1M tokens. Under Artificial Analysis’s benchmarked 7:2:1 (hit:input:output) typical mixed workload, the blended cost is only ~$0.06 / 1M tokens. Compared with top-tier and flagship models such as GPT-5.6 Sol ($5/$30), Claude Opus 5 ($5/$25), Sonnet 5 ($2/$10), Gemini 3.6 Flash ($1.5/$7.5), and even Gemini 3.1 Pro ($2/$12), 0731 firmly resides in the lowest unit price tier on the market. However, a low list price on paper does not equate to cheap final output, nor does it mean its capabilities match the frontier.
In the independent measurement of the Artificial Analysis Intelligence Index v4.1 released on July 31, 2026, DeepSeek-V4-Flash-0731 scored 50 points under the Max effort setting. Although this is a 10-point increase from the Preview version’s 40 points, placing it at #2 in the open-weights category benchmark (second only to Kimi K3 max at 57 points), looking across the broader LLM market, a score of 50 horizontally positions it within the commercial mid-tier and lightweight API model tier. That is, it sits at the same level as closed-source models such as Gemini 3.6 Flash (50 points), GPT-5.6 Luna (51 points), and GLM-5.2 (51 points), while remaining at a clear distance from the top-tier frontier flagship tier scoring 60–70+ points.
Synthesizing these independent measurements, its true category positioning is crystal clear: within major providers’ product tiers (ranging from OpenAI’s Sol/flagship, Terra/Mini, down to Luna/Nano, or Google’s Pro to Flash), Flash corresponds to a Nano/lightweight tier positioned two tiers below the flagship. The true value of DeepSeek-V4-Flash-0731 lies in delivering Nano-tier performance at a unit price below Nano-tier models, offering notable cost efficiency within the lightweight tier. However, the promotional myth spread by self-media and social feeds stems from mistakenly packaging a Nano/lightweight-tier model into a frontier disruptor capable of directly replacing flagship Controllers like Sol or Opus.
In the official Changelog, the benchmark increase on DeepSWE is the most striking: 0731’s score rose from 7.3 points in the Preview version to 54.4 points, and is presented in the same comparison table alongside Opus 4.8 (58.0 points) measured under established testing. Achieving such a noticeable gain in software engineering benchmarks for a lightweight model—without altering the underlying pre-training architecture and relying solely on re-post-training—naturally attracts widespread attention. However, reviewing our deep-dive analysis from May 2026, “After SWE-Bench Pro Saturated, Someone Built a New Ruler”, reveals key methodological nuances behind this score comparison that need to be clarified.
On the SWE-Bench Pro leaderboard, which is susceptible to data contamination and overfitting, major models once scored quite closely: GPT-5.5 reached 82.6%, Claude Opus 4.7 achieved 82%, Gemini 3.5 Flash scored 79.8%, and DeepSeek V4 Pro earned 76.2%. When the Datacurve team introduced the more rigorously validated DeepSWE benchmark in May, they conducted a one-time audit sampling across major models, resulting in sharp divergence: GPT-5.5 held at 70%, Opus 4.7 scored 54%, Gemini 3.5 Flash dropped to 28%, and the higher-tier DeepSeek V4 Pro fell to 8%. The credibility of DeepSWE as a new ruler rested on two core mechanisms: first, a held-out dataset of 113 private problem sets written from scratch by maintainers; second, all models were evaluated uniformly under the mini-swe-agent Harness test framework and the same Docker environment.
The most critical technical detail lies in how metrics evolve after a
test dataset becomes public. As Goodhart’s Law reminds us: when a
measure becomes a target, it ceases to be a neutral metric. As Datacurve
open-sourced DeepSWE’s task details and evaluation framework on GitHub,
once the task structures and validation logic of the test set were
exposed, subsequent re-post-training and harness engineering naturally
optimized specifically around that distribution. Checking the Datacurve DeepSWE Official Public
Leaderboard, as of August 1, 2026, the 0731 Flash model is not
present among the models uniformly blind-tested by Datacurve on the
public leaderboard. Meanwhile, the self-reported 54.4 score in
DeepSeek’s official Changelog specifies the use of their unreleased
DeepSeek Harness minimal mode. As pointed out by Mehmet
Özel and Iolaum in the Hacker News
community discussion, comparing a score of 54.4 produced via a
custom harness on a public dataset side-by-side with Opus 4.8 (58.0
points) measured under standard blind testing reflects the joint
optimization of harness and specific dataset distribution, which should
be viewed objectively in light of its bound environment.
To understand the Harness difference here, one must grasp the true role of test harnesses in commercial engineering. Historically, DeepSeek focused on low-level pre-training and reinforcement learning algorithms without possessing its own consumer-facing coding subscription products (like Cursor or Claude Code), leaving a relative shortfall in evaluation harness engineering. The introduction of their self-developed DeepSeek Harness minimal mode in 0731 demonstrates that the team has begun building up application-layer harness engineering capabilities. Here, “minimal mode” is a standard term in LLM evaluation, referring to a streamlined single-agent harness modeled after mini-swe-agent (providing only basic file viewing and editing tools without layering complex multi-agent architectures). A harness is essentially a software engineering shell wrapped around the LLM, responsible for handling system prompt packaging, tool call parsing, environment state management, and retry strategies. Although DeepSeek has not yet open-sourced the specific code for this harness, general harness engineering principles suggest that custom harnesses typically optimize prompts for their model’s output habits and provide tolerant parsing for specific formatting flaws. This engineering reinforcement reflects progress in application-layer adaptation, but also explains why scores run under a custom harness cannot be directly equated with results obtained under a standard blind-tested harness.
If benchmark methodology differences belong to evaluation-level details, the model’s shortcomings in foundational reliability represent a core factor impacting engineering deployment. Artificial Analysis’s AA-Omniscience Index, which evaluates model factual accuracy, shows that while 0731’s hallucination rate dropped 12 percentage points from the Preview version’s 96%, it remains high at 84% (with an accuracy rate of 37%). Comparing performance across model tiers, flagship models like Claude Sonnet 5 typically maintain hallucination rates around 37%, Mini-tier models like Gemini 3.6 Flash hover around 55%, while Nano-tier models like GPT-5.6 Luna sit around 90%. The 84% hallucination rate of 0731 clearly confirms that it resides within the reliability range of a typical Nano-tier model, remaining inclined to generate content rather than refuse to answer when faced with uncertain responses.
(Update: Some readers have seen GPT-5.6 Sol’s hallucination rate
listed as 88.8% on secondary aggregator sites. We were unable to find
this number on the Artificial
Analysis original page; it is more likely a transcription or
conflation of different effort variants by a secondary aggregator. That
said, this does raise a point worth clarifying: what does a high
hallucination rate actually mean? According to AA’s
definition, the hallucination rate measures the proportion of
incorrectly answered questions among all non-correct responses—that is,
incorrect / (incorrect + partial answers + not attempted).
In other words, it measures whether a model fabricates when it doesn’t
know the answer, not how much it actually knows. A flagship model with
58% accuracy and a lightweight model with 37% accuracy may have similar
hallucination rates, but the former genuinely commands far more
knowledge, so its absolute fabrication surface is smaller. Relying on
hallucination rate alone can therefore be misleading; it needs to be
read alongside accuracy. If we use accuracy for tier positioning
instead, the numbers are more straightforward: on the same
AA-Omniscience test, GPT-5.6 Sol scores 58.5%, GPT-5.6 Terra 45.9%,
GPT-5.6 Luna 41.5%, and DeepSeek V4 Flash 0731 37%. The tier gap is
immediately visible, and the conclusion holds: 0731 is a Nano-tier
model.)
This relatively high hallucination rate is further amplified by its tendency toward verbose generation. Artificial Analysis measured that 0731 consumed 206 million Output Tokens when completing the Intelligence Index (compared to a median of 99 million), reaching a maxed-out Verbosity rating of 4/4. As we previously explored in “A Scratchpad, A Controller: Re-understanding LLM Reasoning”, the ceiling of an Agent system’s capabilities depends on the determinism and context quality of the Controller, rather than output length alone. Verbose output expands the potential surface area for hallucination exposure and drives up the actual Token consumption bill.
In concrete Tool Calling engineering deployments, the formatting
flaws manifested are even more specific. According to engineering
retrospectives by Ahmad
Awais and Kilo.ai,
0731 frequently exhibits four types of formatting issues during tool
calls: sending null for optional fields, outputting JSON
arrays as escaped strings, incorrectly wrapping arrays as single
objects, and outputting file paths as Markdown autolinks (e.g.,
[notes.md](http://notes.md)). Without building a
Tool-calling repair layer (a code layer that automatically fixes
malformed JSON or path errors), Agent workflows can easily break.
Additionally, API-layer stability entails adaptation costs; both n8n Issue #29661
and DeepSeek-V3
Issue #1244 document related errors and output format drift
issues.
Setting aside benchmark details and evaluating 0731 from a production engineering deployment perspective requires returning to the balance between overall compute costs and acceptance rates. Bruno Škvorc of Lindy shared in an official blog post that migrating hosted Agent traffic to DeepSeek reduced inference costs by approximately 90%, but emphasized that a single validation does not equal long-term product stability. Dan Gurgui’s empirical testing on ArchitectureForGrowth recorded that in certain switch scenarios, Sub-agent execution times extended significantly while consuming more Tokens, and outputs still required human review. This corresponds to the Agent production economics concept proposed by NxCode: Cost per accepted task—the true cost per accepted modification is the ultimate decisive metric. A workflow that is cheap per invocation but requires multiple retries may not have a lower overall cost than a workflow with a higher unit price that passes in a single attempt.
From the physical characteristics of task types, 0731’s performance exhibits a fundamental divide between Agentic scenarios and data processing scenarios. In open-ended Agentic tasks (such as autonomous refactoring across multiple files or unconstrained software development), the decision error space is vast. Once a child node makes an erroneous decision in the first few steps of a multi-turn loop, errors compound exponentially, causing the model to run continuously for half an hour, consume nearly 100,000 Tokens, and ultimately still fail.
Conversely, in data pipelines equipped with strong deterministic verification mechanisms or low decision-confusion spaces, 0731 demonstrates significant practical value. Typical scenarios include large-scale mathematical formula and data labeling, deterministic code patching combined with Pytest or Linters, and long-document data extraction based on Pydantic Schemas. In these tasks, rigid evaluation rules intercept errors at every step, allowing 0731’s low unit price and 98% cache discount to translate into tangible cost advantages.
Synthesizing API list prices, generation verbosity, retry counts, and
defense-layer maintenance costs, successfully utilizing 0731 in
production requires establishing three key engineering defenses. First,
a Tool-calling repair layer must be deployed to automatically fix
escaped strings, null optional fields, and Markdown
autolink pollution. Second, chain-of-thought and output length caps must
be strictly configured in system prompts to suppress the extra Token
consumption caused by its maxed-out 4/4 Verbosity. Third, a hybrid
architecture with clear division of labor should be adopted, where a
frontier flagship model serves as Controller responsible for planning
and auditing, delegating high-volume granular sub-tasks to 0731. Through
this architectural arrangement, teams can maintain system determinism
while truly unlocking the economic value of low-unit-cost models.