DeepSeek V4 Flash 0731 Scores 89% on ARC-AGI at $0.02/Task

ARC Prize's independently verified numbers, not a vendor tweet, are what make this release worth a second look. DeepSeek's V4 Flash 0731 — the same July 31, 2026 release explainx.ai covered for its Codex and Responses API support — now has a third-party benchmark on one of the harder reasoning tests in the field: ARC-AGI, the Abstraction and Reasoning Corpus that explainx.ai has tracked since Opus 5's ARC-AGI-3 leaderboard jump.

At max reasoning effort, ARC Prize measured V4 Flash 0731 at 89.0% on ARC-AGI-1 for about $0.02 per task, and 61.4% on ARC-AGI-2 for about $0.04 per task. Those numbers alone don't mean much without a reference point — so here's the reference point: on ARC Prize's own cost-vs-score chart, several Hacker News commenters pointed out that V4 Flash 0731 at max effort actually beats Kimi K3 at max effort on this benchmark, despite costing a small fraction as much per task, and lands roughly where GPT-5.6 Luna does at a fraction of Luna's cost.

TL;DR — Reasoning Effort vs Cost vs Score

Cost figures are ARC Prize's per-task numbers at each effort tier; Low/High exact costs weren't separately published alongside the score, so treat those two cells as directional against the confirmed Max figures. Source: arcprize.org.

What ARC Prize Actually Verified

ARC-AGI matters here specifically because it resists brute-force memorization — each task is a small, novel visual reasoning puzzle designed so that pattern-matching on training data doesn't generalize to the next one. explainx.ai's complete guide to AI benchmarks covers why ARC-AGI-2 in particular pushed top scores down into single digits for most models when it launched, before frontier reasoning models started clearing it with heavy compute.

ARC Prize ran DeepSeek V4 Flash 0731 across three reasoning-effort tiers — Low, High, and Max — against both the original ARC-AGI-1 and the harder ARC-AGI-2 semi-private evaluation sets, and published per-task cost alongside each score. That's the detail that makes this data useful rather than just impressive: cost-per-task on a log-scale x-axis against score on the y-axis is exactly the chart shape ARC Prize uses to compare models that differ by orders of magnitude in price, and it's why a $0.02-per-task model beating a far pricier one on raw score is a genuinely notable data point rather than a rounding error.

The effort-tier pattern is worth internalizing on its own: going from Low to Max effort added roughly 5 points on ARC-AGI-1 (84.0% → 89.0%) but over 15 points on ARC-AGI-2 (46.0% → 61.4%). Harder tasks reward more reasoning budget disproportionately — a pattern that should inform how you set effort levels per workload rather than defaulting to one tier everywhere.

Why It's This Cheap: 300B Total, ~13B Active

DeepSeek V4 Flash is a mixture-of-experts (MoE) model with roughly 300B total parameters but only about 13B active per forward pass. Total parameter count determines how much the model knows; active parameter count determines how much compute each token actually costs to generate. That gap is the entire economic story behind the ARC-AGI cost numbers above.

In practice, that shows up as real throughput on real hardware: community reports put V4 Flash 0731 at roughly 8,000 tokens/sec prefill and 250 tokens/sec single-stream decode on two RTX Pro 6000 Blackwell GPUs — fast enough that the small active-parameter footprint keeps it cheap to run even on expensive accelerators, and cheap enough over an API that providers can price it near the floor. explainx.ai's DeepSeek DSpark V4 speculative decoding guide covers the complementary technique — speculative decoding — that squeezes more throughput out of the same active-parameter budget.

Running It Locally — Real Open Weights, Not Just a Cheap API

The distinction matters: V4 Flash 0731 is genuinely open-weight, not merely open-API. Developers are already running it at home across a range of hardware tiers:

• 2x RTX Pro 6000 Blackwell — the fast path, ~8k tok/s prefill / 250 tok/s decode reported above.
• 256GB DRAM, CPU-only — works, but noticeably slower without GPU acceleration.
• 2-bit quantized on a 128GB "Strix Halo" mini PC — around 15 tokens/sec, usable for light agentic work despite the aggressive quantization.

That range is the practical argument for open weights: a $0.02 ARC-AGI-1 task on someone else's API and a slow-but-functional 15 tok/s local run on a mini PC are two ends of the same cost curve, and you pick a point on it based on your own latency tolerance and hardware budget. explainx.ai's guide to running open-source models locally in OpenCode and the llama.cpp primer both cover the setup mechanics for exactly this kind of local deployment.

The Pricing Layer: Cache Reads Are the Real Story

On raw input/output pricing, V4 Flash 0731 is already cheap across providers — OpenRouter and BaseTen list rates around $0.14 per million input tokens and $0.28 per million output tokens, in line with what explainx.ai reported at launch. But the number that actually changes agentic coding economics is cache-read pricing on DeepSeek's own direct API: roughly $0.0028 per million tokens — about 10x cheaper than competing providers' cache reads, which commonly run $0.028 or higher.

That gap matters enormously for agentic coding, where a harness re-sends most of the same context (system prompt, file tree, prior turns) on every single tool call. Cache-hit rates of 90%+ are routine in these loops, which means the cache-read rate, not the headline input rate, is the number that determines your real bill.

One developer's posted usage from a real coding session illustrates the magnitude:

Over a billion tokens of context reuse for under nine dollars is the concrete shape of "too cheap to meter" — a phrase that used to be aspirational marketing copy and is now closer to a literal description of one specific line item in an agent's API bill, at least until pricing changes.

The Price-Increase Catch

That last caveat isn't hypothetical. DeepSeek separately warned users of a "significant" upcoming price increase on its direct API, without giving exact numbers or a date — the notice that sparked debate over whether today's rates are subsidized or simply reflect genuinely low serving costs at 13B active parameters.

The open-weight structure blunts the risk, though it doesn't eliminate it. Because DeepSeek publishes the weights rather than gating them behind a proprietary API, OpenRouter, BaseTen, and other providers can keep serving V4 Flash 0731 at their own prices regardless of what DeepSeek itself charges on its direct endpoint. A price hike on DeepSeek's own API is a DeepSeek pricing decision, not a hard ceiling on what the model costs to access — the same dynamic explainx.ai flagged after DeepSeek Flash hit 8 trillion tokens in a single day on OpenCode's free and paid tiers.

What Developers Are Actually Doing With It

Hacker News discussion around the ARC-AGI numbers converged on a consistent pattern: use DeepSeek V4 Flash as a cheap daily driver for the bulk of agentic coding, and escalate to a frontier model only when a task genuinely needs it.

Common setups developers on Hacker News described:

• Harness support — running it through OpenCode, through Pi/omp.sh's dual-model "advisor" pattern (one instance implements, a second reviews), and through Codex-compatible endpoints, since V4 Flash 0731 supports OpenAI's /v1/responses API.
• Workload split — DeepSeek Flash handles CI fixes, test generation, log/monitoring analysis, and security audits; genuinely hard problems get escalated to Claude Fable 5/Opus 5 or GPT-5.6 Sol.
• The advisor pattern specifically exists because a single cheap model reviewing its own work misses the same classes of bugs it introduces — a second instance, even the same model, catches a meaningful share of them at negligible added cost given how cheap each pass is.

The honest caveats matter just as much as the enthusiasm:

• Some developers reported degraded agentic and tool-calling performance compared to the earlier "preview" build, despite the ARC-AGI numbers looking strong on paper.
• The final 0731 release is reportedly around 2.5x slower than the preview version in at least one user's testing — a real regression even though the model is, by most accounts, better.
• Several noted it can lose track of context or topic during long sessions, requiring more careful, explicit prompting than they'd need with a frontier model to keep a long agent loop on-track.

None of that erases the cost advantage — it just means "cheap daily driver, escalate for hard problems" is a description of a real workflow constraint, not just a budget-conscious slogan.

The Efficiency Frontier Is Moving Faster Than the Intelligence Frontier

The useful way to read this release isn't "DeepSeek beat Kimi K3" — it's that the cost-per-quality curve is advancing faster than peak quality itself. Peak intelligence on ARC-AGI-2 still belongs to the most expensive frontier reasoning runs. What moved this month is how cheaply a model can get close to that peak — 61.4% for four cents a task is not the ceiling, but it's a dramatically better price-to-capability point than existed even a few weeks earlier.

That's the same tension explainx.ai's coverage of Calacanis vs. Musk on the open-frontier gap landed on: whether "open models are basically caught up" is true depends entirely on which axis you're measuring — peak capability, or capability per dollar. On the peak-capability axis, frontier closed models still lead. On the efficiency axis, releases like V4 Flash 0731 and Castform + Neon's 4B model matching GPT-5.6 Sol at 1/100th the cost show that gap closing fast, task by task.

For anyone actually managing an agentic coding budget, the efficiency frontier is the axis that determines your bill. The intelligence frontier determines what's theoretically possible. Most agentic coding work — CI fixes, test generation, routine refactors — doesn't need the theoretical ceiling; it needs a model that's good enough, verified against a real benchmark, and cheap enough to run at the volume agent loops actually generate.

Bottom Line

DeepSeek V4 Flash 0731's ARC-AGI numbers are the first independently verified data point confirming what its pricing already implied: a ~300B-parameter, ~13B-active MoE model can compete with far more expensive frontier releases on a genuinely hard reasoning benchmark, at cost-per-task low enough to round to noise in most budgets. The catch is durability — DeepSeek's own API pricing may not stay this low, agentic tool-calling took a step back from the preview build, and long-session context tracking still needs careful prompting. None of that changes the concrete demonstration this release provides: cheap, real open weights, verified by a third party, running on hardware from data-center GPUs down to a 128GB mini PC.

Related Reading

• DeepSeek-V4-Flash-0731: Codex Support, $0.14/$0.28 Pricing
• DeepSeek Flash Hit 8T Tokens in a Day — OpenCode's Measurement
• DeepSeek Warns of a "Significant" API Price Increase
• Opus 5 Hits 30.2% on ARC-AGI-3 — What the Jump Means
• AI Benchmarks in 2026: The Complete Guide
• Calacanis vs. Musk: Is the Open–Frontier Gap Already Negligible?
• Castform + Neon: A 4B Open Model Matches GPT-5.6 Sol at 1/100th the Cost
• Run Open-Source Models Locally in OpenCode

Sources: ARC Prize verified benchmark results for DeepSeek V4 Flash 0731, DeepSeek API pricing documentation, OpenRouter and BaseTen provider listings, Hacker News discussion. ARC-AGI scores, cost-per-task figures, and pricing are accurate as of the August 8, 2026 publication date — verify current rates and leaderboard standings at arcprize.org and platform.deepseek.com before making production decisions.