Claude Opus 5 Scored 30.16% on ARC-AGI-3. The Same Model, Unchanged, Scored 100.00%.

What ARC-AGI-3 is actually built to resist

Most AI benchmarks measure recall dressed up as reasoning: a model has plausibly seen something adjacent to the question in its training data, and scoring well is partly a memorization problem. ARC Prize built ARC-AGI-3 to close that loophole specifically for agents. Instead of a static question, it drops an agent into one of 25 public interactive environments, effectively small, rule-based games, with no instructions and no prior exposure, and scores whether the agent can explore, build a working model of the environment's hidden rules, and clear every level. There are 183 levels across those 25 environments. You can't memorize your way to a good score, because the rules are new every time.

That design is exactly why ARC Prize's own leaderboard is the right place to start: Claude Opus 5 on high reasoning effort, running solo with no external scaffolding, posts 30.16% on ARC-AGI-3 as of July 24, 2026, per ARC Prize's published results page. That's the best score of any frontier model tested solo on this benchmark. Best in class, alone, is still under a third.

The number NVIDIA published five weeks later

On August 21, 2026, NVIDIA's developer blog published a result from a system called AVO, short for Agentic Variation Operators. AVO is powered by the same Claude Opus 5, unmodified, and it cleared every one of the 183 levels across all 25 public ARC-AGI-3 environments, for a perfect 100.00 RHAE score (ARC Prize's efficiency-weighted completion metric). Independent coverage from The New Stack confirms the same figures against NVIDIA's own post.

Read that gap carefully: it isn't Opus 5 versus a newer, bigger model. It's Opus 5 versus Opus 5, with nothing changed inside the model, tested on the exact same benchmark five weeks apart. Whatever moved that number by 69.84 points, it wasn't parameter count, and it wasn't new training.

It wasn't brute force either

The obvious skeptical read is that AVO just burned more compute retrying every level until something worked. NVIDIA's own numbers rule that out directly. The prior leaderboard leader, a system called VISTA, needed 7,542 total environment actions to clear its share of the benchmark. AVO finished with 6,624actions, 12% fewer, while covering strictly more of the benchmark than VISTA did. That's not “try everything until it sticks.” It's doing more, with less motion, per level.

The 3 pieces that did the work

NVIDIA's post describes AVO's architecture as three components wrapped around the same underlying model, none of which touch a single weight:

You can write the shape of that loop in about 15 lines, and it's worth doing so because the honest version has no model call that looks any different from a normal agent step. The lift is entirely in what wraps around it:

# avo_style_loop.py — the shape of a memory + supervision + agent loop
# (illustrative structure, not NVIDIA's actual implementation)

memory = []          # persists across the whole run, not just one attempt
stagnation_count = 0
best_score = 0

for attempt in range(MAX_ATTEMPTS):
    state = environment.inspect()
    plan = model.plan(state, memory)          # same model, same weights every call
    result = environment.implement(plan)
    score = environment.evaluate(result)

    memory.append({"plan": plan, "result": result, "score": score})

    if score <= best_score:
        stagnation_count += 1
    else:
        stagnation_count = 0
        best_score = score

    if stagnation_count >= STAGNATION_LIMIT:
        plan = model.plan(state, memory, force_new_strategy=True)  # supervision loop kicks in
        stagnation_count = 0

    if environment.solved():
        break

Nothing in that loop makes the model smarter. It makes the same model's mistakes visible to its next attempt, and it forces a pivot before the agent burns its whole budget repeating one failed idea. That's the entire mechanism behind a 30-to-100 jump on paper: remove the amnesia between attempts, and add a circuit breaker for dead ends.

The catch neither headline led with

Here's the number that didn't make it into most of the coverage: AVO's 100.00 RHAE is a score on the 25-environment public set, the same environments any team can download and iterate against directly. ARC Prize's competition structure also includes semi-private and private held-out sets, environments no outside team gets to see or practice on, and those are the sets that actually decide standing in the ARC Prize competition itself. NVIDIA's own post is explicit that this result does not cover those held-out sets.

That's not a reason to discount the result, it's a reason to read it precisely. A harness that clears every level of a public benchmark it could iterate against is a real demonstration that the scaffolding matters. It is not yet proof that the same harness generalizes to environments it has never touched, and NVIDIA didn't claim that it does.

The second domain: the same harness, a completely different problem

What does generalize, at least once, is the harness itself. NVIDIA pointed the identical AVO architecture, no puzzle-specific code, at GPU-kernel optimization instead of grid puzzles. Over 7 days, it explored more than 500 candidate kernel variants, committed 40 of them, and its best version beat FlashAttention-4 by up to 10.5% on NVIDIA DGX B200 hardware.

A grid-puzzle benchmark and a CUDA kernel search have almost nothing in common as tasks. What they share is that both scores moved when the same 3-part harness was wrapped around the same underlying model. The variable that changed wasn't which model NVIDIA used. It was whether that model got a memory, a supervisor, and a loop that keeps trying instead of one shot per question.

Why this matters more than one benchmark headline

NVIDIA's own post ends with a line worth sitting with: “The model matters, but the model is not the entire agent.” Most AI coverage this year is still framed as a leaderboard race between checkpoints, GPT-5.6 versus Grok 4.6 versus the next Gemini release, as if the model is the whole system. This result is a clean counter-example: the checkpoint never changed, and the system's measured capability moved by 69.84 points on the public benchmark, and produced a second, independent real-world win in GPU kernel search.

The practical version of that lesson, for anyone building agents rather than reading about them, is that the harness around a model is not a rounding error. Persistent memory, a stagnation detector, and a loop that plans, implements, and evaluates cost nothing in parameters and nothing in fine-tuning, and on this evidence they can matter as much as which model you picked in the first place.

If you're building the harness, not just picking the model

That's the same bet MegaBrainis built around: model selection is one lever, but the harness you run around a model, the routing, the memory, the retry and escalation logic, is often the bigger one, and it's the one most teams underinvest in while they argue about which frontier model to default to. MegaBrain routes every call through one API at zero markup with full cost and latency visibility, so you can actually measure whether a bigger model or a better harness is the fix for a given task, instead of guessing.

And if what you're building looks like AVO's agent loop, something that needs to keep state across attempts, catch its own stagnation, and keep working instead of waiting for the next prompt, that's exactly what mhermes, MegaBrain's always-on agent runtime, is for: persistent storage and scheduling on an isolated VM per agent, so the memory and supervision loop your harness needs don't have to be rebuilt from scratch every session.

Sign up at getmegabrain.com to build the harness around your model, not just pick the model and hope.