On July 31, 2026, the Chinese AI lab released V4-Flash-0731—the public API beta of the finalized version. What makes this release remarkable isn’t new architecture. The Mixture-of-Experts design is unchanged: 284 billion total parameters, 13 billion activated per token, and a 1 million token context window identical to the preview version. The entire upgrade was post-training only—alignment, instruction-following, and agentic behavior layers that determine how well the model actually performs in real workflows.
The result is a model that costs roughly $0.28 per million output tokens—less than a rounding error on a GPT-5.6 invoice—yet scores 50 on the Artificial Analysis Intelligence Index, just one point behind GPT-5.6 Luna’s 51. On Terminal Bench 2.1, it posts 82.7, within striking distance of Claude Opus 4.8’s 85.0. And on DeepSWE, the software engineering benchmark that actually matters for agent workflows, it jumped from 7.3 to 54.4—a 6.4x improvement.
This review applies our 6-dimension evaluation framework to test whether the benchmark numbers translate to real-world value or whether the actual usage tells a different story.
Real-World Scenario Testing: Terminal Operations, Repo Modification, and Tool Calls
The most significant claim from the 0731 release is its agentic capability. Unlike chat benchmarks that test single-turn reasoning, agent benchmarks evaluate whether a model can autonomously execute multi-step workflows: open a terminal, navigate a codebase, modify files, run tests, and self-correct when things break.
On Terminal Bench 2.1, this model scores 82.7. For context, Claude Opus 4.8—the current gold standard for agentic coding—sits at 85.0. That’s a 2.3-point gap, but it’s the narrowest margin any sub-$1/M model has ever achieved on this benchmark. The previous preview version scored in the low 40s.
On DeepSWE, the improvement is even more dramatic: 54.4 versus the preview’s 7.3. DeepSWE measures end-to-end software engineering tasks—creating features, fixing bugs, refactoring code—within real repositories. A 6.4x jump from post-training alone suggests that the alignment team found a way to activate latent capabilities that were already present in the base model but poorly surfaced.
The Cybergym score of 76.7 and Toolathlon Verified at 70.3 further confirm that this isn’t a one-benchmark fluke. The model can chain tool calls together—reading documentation, executing commands, parsing output, and making decisions based on results—with reliability that approaches frontier-tier models.
However, real-world agent workflows reveal nuances that benchmarks don’t capture. When tasked with modifying a multi-file repository based on a natural language description, the model excels at mechanical changes—adding a function, updating imports, fixing a syntax error. Where it stumbles is in architectural decisions: choosing between competing design patterns, deciding where to place abstraction boundaries, or understanding implicit requirements that a human developer would infer from context.
The DSBench-FullStack score of 68.7 and DSBench-Hard at 59.6 reflect this split. Full-stack tasks that follow well-trodden patterns (CRUD apps, REST APIs, standard authentication flows) score well. Hard tasks that require novel architecture or cross-system reasoning lag behind.
The Frontend Code Arena results are particularly noteworthy: 1586 points, ranking 3rd in the open category and 7th overall. For a model at this price point to crack the top 10 in frontend code generation—beating models that cost 100x more—is a signal that frontend development may be the sweet spot for deployment.
Cost Per Task: API Pricing, Cache Discounts, and Head-to-Head Comparisons
This is where the model’s value proposition becomes undeniable. The API pricing structure is aggressive in a way that redefines the cost floor for production AI:
| Metric | DeepSeek V4-Flash | GPT-5.6 Luna | Claude Opus 4.8 |
|---|---|---|---|
| Input (per M tokens) | ¥1 (~$0.14) | ~$0.70* | ~$3.00 |
| Output (per M tokens) | ¥2 (~$0.28) | ~$2.10* | ~$15.00 |
| Cache Hit Input | ¥0.02 (~$0.003) | ~$0.35 | ~$0.30 |
| Cache Discount | 98% | ~50% | ~90% |
| Context Window | 1M tokens | 1M tokens | 1M tokens |
*GPT-5.6 Luna pricing reflects post-80% price reduction. Even after that cut, single-task cost remains ~60% higher than V4-Flash.
To understand the real-world impact, let’s break down three concrete scenarios using data from benchlm.ai:
Scenario 1 — Simple conversation (1K input + 500 output tokens):
Claude Opus 4.8: $0.0175
V4-Flash: $0.00028
Savings: 98.4%
Scenario 2 — Code repository review (50K input + 3K output tokens):
Claude Opus 4.8: $0.325
V4-Flash: $0.00784
Savings: 97.6%
Scenario 3 — Cache-intensive agent loop (200K cached + 20K new input + 10K output tokens):
Claude Opus 4.8: $1.35
V4-Flash: $0.00616
Savings: 99.5%
That third scenario is where the model’s value becomes transformative. Agent workflows are inherently cache-heavy: the system prompt, tool definitions, and conversation history get re-sent with every turn. With a 98% cache discount, the marginal cost of each additional agent step approaches zero. This makes it economically viable to run complex, multi-step agent loops—hundreds of tool calls, iterative refinement, parallel exploration—that would cost dollars per run on Claude.
The peak-valley pricing model deserves attention: during weekday high-demand hours (9-12 and 14-18 Beijing time), prices double. For developers in Western time zones, this means your overnight batch processing runs at the cheaper rate—another advantage for automated workflows.
For a broader comparison of how major AI models stack up in real benchmarks, check our ChatGPT vs Claude vs Gemini 2026 comparison.
Failure Modes: Where the Model Falls Short
Benchmark scores tell you what a model can do. Understanding what it can’t do is arguably more important for production deployment. Through testing and community reports, three distinct failure patterns emerge:
1. Complex Architecture Design
When asked to design a system architecture from scratch—choosing between microservices vs. monolith, event-driven vs. request-response, or determining appropriate service boundaries—the model tends to default to popular patterns without deep reasoning about trade-offs. It produces plausible-looking architecture documents that hold up under scrutiny but may not survive contact with production constraints. The NL2Repo score of 54.2 reflects this: converting natural language descriptions into well-structured repositories requires architectural judgment that post-training alone hasn’t fully unlocked.
2. Ambiguous Goal Multi-Step Planning
The model excels when instructions are explicit: “Add a pagination component to the user list page.” It struggles when goals are fuzzy: “Make the dashboard more user-friendly.” In agent workflows, this manifests as the model making reasonable first steps but then going down a path that doesn’t align with the user’s actual intent. The Agent Last Exam score of 25.2—while a significant improvement over the preview’s 15.8—still trails Claude Opus 4.8’s 25.7, and both scores are low in absolute terms. This benchmark specifically tests nuanced, ambiguous scenarios where the “right” answer requires interpretation.
3. Long-Task Self-Correction
In multi-hour agent runs (50+ tool calls), the model sometimes fails to recognize when it’s going down a wrong path. Unlike Claude, which tends to pause and reassess when encountering unexpected results, this model often pushes forward with increasing confidence—generating more code, making more changes—rather than stepping back to question its approach. The Automation Bench Public score of 25.1 confirms this weakness in extended automation scenarios.
Additionally, when following fine-grained instruction documents—detailed style guides, strict output format specifications, or multi-page prompt templates—the model is less stable than Kimi K3 and Luna. It may skip steps, paraphrase instructions rather than following them literally, or apply formatting inconsistently across a long output. For our detailed analysis of Kimi K3’s instruction-following capabilities, see our dedicated review.
Audience Recommendation Matrix
Not every model fits every user. Here’s how V4-Flash maps to different user segments:
| User Group | Fit Score | Best Use Case | Watch Out For |
|---|---|---|---|
| Indie Developers | ★★★★★ | Daily code fixes, API integration, debugging | Architecture decisions may need human review |
| Startup Teams | ★★★★☆ | MVP development, batch data cleaning, CI/CD automation | Peak-hour pricing doubles during business hours |
| Enterprise Teams | ★★★☆☆ | High-concurrency agent infrastructure, automated workflows | Text-only input; no multimodal; V4-Pro unchanged |
| Students & Learners | ★★★★★ | Frontend projects, homework help, code learning | May over-rely on it for deep CS concepts |
For indie developers, this is arguably the best value-to-capability ratio available. At $0.28/M output tokens, you can run hundreds of agent iterations for the cost of a single Claude API call. The MIT license and open weights mean you can self-host for even lower costs, though that requires significant GPU resources (284B total parameters).
Startup teams benefit most from the cache discount. In a typical CI/CD pipeline where the same system prompt and tool definitions are reused across runs, the 98% cache discount makes batch processing economically trivial. A daily code review pipeline that processes 10 repositories would cost roughly $0.08 per run—less than a cent per repo.
Enterprise teams face more friction. The text-only input limitation means no multimodal workflows (screenshot analysis, diagram interpretation, UI testing). The peak-valley pricing complicates cost forecasting. And the fact that V4-Pro API and the consumer-facing website/app models were not updated means teams using the Pro tier or chat interface are stuck with the older version. For coding tool comparisons, our Cursor vs Copilot vs Claude Code analysis provides additional context on which tools integrate best with which models.
Students get the most outsized value. The model’s frontend coding capability (3rd in Frontend Code Arena’s open category) makes it an excellent learning companion for web development projects. The low cost means students can experiment freely without worrying about API bills.
Hidden Limitations You Need to Know
Beyond the headline benchmarks and pricing, several constraints affect real-world deployment decisions:
Peak-Valley Pricing
The pricing table shows the base rate, but during weekday peak hours (9:00-12:00 and 14:00-18:00 Beijing time), prices double. If your team operates in Asian business hours, your effective cost is 2x the advertised rate. Western users running overnight batch jobs benefit from valley pricing, but real-time agent workflows during Asian hours take a significant cost hit. This detail is buried in the pricing documentation and catches many new users off guard.
Only V4-Flash Updated; V4-Pro Unchanged
The 0731 release is exclusively a Flash update. The V4-Pro API and the models powering the consumer website and mobile app were not updated. If you’ve been using V4-Pro for production workloads, switching to Flash means accepting a different model with different characteristics—not simply a cheaper version of the same thing. V4-Pro scores 44 on the Intelligence Index (versus Flash’s 50), suggesting the post-training improvements in Flash actually surpass the Pro variant’s performance—a counterintuitive result that raises questions about why Pro wasn’t also updated.
Text-Only Input (No Image Support)
V4-Flash accepts text only. No images, no PDFs, no screenshots. For agent workflows that involve visual debugging (analyzing UI screenshots, reading diagrams, interpreting charts), this is a hard blocker. Claude, GPT-5.6, and Gemini all support multimodal input. If your workflow requires visual understanding, you’ll need a separate model for those steps—or wait for a future update.
Responses API Only on V4-Flash
The OpenAI-compatible Responses API format—which enables stateful conversations, built-in tool use, and Codex adapter support—is only available on V4-Flash. V4-Pro users are limited to the Chat Completions API. This means if you want to use this model with Codex, agentic frameworks that expect the Responses API format, or any tool that specifically targets the newer OpenAI API surface, you must use Flash. It also means the more capable-sounding “Pro” variant is actually less compatible with the modern agentic ecosystem.
Speed Benchmarks: V4-Flash + Hermes vs GPT-5.6 Sol + Codex
Speed in agent workflows isn’t just about latency—it’s about total task completion time, which includes reasoning, tool calls, file operations, and self-correction loops. Developer testing reveals a significant advantage:
V4-Flash + Hermes: ~40 seconds
GPT-5.6 Sol + Codex: ~1 minute 47 seconds (107 seconds)
That’s a 2.7x speed advantage for the same task completion. For batch processing—where you’re running hundreds or thousands of agent tasks—this compounds dramatically. A pipeline of 100 tasks would take roughly 67 minutes with V4-Flash versus 178 minutes with GPT-5.6 Sol.
The speed advantage comes from two sources. First, the smaller active parameter count (13B activated per token vs. larger dense models) means faster inference per token. Second, the Hermes orchestration layer appears to be more efficient at managing tool-call overhead—spending less time on API round-trips and context re-processing.
However, speed without quality is meaningless. The question is whether the 40-second result matches the 107-second result in correctness. Based on Terminal Bench 2.1 scores (82.7 vs. GPT-5.6’s higher but not dramatically different scores), the answer is: close enough for most tasks, with the gap widening on complex multi-step reasoning. For routine agent operations—file modifications, test runs, API integration—the faster model is the better choice. For architectural design or complex debugging, the extra time may be worth it.
| Benchmark | V4-Flash (0731) | V4-Flash (Preview) | GPT-5.6 Luna | Claude Opus 4.8 |
|---|---|---|---|---|
| Intelligence Index | 50 | 40 | 51 | — |
| Terminal Bench 2.1 | 82.7 | — | — | 85.0 |
| DeepSWE | 54.4 | 7.3 | — | — |
| Agent Last Exam | 25.2 | 15.8 | — | 25.7 |
| Cybergym | 76.7 | — | — | — |
| Toolathlon Verified | 70.3 | — | — | — |
| DSBench-FullStack | 68.7 | — | — | — |
| DSBench-Hard | 59.6 | — | — | — |
| NL2Repo | 54.2 | — | — | — |
| Frontend Code Arena | 1586 (#3 open) | — | — | — |
| Automation Bench Public | 25.1 | — | — | — |
The Bigger Picture: Industry Signals
Beyond the technical specs, two industry signals suggest this release matters beyond benchmark scores. Elon Musk followed the official X account after the 0731 release announcement—a post that garnered 25,000 likes and 5,000 retweets. While a follow doesn’t equal endorsement, it signals that this trajectory is on the radar of the person building the world’s largest AI compute cluster.
More concretely, Tesla’s China vehicle infotainment systems now use these models. This is a production deployment at scale—millions of cars running inference on a model from a Chinese AI lab. For a model that costs $0.28/M output tokens, being chosen over GPT or Claude for a cost-sensitive, high-volume automotive application validates the economic thesis.
The open-source community response has been equally notable. The MIT license and open weights mean researchers can inspect, fine-tune, and deploy without licensing friction. Independent benchmarks from CSDN’s coding cross-evaluation placed the V4-Pro-Max variant at 9.56/10 overall—narrowly behind Claude Opus 4.6-Max’s 9.69 but ahead of GPT-5.4-xHigh’s 8.78. At ¥24/M output tokens versus Claude’s ~¥183/M and GPT’s ~¥220/M, the value gap is enormous.
FAQ
What is V4-Flash-0731?
It’s the finalized public API beta of the Flash variant, released July 31, 2026. The architecture is unchanged from the preview version (MoE, 284B total, 13B active, 1M context)—all improvements come from post-training alignment and instruction tuning.
How does it compare to GPT-5.6 Luna?
On the Artificial Analysis Intelligence Index, V4-Flash scores 50 vs. Luna’s 51—essentially tied. On cost, V4-Flash is roughly 60% cheaper per task even after GPT-5.6’s 80% price reduction. On speed, developer tests show ~40 seconds vs. ~107 seconds for the same agent task.
Can V4-Flash handle image inputs?
No. The model accepts text input only. There is no image, PDF, or screenshot support. This is a significant limitation for multimodal workflows.
Was V4-Pro also updated?
No. Only the Flash variant received the 0731 post-training update. V4-Pro API and the models on the website and mobile app remain unchanged. Notably, the Responses API format is only available on Flash, not Pro.
What’s the cache discount and why does it matter?
Cached input tokens cost ¥0.02/M (about $0.003/M)—a 98% discount. For agent workflows that resend the same system prompt and tool definitions with every call, this makes the marginal cost of additional agent steps nearly zero.
Is the model open source?
Yes. It’s released under the MIT license with open weights. You can self-host, but running a 284B parameter MoE model requires substantial GPU infrastructure.
What are the peak pricing hours?
Weekday high-demand periods: 9:00-12:00 and 14:00-18:00 Beijing time. During these hours, prices double. Plan batch jobs outside these windows for maximum cost savings.
Final Verdict
The 0731 release represents a pivotal moment in the AI model market. By achieving near-frontier performance through post-training alone—without architectural changes or parameter increases—it demonstrates that alignment and instruction-following improvements can unlock latent capabilities at a fraction of the training cost.
For agent workflows, the combination of 82.7 on Terminal Bench 2.1, 54.4 on DeepSWE, and $0.28/M output pricing creates a value proposition that no other model currently matches. The 98% cache discount makes complex, multi-step agent loops economically viable in a way that simply wasn’t possible before.
The limitations are real—text-only input, peak-hour pricing, no V4-Pro update, and gaps in complex architecture reasoning. But for the majority of agent use cases—daily coding, batch processing, frontend development, automated workflows—these limitations are manageable workarounds, not dealbreakers.
If you’re building agent infrastructure and haven’t evaluated this model yet, the cost-to-capability ratio makes it essential to test. The worst case: you find it doesn’t fit your workflow and switch back. The best case: you cut your API costs by 95%+ with minimal quality loss.
\n\n\n