2026 Frontier Map

01Intuition

Pretraining spends the same compute on "what's the capital of France" as on "prove this theorem." That is the problem.

Every large model has a fixed amount of knowledge and skill baked in by pretraining and fine-tuning. Call this raw competence. Historically the way to get more of it was to make the model bigger, train on more data, or both, all before it answers a single question.

That has a ceiling problem. Pretraining compute is a sunk, fixed cost. The model cannot tell in advance which questions deserve more effort, because by the time it is answering, all the training compute has already been spent.

Agentic systems apply that same "spend adaptively" idea one level up. Rather than forcing a single model call to plan, execute and self-correct all at once, split those into separate steps a system can run in a loop. Stop early on easy tasks. Iterate longer on hard ones.

Multimodal and embodied frontier work is a different kind of adaptation: reusing a capable pretrained backbone for a new input or output modality, like video or robot actions, instead of learning that modality from zero. The expensive part, broad world knowledge and reasoning, transfers. Only the comparatively cheap part, how to perceive or act in the new modality, needs learning fresh.

One way to get more from a model at test time is to ask it the same question many times and take the majority answer. Suppose each attempt is right 60% of the time and the attempts are independent.

import numpy as np

rng = np.random.default_rng(0)
p = 0.6                                   # chance one attempt is right

for k in (1, 5, 15, 51):
    votes = rng.random((100_000, k)) < p  # k independent attempts
    majority = votes.sum(axis=1) > k / 2
    print(f"{k:>2} attempts, majority vote: right {majority.mean():.1%}")

02Timeline

• Chain-of-thought prompting (2022) showed that asking a model to think step by step improved accuracy on multi-step problems with no architecture change, which raised the question of spending more compute on that scratch space and picking the best result. That became test-time-compute scaling and process-supervised verifiers (2023–2024).
• In parallel, RLHF and instruction tuning (covered in 10) made models reliable enough at following instructions and calling tools to wire into agentic loops that act, observe a result and re-plan.
• This page covers five directions the field pushed on, each a response to a specific limitation of what came before, plus the problems none of them fixed. Page 11 covers the retrieval and single-step tool-use side.

03The landscape, in five directions

Reasoning & inference-time compute

The clearest instance of "spend compute per-query instead of upfront." Snell et al. formalize two mechanisms (see Go Deeper):

• Search against a verifier. Sample N candidate solutions, score each with a model trained to judge correctness, keep the best.
• Adaptive revision. The model iteratively refines its own draft, conditioned on the prompt.

The verifier is usually a process reward model (PRM), scoring each intermediate reasoning step as well as the final answer. Lightman et al.'s "Let's Verify Step by Step" showed the difference: process supervision caught errors that outcome supervision let slip through, because a right final answer can hide a wrong method that happened to land correctly.

Agentic systems

Page 11 already covers the core loop: reasoning, a tool call, an observation, repeat (ReAct). This page's addition is what changes when that loop runs for a long horizon. Picture a coding agent planning a multi-file change, writing code, running the test suite, reading the failure and retrying, possibly dozens of times.

That demands three things the single-step loop does not:

• Memory. It carries state across steps.
• Planning. Break the goal into sub-goals.
• Self-verification. Decide for itself when a sub-goal succeeded, which is more than running without crashing. This is the verifier idea from reasoning, one level up.

Toolformer (Schick et al., see Go Deeper) was an early demonstration that a model can learn when to call a tool, and with what arguments, from self-supervised examples instead of hand-scripted rules. This underlies how modern agent frameworks decide to reach for a calculator, a search engine, or a code interpreter.

The multimodal & efficiency frontier

Two threads, both pushing a capable backbone into new territory.

• Multimodal. Page 14 covers the bolt-on "encoder + projector + LLM" recipe versus training natively multimodal from the start. The frontier direction pushes native multimodality across more modalities at once (text, image, audio, video in one model), and toward generative video temporally consistent enough to function as an interactive world simulator rather than a short clip generator. A direct extension of the diffusion techniques in 12, applied across time as well as space.
• Efficiency. Mixture-of-Experts (Switch Transformers, see Go Deeper, covered in depth in 10) decouples total parameter count from per-token compute, so capacity can grow without inference cost growing at the same rate. Distillation and quantization (23) push the other way: take a large model's behavior and compress it small enough to run on-device.

Both chase the same goal, which is more capability per dollar of inference compute and less reliance on training compute.

The embodied & robotics frontier

Vision-language-action models (21) and world models used as learned simulators for planning (22) are the same "reuse a pretrained backbone" idea, applied to physical action instead of text or code. You start from a model that already understands images and language and fine-tune it to output robot actions as an additional token type, which beats training a control policy from scratch on a small amount of robot data.

Cross-embodiment generalization (21) pushes further, pooling data across many different physical robot bodies so a single policy transfers across them. The same logic that makes a pretrained language model reusable across many downstream text tasks.

AI for science

The clearest proof that a general architecture, plus the right training objective and enough of the right data, generalizes past language and images.

AlphaFold2 (Jumper et al., see Go Deeper) treated protein structure prediction as a geometric learning problem and reached accuracy that decades of physics-based simulation had not. It became Nature's and Science's Method of the Year for 2021 and, per the community assessments cited in follow-up literature, changed how structural biologists work day to day.

The same recipe of domain-appropriate architecture, a large corpus of structured natural data, and a well-chosen objective has since been extended toward molecule and materials design. Those domains are individually less mature than protein structure prediction, and remain active, unsettled research areas.

04The core mechanisms, precisely

This page spans too many sub-fields to have one shared equation the way a single-architecture page does. But two mechanisms recur across almost everything above, so they are worth stating exactly.

Best-of-N with a verifier. Given a prompt, sample N candidate completions from the model, independently and usually at temperature > 0 so they differ. Score each with a verifier V and return argmax_i V(candidate_i).

The verifier can be a separate trained model, such as a PRM scoring each reasoning step. In simpler setups it is a rule-based checker: does the code compile, does the final answer match a known constraint.

The core tradeoff is that larger N costs inference compute linearly, while accuracy gains are sublinear and eventually flatten. This is the compute-optimal allocation problem Snell et al. study: for a fixed budget, is it better to spend on more samples, or on letting one sample think longer?

Sparse routing (Mixture-of-Experts). A router network computes, per token, a score over a bank of expert feed-forward networks. Only the top-k highest-scoring experts, commonly k=1 or k=2, process that token. The rest contribute nothing to that token's forward pass and cost nothing for it.

Total parameter count can scale with the number of experts, while compute per token stays pinned to k experts' worth of work. This is why sparse models can hold far more total parameters than a dense model trained at the same per-token compute budget. See 10 for the training-time complications this introduces, like load balancing across experts.

05Why this direction

Snell et al.'s headline result makes the tradeoff concrete. Under a matched compute budget, their compute-optimal test-time strategy let a smaller model outperform a roughly 14× larger model, on problems where the smaller model already had some non-trivial baseline success rate.

Why agentic decomposition? A monolithic model has to implicitly learn arithmetic, retrieval and code execution as internal skills, imperfectly, from training data. Routing each to an actual calculator, search index or code interpreter does that sub-task exactly. And a wrong tool call is visible and debuggable in a way a wrong internal computation buried inside a forward pass is not.

06Complexity, failure modes, and the persistent open problems

Inference-time search inherits a classic optimization failure mode: reward hacking against the verifier. Every verifier is imperfect to some degree. Aggressive search can find a candidate that scores well under the verifier without being correct, the same way an RL policy can learn to exploit a misspecified reward function (15).

The perverse part: the more compute you spend searching, the more thoroughly you search for exactly this kind of exploit. Whether you meant to or not.

Agentic loops inherit a different one: compounding error over long horizons. Say an agent's per-step success rate is 95% (illustrative number, not a benchmark result) and a task takes 50 sequential steps. If errors are independent, the probability every step succeeds is roughly 0.95^50 ≈ 7.7%.

So long-horizon reliability is the bottleneck for autonomous coding, more than per-step accuracy. Self-verification at intermediate steps matters far more here than in a single-shot model call, because it catches an error at step 12 before it surfaces at step 50.

And then there is the honest list. These problems carried over unchanged from 2023, and none of the directions above solved them:

• Reliability. Models are still confidently wrong at a non-trivial rate. Inference-time compute reduces this but does not eliminate it.
• Grounding. Tying a claim to verifiable evidence and not to a fluent-sounding guess. See hallucination and groundedness in 25.
• Long-horizon planning. The compounding-error problem above, unresolved for long, ambiguous real-world tasks.
• Evaluation. Benchmark contamination and the weaknesses of LLM-as-judge (25) get worse as models get better at sounding right.
• Cost. Inference-time compute trades money and latency for accuracy directly. There is no free lunch in that trade.
• Safety and controllability. An agent that can execute code and call tools has a much larger blast radius when it does the wrong thing than a model that only outputs text.

None of this is a reason for pessimism about the field; it is the current research agenda. Naming these problems specifically gives a more informed answer than gesturing vaguely at "AI safety."

07Build this

Every claim on this page rests on one curve: accuracy against sampling budget. You can measure it yourself in an afternoon, and the shape it comes out is more informative than any summary of it.

Where this runs in production

An autonomous coding agent, given a bug report, runs a loop:

• Plan. Identify likely files, form a hypothesis.
• Act. It writes a code change.
• Verify. Run the existing test suite.
• Revise. If tests fail, read the failure output and try again. Loop until tests pass or a step or time budget is exhausted.

This is the agentic loop from section 03, with the test suite standing in as an automatic, domain-specific verifier. It has the same "generate, verify, keep or retry" shape as best-of-N sampling in section 04, spread across sequential steps instead of parallel samples. And it inherits the compounding-error risk from section 06 whenever a multi-file change needs many sequential correct steps.

08Interview questions

09Go deeper

●Now write it yourself

Reading the derivation and being able to produce it are different skills. These are Deep-ML problems that exercise what this page covers — each one is checked against real test cases, not multiple choice.

Matched to this page from Deep-ML's catalogue of 1,380 problems. More at deep-ml.com, and Where to practise covers the other platforms and what each one trains.

10Related pages