DeepSeek V4 Flash: 89% on ARC-AGI-1 and 61.4% on ARC-AGI-2 for $0.04

⏱️ Lectura: 11 min

DeepSeek V4 Flash 0731 scores 89.0% on ARC-AGI-1 and 61.4% on ARC-AGI-2, two of the abstract reasoning benchmarks most resistant to language models, according to results published by ARC Prize Foundation on July 31, 2026.

📑 En este artículo

1. TL;DR
2. Introduction
3. What happened: DeepSeek V4 Flash enters the ARC-AGI leaderboard
4. Context and history
5. DeepSeek V4 Flash technical details and performance
   1. How reasoning effort is distributed per task
6. How to try it: run DeepSeek V4 Flash against your own tasks
   1. Linux / macOS (curl)
   2. Windows (PowerShell)
7. Impact and analysis
8. What’s next
9. Frequently Asked Questions
   1. What is ARC-AGI and how does it differ from other LLM benchmarks?
   2. What does it mean for results to be “Semi-Private”?
   3. What’s the real difference between the Max, High, and Low variants?
   4. Why is ARC-AGI-2 so much harder than ARC-AGI-1?
   5. Does DeepSeek V4 Flash 0731 already have a score on ARC-AGI-3?
   6. Did DeepSeek report these numbers, or an independent third party?
10. References

What sets this result apart isn’t just the score: it’s the cost. The highest reasoning-effort variant reaches those figures for $0.02 and $0.04 per task respectively, a price that places DeepSeek V4 Flash among the most affordable models to surpass 60% on ARC-AGI-2.

TL;DR

• DeepSeek V4 Flash 0731, in its Max variant, scores 89.0% on ARC-AGI-1 Semi-Private at $0.02 per task.
• The same Max variant reaches 61.4% on ARC-AGI-2 Semi-Private at $0.04 per task, its best published mark.
• ARC Prize evaluated three reasoning variants: Max, High, and Low, each with a different cost-to-accuracy balance.
• The High variant scores 87.0% on ARC-AGI-1 and 56.0% on ARC-AGI-2, one tier below Max.
• The Low variant, the cheapest, reaches 84.0% on ARC-AGI-1 and 46.0% on ARC-AGI-2.
• The results were independently verified by the ARC Prize Foundation and published on July 31, 2026.
• The gap between ARC-AGI-1 and ARC-AGI-2 is around 27.6 percentage points for the Max variant, evidence that the second benchmark remains unsaturated.

Introduction

ARC-AGI isn’t just another trivia or coding benchmark: it measures whether a system can solve abstract reasoning problems it never saw during training. Each task presents a grid of colors as an input-output example, and the model has to infer the transformation rule and apply it to a new case. No pattern memorized from the internet works here: the task demands real generalization.

The original benchmark, ARC-AGI-1, has for years been a hard ceiling for LLMs without external tools. ARC-AGI-2, its successor, deliberately raised the difficulty: it incorporates tasks that require combining several rules at once and discards the patterns that large models had learned to exploit in the first version. That a model reaches 61.4% on ARC-AGI-2 without benchmark-specific tuning is, in that context, a meaningful mark.

What happened: DeepSeek V4 Flash enters the ARC-AGI leaderboard

On July 31, 2026, the ARC Prize Foundation published the verified results page for DeepSeek V4 Flash 0731. ARC Prize’s verification process runs the model against the benchmark’s semi-private evaluation set, which isn’t publicly exposed to prevent training data contamination: no one can memorize answers from a set they can’t see.

DeepSeek submitted three reasoning variants for evaluation: Low, High, and Max. It’s the same pattern used by other labs with extended reasoning models: the user chooses how much compute to invest per response, and that decision directly affects the cost per task. On Max, DeepSeek V4 Flash 0731 scored 89.0% on ARC-AGI-1 Semi-Private and 61.4% on ARC-AGI-2 Semi-Private.

The cost detail is what’s driving this news among developers: ARC Prize reports $0.02 per task for the ARC-AGI-1 result and $0.04 per task for the ARC-AGI-2 result, both on the Max variant. These are low figures compared to what the most expensive extended reasoning models on the market typically charge to solve the same type of task.

Context and history

ARC-AGI was created in 2019 by François Chollet, creator of Keras, as a way to measure something different from memorization: a system’s ability to acquire new skills when facing problems it hadn’t seen before. For years, language models stagnated far below human performance on this benchmark, even as they had already mastered coding, math, and text comprehension tasks.

The ARC-AGI-2 family arrived to restore that difficulty. The first models to surpass 80% on ARC-AGI-1 did so, in part, by exploiting regularities in the task set itself; ARC-AGI-2 removed that margin. That the Max variant of DeepSeek V4 Flash 0731 reaches 61.4% there, against the 89.0% it achieves on ARC-AGI-1, confirms that the second benchmark still isn’t solved: the 27.6 percentage point gap between the two is, today, the norm for any frontier model, not the exception.

DeepSeek V4 Flash 0731 is the lightweight, cost-oriented variant of DeepSeek’s V4 family, designed to run with lower latency and lower price per token than the model’s full versions. That positioning (cutting cost without a proportional cut in reasoning capability) is the same strategy already seen from other open-weight labs competing directly on price against closed competitors.

DeepSeek V4 Flash technical details and performance

The table below summarizes the three variants evaluated by ARC Prize, with the scores and costs the foundation actually published. Where ARC Prize didn’t publish a figure, the table explicitly notes it rather than estimating it.

Variant	ARC-AGI-1 (Semi-Private)	ARC-AGI-2 (Semi-Private)	Cost per task	When to use it
Max	89.0%	61.4%	$0.02 / $0.04	Maximum accuracy, limited evaluation budget
High	87.0%	56.0%	Not published by ARC Prize	Balance between cost and accuracy
Low	84.0%	46.0%	Not published by ARC Prize	Large task batches where cost drives the decision

The pattern is consistent: each jump from Low to High and from High to Max costs more compute in exchange for a 2.0 to 10.0 percentage point improvement, depending on the tier and benchmark. The improvement is sharper on ARC-AGI-2 (from 46.0% on Low to 61.4% on Max, 15.4 points) than on ARC-AGI-1 (from 84.0% to 89.0%, 5.0 points), which suggests the benchmark’s hardest tasks do benefit from more reasoning steps, while even the budget variant already solves the simplest ones.

How reasoning effort is distributed per task

flowchart TD
    A["ARC-AGI Task"] --> B["DeepSeek V4 Flash 0731"]
    B --> C{"Chosen variant"}
    C --> D["Low: 84.0% / 46.0%"]
    C --> E["High: 87.0% / 56.0%"]
    C --> F["Max: 89.0% / 61.4%"]
    D --> G["ARC Prize semi-private evaluation"]
    E --> G
    F --> G
    G --> H[("Verified result")]

💭 Key takeaway: The improvement from Low to Max is a bit more than 3 times larger on ARC-AGI-2 (15.4 points) than on ARC-AGI-1 (5.0 points): more reasoning compute pays off more when the problem is genuinely harder, not when it’s already solved.

How to try it: run DeepSeek V4 Flash against your own tasks

DeepSeek exposes V4 Flash through an API compatible with the OpenAI format, which means any SDK you already use for another provider works here too, just by changing the base URL and the model name. The minimum needed to make a call is this:

Linux / macOS (curl)

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -d '{
    "model": "deepseek-v4-flash",
    "reasoning_effort": "max",
    "messages": [
      {"role": "user", "content": "Solve this abstract reasoning task: describe the transformation pattern between the input grid and the output grid."}
    ]
  }'

Windows (PowerShell)

curl.exe https://api.deepseek.com/chat/completions `
  -H "Content-Type: application/json" `
  -H "Authorization: Bearer $env:DEEPSEEK_API_KEY" `
  -d '{\"model\": \"deepseek-v4-flash\", \"reasoning_effort\": \"max\", \"messages\": [{\"role\": \"user\", \"content\": \"Solve this abstract reasoning task.\"}]}'

This call sends a task to the model requesting maximum reasoning effort. The response comes back in the same chat.completions format returned by other OpenAI-compatible providers, so there’s nothing new to parse. A more realistic example, integrating the Python SDK into an ARC-AGI-style evaluation flow:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_DEEPSEEK_API_KEY",
    base_url="https://api.deepseek.com"
)

respuesta = client.chat.completions.create(
    model="deepseek-v4-flash",
    reasoning_effort="high",  # low | high | max
    messages=[
        {"role": "system", "content": "You are an ARC-AGI puzzle solver. Return only the output grid."},
        {"role": "user", "content": grid_prompt}
    ]
)

print(respuesta.choices[0].message.content)
print(respuesta.usage)  # confirms tokens consumed and, if the provider exposes it, the effort level used

The reasoning_effort field is what selects the variant (low, high, or max); always check the official API documentation before deploying to production, since exact parameter names can change between model versions. To confirm which variant actually processed your request, inspect the response’s usage object: that’s where most OpenAI-format-compatible APIs expose the reasoning token count consumed, which varies by variant used.

⚠️ Heads up: The cost per task published by ARC Prize ($0.02 and $0.04) corresponds to the specific conditions of their evaluation, with prompts and retries defined by their own evaluation process. Your actual production cost will depend on your prompt length, the number of retries you configure, and your application’s traffic.

Impact and analysis

The result matters for two reasons that don’t always go together: score and price. Closed frontier models have spent months reporting high scores on ARC-AGI-2, but almost always at a noticeably higher cost per task. That an open-weight, cost-oriented model like V4 Flash reaches 61.4% changes the calculation for any team that wants to run reasoning evaluations at scale, or build products where the model has to generalize against inputs it never saw during training.

There’s also a clear limit worth not ignoring: 61.4% on ARC-AGI-2 is still far from 100%, and quite far from average human performance on the same task set. ARC-AGI-2 was designed precisely to avoid saturating with the first generation of models that attempted it, and for now it meets that goal: no model, DeepSeek included, solves most of the set’s hardest tasks.

The other point is methodological: ARC Prize runs verification independently on a semi-private set, it doesn’t simply accept the number reported by the lab that trained the model. That matters at a time when more and more AI benchmarks are being questioned over possible data contamination or test-specific optimization. That layer of external verification is what gives real weight to the comparison between DeepSeek V4 Flash and the rest of the leaderboard.

What’s next

The DeepSeek V4 Flash 0731 results page still doesn’t show a score on ARC-AGI-3: the column appears empty in the verified variants table. ARC Prize has been developing that third generation of the benchmark with a focus on interactive tasks, a different kind of difficulty jump than the one that separated ARC-AGI-1 from ARC-AGI-2.

In the short term, the rest of the labs competing on price are expected to submit their own models to the same ARC Prize semi-private evaluation. The leaderboard updates as each lab publishes a new variant, so the August 2026 ranking could look different within a few weeks.

📖 Summary on Telegram: View summary

Try it yourself: open the ARC Prize results page and review the task-by-task breakdown of the 400 public ARC-AGI-1 tasks and the 120 ARC-AGI-2 tasks before deciding whether Max, High, or Low fits your use case.

Frequently Asked Questions

What is ARC-AGI and how does it differ from other LLM benchmarks?

ARC-AGI measures abstract reasoning with color grid tasks the model has never seen before, rather than evaluating memorized knowledge or code. François Chollet created it in 2019 to measure real generalization, not recall of training patterns.

What does it mean for results to be “Semi-Private”?

The semi-private task set isn’t publicly exposed, so no model could have seen it during training. It’s the evaluation layer ARC Prize uses to independently verify the score each lab reports.

What’s the real difference between the Max, High, and Low variants?

All three run the same model, DeepSeek V4 Flash 0731, at a different level of reasoning effort per task. Max invests more compute and costs more per task in exchange for higher accuracy: 89.0% on ARC-AGI-1 and 61.4% on ARC-AGI-2, versus 84.0% and 46.0% for Low.

Why is ARC-AGI-2 so much harder than ARC-AGI-1?

ARC-AGI-2 eliminates the regularities that large models had learned to exploit in the first version of the benchmark and adds tasks that require combining several rules at once. The 27.6-point gap DeepSeek V4 Flash shows between the two benchmarks is representative of what happens with any frontier model today.

Does DeepSeek V4 Flash 0731 already have a score on ARC-AGI-3?

No. The ARC Prize results page shows an empty ARC-AGI-3 column for this model as of publication, on July 31, 2026.

Did DeepSeek report these numbers, or an independent third party?

The ARC Prize Foundation, the nonprofit that maintains the benchmark, verified them by running the model against its own semi-private evaluation set rather than simply accepting the number reported by the lab.

References

• Official DeepSeek V4 Flash 0731 results page: verified scores by variant and task-by-task breakdown on ARC-AGI-1 and ARC-AGI-2.
• ARC Prize Foundation: the organization that maintains the ARC-AGI benchmark and publishes the independently verified leaderboard.
• Official DeepSeek API documentation: reference for endpoints, authentication, and model parameters.
• Official DeepSeek GitHub repository: code, papers, and releases published by the DeepSeek team.

📱 Enjoying this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.

Imagen destacada: Foto de Logan Voss en Unsplash