A Taxonomy for Next-Generation Reasoning Models

Knowing how to solve a benchmark is different from finding a reference whose name you have forgotten. By June 2025, the wave of o1 and DeepSeek reasoning models had established a productive relationship between reinforcement learning during training and additional computation at inference. Much of the discussion centered on reinforcement learning with verifiable rewards (RLVR): rewarding answers that can be checked for correctness. Nathan Lambert wanted to know what came next beyond higher benchmark scores and answers consuming 10,000 tokens.

His everyday example was a familiar frustration for a researcher. He remembered an example of reward over-optimization but kept forgetting that the game was called CoastRunners. Searching for over-optimization meant repeatedly trying to recover the right reference. When he asked o3, he reports, it supplied the download link directly. The model recovered what he meant without requiring him to remember the name first.

That is an unexpected application of training initially associated with math and code. Lambert had made o3 his most-used model for finding information, and this retrieval success suggested that reasoning training could enable a broader range of useful behavior. It was an application anecdote, not a controlled comparison, but it made the research question concrete: which additional capabilities would turn isolated successes into dependable products?

Deep Research extended that promise into a more steerable workflow. Lambert described directing it to inspect his website for typos or restricting its research to material published on that site. The useful capability was not simply producing a report; it was following a narrower definition of what to investigate.

Claude Code offered another kind of interaction. He used it to help build the website for his online book, treating it as a tool for enjoyable experiments. His enthusiasm came with a qualification: he was not evaluating it on demanding software-engineering work.

Codex represented a further step toward autonomous execution. Lambert thought the form factor was clearly promising, while finding its environment limiting for machine-learning tasks. At the time of the talk, he reported that it had no GPUs and had only recently gained internet access. Working with open models could require looking up Hugging Face configurations, so those environmental constraints mattered independently of the model’s reasoning ability.

His prediction was that these products would become everyday tools within the following six months. That was a forecast about the emerging applications of reasoning models, with useful behavior still dependent on access to the tools and resources a task required.

A chart of task horizons placed these applications in a longer progression. Lambert read the period around GPT-4o as showing signs of saturation, followed by newer Sonnet models and o1 extending the frontier. He described the vertical axis loosely as how long a task could be completed by a model, and connected the subsequent gains to reasoning training.

Editor: In METR’s original March 2025 analysis, the task horizon measures task duration for a human expert at a specified probability of agent success. It does not measure the agent’s own running time.

Extending the curve requires identifying and training missing capabilities. A trend line does not make the next gain automatic. Lambert’s proposed next step was to move beyond individual reasoning skills toward planning: what would a research program need to teach a model so that it could work autonomously on a substantial task?

Lambert’s provisional taxonomy separates four traits that are easy to conflate when judging whether a model is good at reasoning:

Skills were already the clearest success of reasoning training. Calibration became more consequential as each task consumed more computation. Strategy and abstraction were Lambert’s proposed subdivisions of planning: first choose a direction, then turn it into work that can actually be carried out.

Humans often supply that decomposition today. Training a model to solve math problems does not explicitly teach it how to divide an open-ended task among its own abilities, tools, and other models. In Lambert’s research agenda, those behaviors needed to become training targets in their own right.

The basic RLVR loop is straightforward:

1. Give the model a prompt.
2. Let it generate a completion.
3. Score that completion using the available verification procedure.
4. Use the scored completions to update the model’s weights.

The diagram Lambert described was a single-turn loop. Multi-turn interactions and tool calls make the formulation more complex, but the central mechanism remains generation followed by feedback and a weight update.

The progression from GPT-4o to o1 and then o3 showed how much this additional training could change performance on difficult evaluations. Lambert pointed to Humanity’s Last Exam and AIME while arguing that planning needed a comparable capability-building effort. Better scores on existing reasoning tasks did not establish that models could reliably organize longer work.

The repertoire of individual skills was also expanding. Lambert highlighted tool use in newer DeepSeek and Qwen models, and described o3’s usefulness as the combination of tools with reasoning, math, and code.

What sits above tool use was harder to describe precisely. Claude had a reputation for strong agentic behavior, but Lambert emphasized that there was no equally established way to measure or communicate that quality across models. Calling a tool successfully is observable; judging whether a model directs a whole task well requires a broader evaluation.

At the time of the talk, products largely delegated effort calibration to the user. ChatGPT offered model selection; Claude exposed an extended-thinking toggle; Gemini had similar controls; APIs offered reasoning-effort settings. Each control asked the user to predict how much reasoning the next task deserved.

A model that could make that decision itself would reduce both the selection burden and unnecessary token expenditure. The problem becomes more expensive as the available reasoning budget grows.

Consider 2 + 3. Lambert described examples in which reasoning models used hundreds to roughly a thousand tokens for an addition whose answer could be a single token. A separate sequence-length comparison on the slide contrasted a standard instruction model with the QwQ thinking model. In the comparisons he discussed, switching to reasoning could increase token expenditure by 10–100×; this was not a universal multiplier for every task or model.

Extra tokens create infrastructure load, cost, and waiting time. For an easy question, the user should not have to wait minutes or switch providers to avoid unnecessary deliberation. Calibration means spending effort where it changes the result.

Effort calibration leads to a second question: is the model spending that effort in a useful direction? Lambert took an example problem from Epoch AI’s FrontierMath material and tried it with DeepSeek-R1-0528. He wanted to see whether the model would plan before beginning the solution.

In his account, it immediately began constructing a polynomial. It did not first sketch the problem or compare possible approaches. This was a probe of one problem, but it illustrated the distinction between starting to reason and choosing a strategy.

Lambert expected an answer of 10,000–40,000 tokens. He then imagined increasing that budget by another factor of ten: following the wrong direction could consume multiple dollars and substantial latency without producing useful progress. Those were an expectation and a hypothetical extension, not measured results from the probe.

He described the applications under discussion as operating within roughly one-to-thirty-minute latency windows. A bad overall strategy and excessive work on a single subproblem can both exhaust that window. From the user’s perspective, either failure can mean abandoning the task before it finishes.

Products such as Deep Research and Claude Code appeared to Lambert to be prompted to plan at the start. His proposal was to make that behavior native to the model through training, so that choosing an approach would not depend entirely on instructions supplied by the application.

A plan creates practical questions about memory and execution. Lambert described Claude Code compressing its memory when the context window filled, without assuming that this was the best memory policy for every application. An agent also needs to avoid repeating mistakes—a problem he connected to the earlier discussion of playing Pokémon. Remembering previous attempts matters only if that information changes what the agent tries next.

Abstraction also means producing manageable parts and allocating additional thinking to the difficult ones. That may involve offloading work to another model or calling several models in parallel.

Lambert’s memorable example was the manual version: people opening tmux and running Claude Code in ten windows. The desired model capability was not merely to launch more processes. It was to recognize when parallel work would help, decide how to divide the task, and choose an appropriate way to approach it.

Lambert’s reconstruction of the path from Q* to Strawberry to o1 emphasized the effort required to establish new behaviors. In his account, OpenAI spent twelve to eighteen months developing initial reasoning traces, with human data helping make backtracking and verification reliable. He used that interpretation of reasoning-model development to motivate a comparable effort for planning, rather than presenting it as a disclosed training recipe.

Planning demonstrations may be easier for experts to produce. Writing a convincing 10,000-token reasoning trace with backtracking is awkward; writing a good five-to-ten-step plan, or checking a model-generated plan, is a more natural expert task.

The proposed training path is therefore concrete: collect initial planning demonstrations, apply supervised fine-tuning (SFT) to teach those behaviors, and then investigate whether reinforcement learning on larger tasks reinforces useful planning styles. The last step remains a research question. A model can learn to emit a plan without necessarily learning which plans lead to successful execution.

Lambert also suggested adding more structure to the output sequence. Reasoning models already distinguish thinking from answering; a hypothetical extension would be plan → think → answer. The purpose would be to choose an approach before committing a large reasoning budget. This was a proposed training structure, not an implemented API.

The CoastRunners example shows a strong individual skill: recovering niche information when the user cannot remember the right search terms. A research task asks for more than that one successful retrieval.

Lambert contrasted excellent Deep Research results with disappointing ones and attributed some of that inconsistency to missing planning ability. An electronics-purchase recommendation makes the gap tangible. A model may be good at finding facts yet still fail to gather the right information or investigate the alternatives thoroughly enough to justify a recommendation.

Reliable coverage requires decisions about both what to investigate and how much effort each part deserves. Search supplies information; planning determines whether the collected information is sufficient for the task.

The boundaries between strategy, abstraction, and context management need not be rigid. Lambert’s purpose was to decompose the training problem: identify the behavior that is missing, then ask what data or algorithmic method could teach it. The taxonomy is useful insofar as it makes those research choices more specific.

Lambert used o1 Pro as an example of robustness and was still anticipating o3 Pro. He distinguished two possible benefits of additional computation: making a previously unsolved task solvable, and making an already available capability more reliable or producing a better-crafted answer.

His interpretation was that reinforcement learning could encourage exploration, while additional parallel computation could help exploit the approaches available to the model. This was an intuition about how compute might improve results, not an account of the products’ internal architecture. Parallel work could be valuable when robustness mattered, but it would not solve every limitation or replace the need for new capabilities.

Continual learning raises a larger possibility: repeatedly update a model through long-horizon tasks, potentially reducing its dependence on pretraining. Lambert saw an unresolved algorithmic bottleneck there. Scaling reinforcement learning further was, in his view, a more immediate and tractable direction.

For his work at the Allen Institute for AI, or Ai2, he reduced the practical reasoning-model research plan to a small number of priorities.

1. Collect questions with verified answers. Seek coverage across domains, while recognizing that much of the available data is math and code.
2. Filter by difficulty relative to the base model. Lambert’s illustrative extremes were questions solved zero times in 100 attempts or 100 times in 100 attempts. He argued that both waste computation and make RL updates noisier. The useful training set depends on what this particular starting model can sometimes, but not always, solve.
3. Build a stable RL run. Train over the selected questions with infrastructure that allows sustained improvement. Suitable data and reliable training are the foundation of the recipe.

Only after those foundations are working does Lambert turn to refinements such as overlong filtering, changes to clipping, or resetting the reference model. He characterizes their contribution as a few additional percentage points on top of a working run, rather than a substitute for good data and stable infrastructure. The practical decision rule is to fix the data and training loop before expecting an algorithmic adjustment to rescue the run.

The closing provocation was whether post-training should simply be called training. Lambert offered a conditional calculation: suppose o1’s post-training used 1% as much compute as its pretraining, then apply the 10× increase he reported for o3. On that assumed baseline, the result would be roughly 10%, not parity. Reaching comparable pretraining and post-training GPU-hours would require further growth.

The point of the scenario was the changing scale of the investment. A phase once treated as a small addition could become a substantial part of the training budget.

For DeepSeek-V3, Lambert cited a post-training share of 0.18% of GPU-hour compute and described pretraining as taking approximately two months.

Editor: The DeepSeek-V3 Technical Report, v2, reports 5,000 post-training H800 GPU-hours out of 2,788,000 total GPU-hours, or about 0.18%. This is the reported final training run, including context extension; research and ablation costs are excluded.

The basis for his DeepSeek-R1 comparison was different. Lambert recalled a deleted researcher tweet saying that R1 training took a few weeks. Assuming that RL used the same entire cluster, he tentatively estimated a 10–20% compute share. He explicitly regarded that assumption as strong and probably inaccurate, so the estimate should be read as his speculative comparison, not a DeepSeek-disclosed training cost.

He also noted that DeepSeek’s pretraining infrastructure might be substantially more efficient than its RL infrastructure. Elapsed duration alone cannot settle the compute comparison when cluster allocation and implementation efficiency differ.

The research direction is to spend that growing RL budget on models that can carry out longer plans: break a task into parts, decide how to approach those parts, and solve them with the resources available. That makes autonomous decomposition a training objective alongside the reasoning skills that made the first wave of applications possible.