The same model that walks through an olympiad-grade proof in one turn will, in the next, tell you 9.11 is larger than 9.9 and then defend it. Nothing changed between those two answers — same weights, same context window, same temperature. If you spent 2025 building on top of frontier models, you learned to expect exactly this: brilliance and blunder out of one set of parameters, minutes apart.
Three phrases dominated the year's post-mortems — RLVR, test-time compute, and jagged intelligence. They usually get filed as three separate trends. They are not. They're one causal chain. RLVR is the training method that produced most of the year's gains; test-time compute is the control knob it handed us; and jagged intelligence is the shape of mind you get at the end of the pipeline. Reading them as a chain rather than a list is the difference between being surprised by your model in production and designing around it on purpose.
The training stage that reshaped the year
For years the recipe was pretraining, then supervised finetuning, then RLHF — reinforcement learning from human feedback, where a learned model predicts which answer a human would prefer. The weakness of a learned preference model is that it can be gamed: optimize against it hard enough and you get answers that score well and mean little.
2025's answer was to make the reward a program instead of a model. Reinforcement learning with verifiable rewards (RLVR) trains against signals you can check mechanically — did the final math answer match, did the code pass its tests:
# RLHF: a learned model guesses how much a human would like the answer
reward = preference_model(prompt, answer) # subjective, gameable
# RLVR: the reward is a program that checks the answer
def reward(answer, task):
if task.kind == "math":
return 1.0 if answer.final == task.gold else 0.0
if task.kind == "code":
return fraction_of_tests_passing(answer.code, task.tests)
Because the signal is objective, you can run the loop far longer without it collapsing, and models trained this way begin to spontaneously produce long chains of reasoning — not because anyone labeled reasoning traces, but because reasoning is what raises the pass rate. This is the machinery behind the reasoning models that defined the year: o1 late in 2024, then o3 and DeepSeek's R1 in early 2025, the latter proving you could reach that tier with open weights and pure RL. Most of the year's headline gains were labs working through the backlog of this single new stage.
Thinking became a budget line
RLVR handed us a knob that pretraining never offered. Once a model has learned to reason its way to the reward, you can buy more reasoning at inference time — let it generate longer traces, sample more candidate solutions, check its own work — and accuracy climbs with the token budget. Capability stopped being purely a function of model size and became something you pay for per request.
That reframes cost. A cheaper model told to think for 10,000 tokens can beat a larger model answering in 200. It also introduces a real failure mode: more thinking is not monotonically better. Reasoning models overrun easy questions, talk themselves out of a correct first answer, and burn budget on problems that needed one line. "Think longer" is a dial with a wrong end, and finding the right setting per task type is now an engineering decision, not a checkbox.
Why the output comes out jagged
Here's the part that matters for anyone shipping. RLVR only sharpens capability where a verifier exists — math, code, structured puzzles. Nobody has a cheap program that scores "sensible judgment about a refund dispute." So capability spikes hard near the verifiable domains and stays flat everywhere else. The result is jagged intelligence: a model that is, in one widely-shared framing, a genius polymath and a confused grade-schooler wearing the same coat.
The same year-in-review offered the sharpest metaphor for why this feels so alien:
We're not "evolving/growing animals", we are "summoning ghosts".
Human intelligence was optimized by survival, so our strengths and weaknesses correlate in ways we can intuit. These models were optimized by text imitation and puzzle rewards — a completely different objective — so their competence map has no relationship to ours. There is no reason a system that proves theorems should also count decimal places, and increasingly it doesn't.
This also broke benchmarks. A benchmark is, almost by definition, a verifiable environment — precisely what RLVR optimizes against. When the test is checkable, training on its distribution becomes an art form, and a five-point jump on a public eval tells you less every quarter. Treat leaderboard deltas as marketing until you've measured on your own private, task-shaped cases.
What to actually do with a jagged model
The posture that follows from all of this is not "wait for the models to smooth out." Assume they won't; the jaggedness is structural, a direct consequence of where verifiers happen to exist.
- Put a verifier in your own loop. If the task is checkable — types, tests, schemas, a second model cross-examining the first — check it. That's the same lever the labs pulled, applied at the application layer.
- Budget inference per task type. Give hard, verifiable problems a large thinking budget; cap the easy ones before the model overthinks its way to a wrong answer.
- Distrust the smooth mental model. Don't assume a model that aced your hardest case will clear the trivial one beside it. Test the boring inputs on purpose, because that's where jaggedness hides.
- Benchmark on your own data. Public evals are the test set now. Your private cases are the only signal that hasn't already been optimized against.
The one-line version: 2025's capability gains and 2025's strangest failures came out of the same pipe. Build as though intelligence is spiky rather than smooth — verify what you can, budget thinking deliberately, trust your own measurements over the leaderboard — and you get the upside of the reasoning era without being blindsided by the grade-schooler still living in the weights.
Sources: 2025 LLM Year in Review, Reinforcement Learning with Verifiable Rewards Implicitly Incentivizes Correct Reasoning in Base LLMs (arXiv:2506.14245), Inference-Time Scaling: Reasoning Models in 2025