NVIDIA post-trains a 550B mixture-of-experts model for competitive programming and pairs it with GenCorrect, a five-round loop that generates ~200 candidates, clusters them, and refines under subtask feedback. Live at IOI 2026, it scored 535.4/600, beating the top human’s 498.27.
If you ship a code-generation agent, you already know the pattern: sample a bunch of candidates, run them against tests, pick the best. That’s most of what “agentic coding” is in production. This paper is a controlled study of what actually moves the needle on very hard problems, run end-to-end on the two hardest programming contests in the world (International Olympiad in Informatics and International Collegiate Programming Contest). The dominant baseline family is closed systems like OpenAI’s o1-ioi, which mixed coding-focused RL with hand-built inference scaffolding. This paper decomposes the pipeline (data curation, SFT, RL, test-time refinement) so you can see which stage pays for itself.
The pipeline has four stages built on 22,000 curated contest problems, each wrapped in an executable environment with real test cases. Stage one is supervised fine-tuning on reasoning traces generated by a strong teacher model (DeepSeek-V4-flash, later GLM-5.2 for the live run); crucially, the SFT mixture includes “self-improvement” traces where the teacher is shown a prior solution and asked to fix it, teaching the student the refinement behavior needed later. Stage two is Group Relative Policy Optimization (GRPO) reinforcement learning with a binary executable reward (1 if the C++ solution passes all tests, 0 otherwise), applied only to the smaller 30B model because RL on the 550B was too expensive. Stage three is inference-time GenCorrect: each round samples up to 200 candidates, filters ones that compile, clusters them by code-token similarity using a farthest-point selection rule, submits 10 diverse representatives to the grader, then conditions the next round on which subtasks are still unsolved. The submission budget (50 per problem) matches the human contest rules exactly.
accum_scores = {subtask: 0 for subtask in problem.subtasks}
references = []
for round in range(5):
candidates = sample(model, problem, references, n=200)
candidates = [c for c in candidates if compiles(c)]
centers = farthest_point_select(candidates, k=10, sim=token_shingle_sim)
submissions = [best_by_heuristic(cluster) for cluster in centers]
subtask_scores = grader.submit(submissions) # only signal seen this round
accum_scores = elementwise_max(accum_scores, subtask_scores)
references = pick_complementary(submissions, accum_scores) # cover gaps
For the live IOI 2026 run the authors made three competition-specific changes: switch the SFT teacher to GLM-5.2 (shorter outputs, higher score), expand the fifth round to 1,000 candidates ranked by executing them on model-generated test inputs, and quantize the 550B model to NVFP4 for a 3.7× throughput gain at the cost of ~6.6 points of Score@1.
The prevailing move for hard-reasoning benchmarks has been to lean on RL with verifiable rewards, following DeepSeek-R1 and similar recipes. This paper’s decomposition points the other way. On competitive programming, SFT on strong teacher traces does most of the work, RL adds a modest bump, and iterative refinement against the real grader is what actually crosses the gold threshold. The evidence is that for the 30B model, SFT lifts IOI 2025 Score@1 from 21.7% to 47.3%, RL adds only 1.8 points, and then GenCorrect adds another ~107 raw points on top; for the 550B model they skipped code-specific RL entirely and still won gold.
The load-bearing result is the stage decomposition on the 30B Nano-CC model: SFT alone lifts IOI 2025 Score@1 from 21.7% → 47.3%, RL adds +1.8 pp to reach 48.5%, and then five rounds of GenCorrect take the raw score from 360.6 → 468.2 (above the 438.3 gold threshold under the 50-submission cap). That gap between what SFT+RL gets you (Score@1) and what feedback-driven refinement gets you is the paper’s main lesson. Secondary evidence:
•
The 550B Ultra-CC model, trained with one SFT epoch and no code-specific RL, reaches 502 on IOI 2025 after five GenCorrect rounds, beating the RL-trained smaller model.
•
Stronger base models benefit more from test-time compute: at Score@1 Ultra-CC leads Nano-CC by only ~13 raw points, but at Score@200 the gap grows to 44, and after GenCorrect it grows further.
•
The live IOI 2026 run scored 535.4/600, above both the gold threshold (361.12) and the top human contestant (498.27). Post-hoc runs of the general (non-competition-tuned) pipeline averaged 521.7 with a range of 495.0–545.8, suggesting the competition-specific tweaks helped modestly but the general pipeline was already gold-level.
•
Gains transfer: Nano-CC hits 51.0% Pass@1 on ICPC 2025 and 71.6% on LiveCodeBench Pro, up from 16.9% and 17.6% for the base model.
Reach for this playbook when you’re building an agent that solves problems against a real verifier (test suite, type checker, simulator) with a bounded submission budget. The reusable idea is the GenCorrect loop: sample broadly, cluster to keep only structurally diverse candidates, spend your limited “real” evaluations on the 10 most different ones, then condition the next round on which sub-goals are still unmet rather than on free-text self-critique. The “per-subtask accumulated best score” state is the key trick, it lets the model see exactly which parts of the problem are still open without needing a separate critic model.
The authors say they will release the competition Ultra-CC checkpoint and runnable inference/evaluation recipes via NeMo-Skills. The training corpus itself is not releasable due to third-party redistribution restrictions on the source contest problems. If you want to reproduce or adapt the loop, the recipes and eval harness are the practically useful pieces; the 22K-problem curated set is not.
When you have a real verifier and a small submission budget, spend your compute on diverse candidates plus per-subgoal feedback, not on longer chains of thought. SFT on strong teacher traces gets you a competent solver; the refinement loop against the grader is what turns competent into gold-medal.
•
The live IOI 2026 result used a peak of 760 GB300 GPUs during inference. This is a system-level comparison to humans, not an equal-resource one, and the loop only works when you can afford ~1,000 candidate generations per problem in the final round.
•
RL was never run at 550B scale due to compute cost, so the claim “SFT dominates, RL adds little” is only directly measured on the 30B model. It might not hold if you could afford RL on the larger one.
•
Results are demonstrated on competitive programming, where the verifier is deterministic, cheap, and gives structured subtask credit. Domains with noisy, expensive, or binary-only verifiers (the paper already sees faster plateaus on ICPC’s binary feedback) will get less mileage from the per-subgoal refinement trick.