AI Beats Top Human Coder at IOI 2026: 535.4 vs 498.27

Competitive programming just crossed a line no prior contest had seen. At IOI 2026 — the International Olympiad in Informatics, the hardest school-age coding competition on Earth — an NVIDIA system called Nemotron-CC scored 535.4 out of 600, clearing the gold threshold of 361.12 and beating the top human contestant, who scored 498.27. By the authors' accounting, it is the first AI system to outscore the highest-scoring human on an IOI problem set, under the same time, internet-access, and submission constraints as the humans in the room.

What Problem Does This Solve?

Two problems, actually. The first is that competitive programming is one of the best machine-checked proxies for structured reasoning we have: parse a statement, design an algorithm, prove it fits the constraints, implement it bug-free under a clock. IOI problems have exact, machine-verifiable answers, so there's no grader noise — either the solution passes the test set or it doesn't. The second problem is post-training. Base models get you to "competent." Getting to gold-medal requires turning raw capability into contest behavior: knowing when to stop optimizing, when to submit, how to hedge between solutions. No one had published a pipeline that clears gold at the hardest level under real contest constraints.

What's the Method?

End-to-end specialization. The team curated 22,000 competitive programming problems with synthetic reasoning traces, then trained two mixtures-of-experts on top: Nemotron-3-Nano-CC (30B total, 3B active) got supervised fine-tuning plus reinforcement learning with verifiable rewards, while Nemotron-3-Ultra-CC (550B total, 55B active) got SFT alone — a deliberate ablation of RL at scale. On top sits GenCorrect, a feedback-driven test-time strategy: generate diverse solutions, run them against hidden tests, feed failures back, refine, repeat.

flowchart LR
    A["22,000 curated problems + synthetic reasoning traces"] --> B["SFT on traces"]
    B --> C["RL with verifiable rewards — Nano-CC 30B"]
    B --> D["SFT only — Ultra-CC 550B"]
    C --> E["GenCorrect: generate → test → refine"]
    D --> E
    E --> F["IOI 2025 (retrospective): 468 pts vs gold 438.3"]
    E --> G["IOI 2026 (live): 535.4 vs top human 498.27"]

What Are the Results?

Run retrospectively on the IOI 2025 problem set, Nano-CC jumped from 130 points to 291 after post-training, then to 468 with GenCorrect — above that year's gold threshold of 438.3. Ultra-CC, with SFT alone, hit 502. Then came the prospective run: a competition-specific Ultra-CC system evaluated live during IOI 2026 under full human constraints. It scored 535.4/600, comfortably above the gold threshold of 361.12 and the top human's 498.27. The scale result is almost as interesting as the headline: SFT-only at 550B beat RL at 30B, suggesting scale can substitute for a lot of reward engineering.

What Are the Limitations?

• Test-time compute is the real cost. GenCorrect iteratively generates, evaluates, and refines many candidate solutions per problem. The compute budget per submission isn't reported, and the "system" isn't a single forward pass — it's an inference harness with a feedback loop.
• Curation is part of the win. The 22,000-problem dataset with synthetic traces is a human-built asset. The pipeline is reproducible in principle, expensive in practice.
• One contest, one shot. The IOI 2025 numbers are retrospective on public problems. The IOI 2026 run is prospective — the strong claim — but it's a single event. Variance across years and problem setters remains untested.
• Contests are not engineering. A gold medal at IOI says nothing about migrating a monorepo or debugging a flaky distributed system. The gap between competitive coding and production software is exactly what Dispatch's SWE coverage keeps measuring.

Why Should Someone Building Things Care?

First: generate → test → refine loops are the cheapest capability lever available. GenCorrect needs no new training — it's an inference-time harness that works because a verifier (the judge) exists. Any domain with a fast, reliable checker just got permission to ship similar loops. Second: the RL-versus-scale result is a budget decision in disguise. If a 550B SFT-only model out-scores a 30B RL model, teams with compute should skip the reward modeling and scale; teams without should know the 30B RL path still clears gold. Third, the frontier of "AI beats the best human at X" has moved from games to formal reasoning under a clock — and verifiable-reward domains are where that happens first. If your product has a verifier, the competitive programming chapter is the blueprint for your roadmap.