Gold Medals, Cheap Haikus, Stubborn Robots

One finding stands out. A single SFT epoch on Ultra beat the fully post-trained Nano on IOI, ICPC and LiveCodeBench Pro. That result is why the IOI 2026 entry used SFT alone, with no RL.

The math specialists

Starting from Nemotron 3 Ultra, the team trained two checkpoints:

• SFT checkpoint: 414,890 filtered examples covering 15,818 proof problems. The data went beyond final answers. It included proof generation, refinement, verification and meta-verification, so the model learned to find gaps in proofs and respond to critiques.
• RL checkpoint: trained on 9,597 problems picked to sit near the edge of what the model could solve.

The two checkpoints were strong in different places. The SFT model did best in the first search round, and the RL model had the best overall result of any single checkpoint. The final system therefore used both, plus the general model. For each problem it generated, scored, critiqued and refined candidate proofs. A separate high-compute stage then picked the submission. Everything ran in natural language, with no formal prover, tools or internet access.

NVIDIA's central argument is that neither fine-tuning nor brute-force sampling produced the medals alone. Better specialists supply better candidates and better critics to the search loop. At IMO, combining complementary checkpoints was worth more than drawing extra samples from one. The post does not give compute budgets.

The release includes the IMO SFT and RL checkpoints, both training datasets, a new 200-problem benchmark (Nemotron-IMO-Bench), Ultra-CC, papers for both projects, and NeMo-Skills inference pipelines with the IMO prompts and submitted proofs.

• Retokenization. Harnesses keep context as text. Running that text back through the chat template can shift token boundaries, so adjacent calls can't always be merged into one sample.
• Advantage calculation. Subagents, context summarization and retokenization split rollouts into several samples. Computing advantages per sample counts rollouts that produce many samples more than once.
• Loss normalization. Averaging loss over samples gives extra weight to rollouts that produce more samples, and sample count is mostly a side effect of how the harness behaves.
• Scheduling. Sample count and length are known only after a rollout finishes, but GPU and parallelism configurations are fixed in advance.

Design and results

The framework is about 3,500 lines of code with three parts:

• an API Gateway, which stores rollouts and runs the proxy;
• a Rollout Controller, which runs agents as local processes or as standard Kubernetes jobs, so there's no need for paid sandbox services like Modal or E2B;
• a trainer built on verl, which assembles samples through an adapter.

Collocated Async RL runs rollouts and model updates on the same GPUs. Once enough rollouts are collected, the gateway stops taking new requests, waits for in-flight calls to finish, runs the update, then resumes. The harness never sees the pause. The authors report about a 2x end-to-end speedup over synchronous RL, using fewer GPUs than standard async RL, which needs separate GPU pools.

The coding pipeline used SWE-smith data, mini-SWE-agent and Qwen3.5-9B, and included data cleaning and safeguards against reward hacking. With about 6,000 training samples, RL alone raised SWE-bench Verified Pass@1 from 41.8% to 56.4%. Computing both advantages and loss normalization per rollout gave higher validation reward (about 0.37) and steadier policy entropy than per-sample handling. The post shows results for only this one model and benchmark.

• Low: 7 seconds, 0.0936 cents.
• Max: 5 minutes 9 seconds, 3.3826 cents.
• Haiku 4.5 a year ago: 0.7583 cents, with no reasoning levels and a poor pelican.

The max-effort reasoning trace opened with "This is the classic pelican-on-bicycle SVG test." Because the model recognized the benchmark, Willison also tried an unfamiliar prompt: an armadillo in fishnet tights jaywalking on Mars. He tested the new model with his llm CLI. The latest llm-anthropic plugin picks up new models via llm anthropic refresh instead of needing a new release for each one.

Other announcements

• Sonnet 5.5 cache reads are now half price.
• Monthly API credits for subscribers: Max 5x gets $100, Max 20x gets $200, and Team plans get up to $500, shared across users. Credits don't roll over. You can turn off auto-reload so requests stop when the balance runs out, which avoids surprise bills.

Willison calls the credits "really generous" because they equal the cost of the subscription itself. He notes that OpenAI still lets people use a Codex subscription for personal API use, which is a better deal for heavy users. Anthropic's credits close some of that gap.

Thinking while answering

GPT-6 can also start answering partway through reasoning. OpenAI says it trained the model to account for how long the user is waiting. The model writes the answer in several partial responses that build on each other, and the goal is a final answer as coherent and accurate as one written in a single pass.

The numbers OpenAI gives, all from internal evals:

• On "high-value, everyday agentic tasks," GPT-6 Extra High starts answering as quickly as GPT-5.6 Medium and scores better overall than GPT-5.6 Extra High.
• On queries that need web search, GPT-6 Instant starts answering 44% sooner on average than GPT-5.6 Instant.
• On difficult problems, GPT-6 addressed "the key aspect of the user's question" more often than GPT-5.6. No figures are given.

Safety

OpenAI says GPT-6 holds up better against jailbreaks than GPT-5.6 Sol, especially attacks that adapt over several turns. It also says the model uses conversation history to spot risks that a single prompt wouldn't reveal, and refuses harmless requests less often. Training drew on real-world misuse involving cyberattacks, biological threats and violence. OpenAI also says the model is better at stating when it lacks the information or tools to answer. The detailed results are in the system card, not this post.

OpenAI's broader argument is that software should adapt to people instead of people learning fixed interfaces. Intelligent UI is the first step it is shipping toward that.

Connector insertion: the "inverse bitter lesson"

The second task: lift four cable-mounted connectors and insert each into a socket with tight clearance. To grasp the cables, the robot segments them with SAM3, fits a centerline and grabs the midpoint. This almost never failed. Grasping the connectors was harder. They are small and nearly textureless, so generalist pose estimation failed. Behavior cloning with ACT and diffusion policies also had low success. The cables differ from sample to sample, few were available, and each one deforms permanently after limited handling, so the team couldn't collect data at scale. The authors call this the inverse bitter lesson: sometimes physical and financial limits make scale impossible.

Their fix was DOPER, a specialist pose estimator. It trains a lightweight CNN on renders from a part's CAD model, using keypoints chosen by farthest-point sampling on the part's convex hull. It is then fine-tuned on pseudolabels generated from a real-world 3D neural reconstruction of the part, and runs at 30 Hz or faster. 3D-printed gripper fingers guide each part into a repeatable pose as the gripper closes. For insertion, an RL policy trained in Isaac Lab worked for the large connector but not the small one, where small pose errors made it slip against the socket edge. Extending the team's earlier SPARR method fixed this: a real-world residual RL policy that uses force-torque input, since the connector is hidden from the cameras during insertion, sits on top of the sim policy. End-to-end, the task succeeds 90–95% of the time at about 40 s per cable, against a 72 s target for all four.

The authors also point out a verification problem. Showing 99.5% success at one-sided 95% confidence requires 598 consecutive successful trials, and wear on the parts means that could consume hundreds of duplicate components. They propose AV-style deployment: run under human supervision and learn from each correction.