0:00Juniper: A thirty-billion-parameter model sat the 2025 International Olympiad in Informatics — the world championship of competitive programming — and scored 291 out of 600. Then the exact same model weights took the exact same exam and scored 468. No extra training. No new knowledge added to the model. Just a different way of taking the test. That difference was worth 177 points. It took the system from below bronze to gold-medal territory.
0:28Eric: And the move that bought most of those points sounds, at first, like a mistake. The system deliberately throws away its ten best answers.
0:37Juniper: Or, more precisely, it passes over the ten answers that look strongest and submits a deliberately varied set instead. The authors call the full test-time system GenCorrect. It generates many possible solutions, submits a diverse few, studies the partial-credit scores, remembers what worked, and tries again. By the end of this episode, you’ll know which part of the modern AI stack is actually paying for performance here: the training data, the fine-tuning, the reinforcement learning, or the scaffolding wrapped around the model while it answers. NVIDIA built all four in the open, then measured them one at a time on the same fixed exam.
1:18Eric: And that matters well beyond programming olympiads. It’s the budget question every team building coding agents is guessing at right now. Do you spend the quarter on another training run? Or do you improve the loop around the model?
1:34Juniper: Right. And the honest answer is a little deflating for one of those options.
1:39Eric: Let me state the obvious bet first. For the past two years, if you asked how to get a model to gold-medal level at competitive programming, a lot of people would say reinforcement learning with verifiable rewards. Code gives you unusually clean feedback. You compile it. You run it against real tests. If it passes, reward the model. If it fails, don’t. That’s about as crisp as a machine-learning reward signal gets. And it’s where a lot of the excitement has been.
2:10Juniper: In this paper, that reinforcement-learning stage added eleven points out of 600.
2:16Eric: Eleven. Not a hundred and eleven. Eleven.
2:19Juniper: So here’s the experimental ladder. There are four rungs, and four scores worth keeping straight: 130, 280, 291, and 468. Start with the base model. It has thirty billion parameters in total, but only about three billion are active for each token it produces. It’s what’s called a mixture-of-experts model: it contains many specialized sections, but only activates a small portion at a time. So it has a large overall capacity while paying something closer to the running cost of a much smaller model. Straight out of the box, on the six problems from the 2025 olympiad, it scores 130 out of 600. That wouldn’t have earned bronze.
2:59Eric: That’s rung one: base model, 130.
3:02Juniper: Rung two is distillation. A stronger existing model generates 1.2 million worked solutions across twenty-two thousand competition problems. And the researchers don’t keep only the final code. They keep the whole reasoning transcript: the false starts, the abandoned ideas, the moment the model realizes an approach won’t fit within the time limit, and the reformulation that follows. Then they train the smaller model to imitate those transcripts. Think of it as apprenticeship. You’re not just handing the student a book of correct answers. You’re letting the student watch a master work through a problem, out loud, more than a million times. That takes the score from 130 to 280.
3:45Eric: So distillation buys 150 points. The student is absorbing a style of problem solving, not merely memorizing completed solutions.
3:53Juniper: Exactly. Then comes rung three: reinforcement learning. The system writes code. The code is compiled and executed against real tests. A full solution gets a reward of one. Anything less gets zero. That takes the score from 280 to 291.
4:09Eric: A hundred and fifty points from imitation. Eleven from the stage everyone’s excited about.
4:15Juniper: And rung four is GenCorrect, the loop around the fixed model. Same weights. No additional training. That takes the score from 291 to 468.
4:24Eric: Before we unpack that loop, I don’t want to skate past why the reinforcement learning stalls. The authors diagnose it themselves, and the diagnosis matters. They use an algorithm called GRPO. For each problem, it samples a group of sixteen attempts. It scores each attempt relative to the average of that group. Better-than-average attempts get reinforced. Worse-than-average attempts get suppressed.
4:50Juniper: And what happens when all sixteen attempts fail?
4:54Eric: Nothing useful. If all sixteen receive the same zero reward, every attempt equals the group average. There’s no difference for the training algorithm to learn from. In machine-learning language, there’s no gradient. In plain English, the model’s weights get no directional nudge at all. The same problem appears at the other extreme. If all sixteen attempts succeed, they’re also indistinguishable. So this form of reinforcement learning teaches only in a narrow band: problems where the model already succeeds sometimes and fails sometimes. It can sharpen the frontier. It struggles to move that frontier into problems where every attempt currently fails.
5:35Juniper: And there’s a second problem.
5:37Eric: Some of these reasoning traces run to a quarter of a million tokens. The model makes an enormous chain of decisions, then receives one number at the very end. No notes in the margins. No indication of which choice was clever, which detour was useless, or where the solution went off the rails. It’s grading a book-length exam with one digit.
6:00Juniper: So if you’ve lost the thread, here’s the reinforcement-learning problem in two parts. First, when every attempt fails, the system gets no relative signal telling it which failure was less bad. Second, even when it gets a final reward, that reward comes after a quarter-million-token trajectory. It doesn’t say which decisions deserve credit.
6:22Eric: To be fair, the researchers ran the honest control. They applied reinforcement learning directly to the raw base model, without the distillation stage first. Performance did improve — from roughly twenty-two percent to twenty-five percent on the olympiad set. So executable rewards do teach something from scratch. They just don’t teach much compared with distillation.
6:46Juniper: That’s the paper’s first major payoff. It gives us an open measurement that’s rarely published cleanly: in this setup, the stage everyone talks about isn’t where most of the points come from. If you want every major AI paper taken apart like this, daily, that’s what this channel does — subscribe and you’ll get them.
7:06Eric: So the biggest remaining jump comes from GenCorrect. Now we need to understand what that loop actually does.
7:13Juniper: Here’s the mechanism. There are four pieces to remember. One: the candidate pool. The model generates two hundred complete solutions to one problem. Two: the selector. It chooses ten of those two hundred to submit. Three: the grader. This is the real official contest judge, which returns a score for each submission. And four: the notebook. The notebook keeps a running record of the best score achieved so far on every part of the problem. The system runs for five rounds. It makes ten official submissions per round, for fifty submissions in total. That’s exactly the cap given to a human contestant.
7:51Eric: And the grader isn’t returning a simple pass or fail. That’s the structural fact the whole system feeds on.
7:58Juniper: Right. An olympiad problem is usually divided into subtasks. One subtask might allow only ten input elements, so a slow brute-force method is enough. Another might allow a million elements and require the contestant to discover some hidden structure. Each subtask is worth part of the problem’s hundred points. So when a solution comes back, the system doesn’t just hear “wrong.” It gets something more like: full credit on subtasks one and two, half credit on three, and zero on four. That scorecard tells the model where its solution works and where it breaks.
8:32Eric: Now the selector has two hundred possible programs and only ten submission slots. The obvious move is to estimate which ten are best and submit those.
8:42Juniper: And GenCorrect does something that initially looks backward. It chooses ten solutions that are as different from one another as possible. The selector starts with one candidate. Then, repeatedly, it adds whichever remaining program is least similar to the programs already chosen. Similarity is measured directly from chunks of normalized C++ source code. The goal is to spread those ten submissions across the space of possible approaches.
9:09Eric: But that means accepting some weaker-looking programs. If you’ve already identified a top ten, diversity forces you to leave some of them out.
9:18Juniper: It does. And that’s still the right move because round one isn’t only an attempt to score. It’s reconnaissance. Imagine drilling ten wells in a field. You could put all ten where your survey says oil is most likely. But then you’ve taken ten samples from essentially one location. Or you could spread the wells across the field. You may get less oil immediately, but you learn much more about where the oil actually is.
9:43Eric: So ten nearly identical programs are ten copies of one idea. Their scorecards tell you one thing. Ten very different programs test ten different algorithmic strategies.
9:53Juniper: Exactly. In the opening round, you’re not trying to be right ten times. You’re trying to learn ten things. And unlike the drilling example, those exploratory submissions aren’t wasted. Every one of them is still officially scored, and any useful result can be banked. That brings us to the notebook. After each round, the system records the highest score it has achieved so far on every subtask. Suppose one program solves the first two subtasks and another solves the third. The notebook keeps those high-water marks. Once a subtask has been fully achieved, later rounds don’t need to spend effort on it.
10:29Eric: So the search has memory. It doesn’t keep rediscovering the same partial success.
10:35Juniper: Right. The recorded score can only improve. Each new round attacks the gaps that remain. That’s what turns fifty scattered submissions into one coordinated search. And there’s an important methodological detail here: the diversity selector is blind to grades. It filters and groups the programs before any official scores come back. So the diversity step can’t secretly peek at the results and choose retrospectively.
11:00Eric: What does the model actually receive when round two starts? Because “Here’s your scorecard, try harder” isn’t much of a strategy.
11:09Juniper: It gets three things. First, the accumulated scorecard showing what has and hasn’t been achieved. Second, three reference solutions chosen to complement one another: the strongest overall solution, one aimed at the largest remaining gap, and one with useful coverage across the other gaps. Third, it gets a strategic instruction. I want to read this close to verbatim because it may be the most revealing line in the paper: “Choose exactly one eligible target subtask and focus on solving that target better. Prefer the target with the largest remaining score gap, unless another one is clearly easier to improve. Do not spend effort on subtasks that are already fully achieved.”
11:50Eric: That’s not an algorithm. That’s a coach talking to a sixteen-year-old.
11:56Juniper: It’s contest strategy, written in English and pasted into a prompt. Earlier systems handled subtasks by splitting them apart and generating separate solutions for each one. That burns generations. GenCorrect instead gives the model the whole state of play and tells it how to choose its next battle.
12:15Eric: Let me see if I’ve got the causal story. Distillation gives the model much more ability. Reinforcement learning polishes a narrow band where the model already wins occasionally. GenCorrect then converts that ability into points by exploring diverse approaches, reading partial-credit feedback, and remembering which pieces have already worked.
12:36Juniper: That’s the core of it. Now the researchers ask whether the loop still helps when the underlying model gets much larger. They compare the thirty-billion-parameter specialized model with a 550-billion-parameter model. There are three comparisons, and they tell three different stories. First, one attempt per model — the normal single-shot benchmark. Here, the enormous model leads by only about two percentage points. In raw olympiad scoring, that’s thirteen points. Almost nothing.
13:07Eric: The sort of difference that could look like a rounding error on a leaderboard.
13:12Juniper: Second, they sample two hundred solutions from each model and count the best one. Now the gap expands to forty-four points. Third, they run the full five-round GenCorrect loop. After round one, the large model is actually behind. It has 343.9 points, compared with 360.6 for the smaller model.
13:30Eric: So the giant model’s first batch is worse.
13:33Juniper: Yes. But by the end of all five rounds, the large model has overtaken it. The big model finishes at about 502. The small model finishes at 468. That’s a gap of roughly thirty-four points.
13:46Eric: So the larger model’s advantage doesn’t show up mainly as a better first answer. It shows up as a richer spread of ideas to sample from, plus a greater ability to use the feedback over multiple rounds.
13:59Juniper: And that has a practical consequence. If you benchmark two models using one answer each, then deploy the winner inside a system that samples hundreds of answers and iterates on feedback, your benchmark may be ranking the models on the wrong axis.
14:15Eric: There’s another comparison in the paper that may be its cheapest big idea. The researchers also test the loop on the International Collegiate Programming Contest, the major university competition. The feedback there is much less informative. Instead of a detailed subtask scorecard, a submission mostly comes back as one bit: pass or fail. On the olympiad problems, where the model receives partial-credit scores, performance keeps improving through all five rounds. On the university contest, both models plateau after two or three.
14:51Juniper: It’s Mastermind versus a padlock.
14:54Eric: Exactly. In Mastermind, every wrong guess gives you structure: two pieces are right and in the right place, one is right but misplaced. You can use that information to converge. A padlock just stays closed. A thousand failed combinations teach you a thousand combinations it isn’t. Same amount of search. Very different return. The difference is the information the environment provides when you fail.
15:21Juniper: And that lesson transfers beyond programming contests. If you’re building automated test harnesses, software-development pipelines, or evaluation environments for agents, don’t give the agent only a pass-fail bit. Give it feedback it can climb.
15:38Eric: Before we get to the live competition run, I want to plant the resource caveat now rather than spring it later. The AI system faced the same five-hour clock, the same no-internet rule, the same fifty-submission limit, and problems it hadn’t seen before. What wasn’t matched was the amount of computing hardware. The system used up to 760 datacenter graphics processors. Three constraints were held constant. The most consequential resource wasn’t.
16:09Juniper: Agreed. Hold onto that caveat. Now, every earlier claim of AI gold-medal performance at this olympiad had been retrospective. By the time the AI took the test, the problems were already public. So were editorials, explanations, and forum discussions. That always leaves a nagging question: did the model solve the problem, or did it recall something about it? You can’t completely prove the absence of contamination after the fact.
16:35Eric: Unless the model takes the exam before the problems exist in public.
16:39Juniper: Which is what the researchers did in 2026. They entered the 550-billion-parameter system live during that year’s International Olympiad in Informatics. The problems were new when the competition clock began. For this live run, they made three competition-specific changes. First, they used a different teacher during distillation. That teacher scored higher and produced shorter reasoning traces. Shorter traces matter because they let the system generate more candidates inside the same five-hour limit. Second, they expanded the final round from two hundred candidate programs to one thousand. Third, they quantized the model to four-bit precision. Quantization means representing the model’s numbers less precisely so it can run faster. That produced 3.7 times the throughput, at a cost of about six and a half points in single-shot accuracy.
17:30Eric: They deliberately made each attempt slightly dumber so the system could make many more attempts.
17:36Juniper: In a search-driven system, more attempts can beat better individual attempts. But that creates another problem. In the final round, the system has a thousand candidate solutions and only ten official submissions left. It needs a way to rank those candidates before using its remaining slots. So it writes fifty programs that generate possible test inputs. It checks those inputs with its own validators and keeps a hundred valid ones. Then it runs all the candidate solutions against those tests. Finally, it writes its own scoring script using the published criteria for each subtask. In other words, the system builds an internal grader to predict which candidates deserve the final official submissions.
18:21Eric: All right. What did the live system actually score?
18:24Juniper: It scored 535.4 out of 600. The gold-medal threshold that year was about 361. The highest-scoring human contestant scored 498.27.
18:34Eric: So on the day of the competition, the AI finished about thirty-seven points ahead of the best human contestant in the room.
18:42Juniper: On problems that didn’t exist publicly when the clock started. To the authors’ knowledge, it was the first AI system to outscore the top human contestant on an International Olympiad in Informatics problem set.
18:56Eric: And now I’m going to take that headline apart a little, because the careful version is more interesting. That live result was one run. After the competition, the researchers reran the broader pipeline. Those runs averaged about 522 points, with results ranging from 495 to 546. The best human had scored 498.27. So the bottom of the AI system’s observed range falls below the human score.
19:21Juniper: Meaning the strongest version of the headline depends on which run you happen to get.
19:27Eric: Right. “Beats the best human” describes the live draw. And on the day that counted, it won by thirty-seven points. But the system’s own reruns show a distribution whose lower end crosses the human result. On a bad day, this system loses. The paper reports that range honestly, which is to its credit. But the abstract’s phrasing is stronger than one sample really supports.
19:52Juniper: I’m not going to argue with that. The fairer summary is: this system is typically at or near the level of the best human, not reliably above it.
20:01Eric: There’s a second issue, and this one changes how I’d describe the paper’s contribution. The teacher model still outperforms the student model in both teacher-student pairings. For the main specialized system, the teacher scores about fifty-five percent on the 2025 problems in a single attempt. The distilled student reaches about fifty-one percent. For the live-run variant, the stronger teacher scores about sixty-six percent. Its student reaches roughly fifty-nine percent. So on this benchmark, the student never surpasses the teacher.
20:37Juniper: Which means the contribution isn’t simply, “We trained the strongest model.”
20:42Eric: No. It’s closer to: “We built a fully open training pipeline and a very strong inference loop, and that loop is where much of the value appears.” That’s consistent with the paper’s own ablation ladder. But there’s a third caveat that nags at me. Every competition-specific choice — the teacher swap, the thousand-candidate final round, the quantization setting — was tuned using the 2025 problem set. That set contains six problems. And those same six problems are also where the paper reports all the stage-by-stage ablation numbers.
21:17Juniper: Six problems is a small development set.
21:21Eric: A very small one. We don’t know how much of that beautifully clean ladder was partly fitted to those six particular problems. I don’t think that erases the live result. The live competition used genuinely unseen problems. But the system used for the live record and the system used for the clean decomposition aren’t identical. So the paper doesn’t completely separate every contribution it originally set out to separate.
21:49Juniper: That’s fair, and the authors acknowledge part of it themselves. Their limitations section says the live result should be understood as a system-level comparison under the same time and submission limits, not as an equal-resource comparison with the human contestants.
22:06Eric: A grandmaster playing forty chessboards is one mind spread thin. This system is the inverse: many parallel attempts converging on one board, with a manager reading the results and deciding where to focus next. Same clock. Same submission rules. Not the same thing sitting in the chair.
22:25Juniper: So let’s return to the cleanest result. The same fixed model scored 291, then 468. What changed between those scores wasn’t the model’s knowledge of algorithms. It was how the system used that knowledge. The model could attempt the problem, receive a detailed grade, preserve the parts that worked, and direct the next round toward the parts that didn’t.
22:48Eric: And the allocation signal underneath that result is blunt. Distillation added 150 points. Reinforcement learning added eleven. The GenCorrect loop added 177.
22:59Juniper: That doesn’t prove reinforcement learning is generally unimportant. It establishes something narrower and more useful. In this system, on this six-problem olympiad benchmark, better training wasn’t the largest source of additional performance. A large share of the gain came from scaffolding: diverse sampling, informative feedback, targeted retries, and memory across rounds.
23:24Eric: And the contrast with the university contest tells you why. Search becomes much more valuable when failure contains information.
23:33Juniper: So here’s the practical question. If you had one quarter’s budget for a coding agent, would you spend it post-training the model? Or would you spend it improving the sampling loop, the scaffolding, and the richness of the feedback the environment returns? If you’ve shipped one of these systems, you probably already know which way you lean. Say so in the comments.
23:56Eric: The full annotated version of this episode is on paperdive dot AI, with every technical term tap-to-define and links to the related papers grouped by theme.
24:06Juniper: Here's a quick bit of housekeeping before we go. The script was written by Anthropic's Claude Opus 5 and then refined by OpenAI's GPT-5.6 Sol, Eric and I are AI voices from Eleven Labs, and the producer isn't affiliated with either company. The paper is "Post-Training Language Models for Gold-Medal Performance in Coding Competitions," by Aleksander Ficek and their colleagues, posted September 2nd, 2026.
24:31Eric: One final gap in the paper: it never gives a problem-by-problem breakdown of the live score. So we don’t know whether the system performed evenly across all six problems, or maxed out four and scraped partial credit on two. Broadly competent, or narrowly spiky? The final total can’t tell us.