What Comes Next: Honest Uncertainty

This is the last post in the series. If you read it in order you walked from vectors and spaces up to agent protocols, so you have a working mental model of the whole stack. The point of this post is to turn that model on the frontier itself and try to be honest about what I think I know and what I don't.

Nobody really knows what happens next. The honest answer to "what do LLMs look like in 2027" is a shrug and a list of conditional bets with confidence intervals attached. I'd rather write down those bets explicitly than try to land a clean closer.

So that's what this post is. Four live frontiers, a few questions the field can't answer yet, and a confidence matrix at the end that tries to be specific about which claims I'd take bets on and at what odds.

The problem

A lot of announcements from frontier labs frame each new result as a phase transition. Some of them are. Some are linear extrapolations that have already started to bend. Without a mental model of the stack, telling the two apart is hard.

The goal of this post is to take four specific directions the field is pushing on (test-time compute, multimodal-native, world models, the compute wall), look at each one with the same lens we've used all series, and then end with a confidence matrix that tries to be specific about which cells I can fill in and which I can't.

Capability on the y-axis, cost per query on the x-axis. Every paradigm has a ceiling. The story of 2020-2026 is three paradigms stacking: pretrain-only, then pretrain plus RLHF plus tools, then the current one that adds test-time compute on top. Each one lifted the ceiling. "What comes next" is really the question of which paradigm lifts it again, and by how much.

Prerequisites

This is the last post, so technically everything in the series is fair game. The specific pieces I'll lean on most:

• Matmul and the activation/parameter split. If you know the atom a forward pass is made of, you know what "running a bigger model" actually costs.
• Decoding and the one new row. Test-time compute is all about what you do during decode, not training.
• RLHF and DPO. The reasoning-model wave uses reinforcement learning on top of a pretrained base, and the training signal matters.
• Retrieval and context engineering. The question "are we out of data" only makes sense once you know where the data goes.
• Tools and agent loops. A lot of "AGI by 2027" claims are really claims about what a tool-augmented loop can do.

If any of those feel fuzzy, the links back into the series are in the sidebar.

Frontier 1: test-time compute

The simplest way to describe what happened with o1 and o3 and their open-weight cousins is that somebody figured out how to spend inference compute the way we used to spend training compute. Instead of making the model bigger, make it think longer.

The mechanics are familiar once you see them. You draw more samples, or you search over possible chains of thought, or you generate and then verify, or you train a separate verifier and run best-of-N against it. All of these are ways of converting GPU-seconds at decode into accuracy.

What makes it a genuine new axis is that the returns, at least for now, look loglinear in compute. Snell et al. showed this pretty crisply on math benchmarks: double the samples, get roughly the same absolute accuracy gain each doubling, up to a saturation point that depends on the task. It looks like a scaling law, except the compute you're scaling is at inference time, and you can spend it on a per-query basis instead of baking it into the weights.

Drag the slider. The shape is what I want you to internalize, not the specific numbers (those are illustrative). The saturating loglinear curve with a task-dependent ceiling shows up over and over again.

Here's where the nuance lives. The curve has a ceiling. Every task has a point past which sampling more doesn't help, because the model either doesn't know the answer or can't verify it when it sees one. On math, the ceiling is high because we can check the answer. On open-ended reasoning, the ceiling is lower because we can't. Best-of-N against a verifier only works if the verifier is trustworthy, and verifiers trained on one distribution often fail on another.

The minimal math, for anyone who wants it: for best-of-N with a noisy verifier, the expected accuracy is roughly

where $p_{\text{correct}}(N)$ is the probability that any one sample is correct, and $\epsilon(N)$ is the verifier's false-positive rate at scale. The $p_{\text{err}} \cdot \epsilon(N)$ term is the reason scaling N can't save you forever: if your verifier fires on wrong answers even 1% of the time, a large enough N eventually lands you on a confident mistake.

Here's the tiny Python version of the idea, so you can see the whole loop:

import random
 
# Pretend "model" that samples answers to a math question.
# The correct answer is 42. The model gets it with probability 0.35.
def sample_answer():
    return 42 if random.random() < 0.35 else random.choice([41, 43, 420, 7])
 
# Pretend verifier: scores a candidate answer. Imperfect — 8% false positives.
def verifier_score(candidate):
    if candidate == 42:
        return 1.0
    # a wrong answer gets a high score 8% of the time
    return 0.95 if random.random() < 0.08 else random.uniform(0.0, 0.4)
 
def best_of_n(n):
    samples = [sample_answer() for _ in range(n)]
    scored = [(verifier_score(c), c) for c in samples]
    scored.sort(reverse=True)  # highest-verified first
    return scored[0][1]
 
# Sweep N and estimate accuracy
random.seed(0)
for n in [1, 2, 4, 8, 16, 32, 64, 128]:
    correct = sum(1 for _ in range(2000) if best_of_n(n) == 42)
    print(f"N={n:>3}  acc={correct/2000:.3f}")
# acc rises fast at small N, then tops out below 1.0 because of verifier FPs

Try running that in your head. At N=1 you're stuck at the raw model accuracy. At N=4 or N=8 you'll see a big jump. Past N=32, the verifier's false positive rate starts dominating and you stop getting free capability. That's the honest shape of test-time compute scaling. It's a real and genuinely new axis, and it has a limit.

The open question: does that limit move over time, or is it structural? If the verifier gets better (because we train it on more and better data, or because we use a more capable base model as the verifier), the curve lifts. If verification turns out to be fundamentally as hard as generation for important tasks, we hit a wall and the reasoning-model wave stops being the growth story.

I genuinely don't know which one it is. Neither does anyone else right now. That's a real open question, not a polite deflection.

Frontier 2: multimodal-native

The second frontier is easier to describe and, I think, a more obvious win.

For most of the LLM era, the way you got multimodal behavior was by bolting a vision encoder onto a language model and teaching the two to talk across an adapter. CLIP-style encoders plus an LLM decoder was the dominant pattern. It worked well enough to be useful. It never felt native.

Multimodal-native models are the alternative: train from the start with text, image, video, and audio flowing through the same transformer, sharing a single latent space. Gemini's line of models moved decisively in this direction, and by 2026 the rumors about the next generation of frontier systems are that they are natively multimodal across all four modalities from pretraining. The empirical story is that these models do substantially better on cross-modal reasoning (looking at a chart and writing a caption that uses numbers from the chart, watching a video and summarizing its causal structure) than stitched-together pipelines did.

This one I'm pretty confident about. The reason is mechanical. If you've internalized the residual stream view of a transformer, you know that "meaning" in one of these models lives in vectors in a shared space. If every modality shares that space from the start, cross-modal operations are the same kind of attention the model does inside a single modality. There's no impedance mismatch between a "vision feature" and a "text feature," because the model never learned them as separate kinds of thing.

The nuance is that multimodal-native doesn't automatically mean "best at every modality." A model trained on a blend of text, image, video, and audio has a finite capacity budget, and specializing a separate model for a single modality can still beat it on narrow tasks. That's fine. The claim isn't that generalists replace specialists. The claim is that the generalists are the ones that move the overall frontier, because they compose the modalities natively and agent loops end up calling them for anything that crosses a modality boundary.

I'll put this one in the "we know: yes" column in the matrix below, for the specific claim that multimodal-native architectures win on cross-modal tasks. The broader claim that they replace specialists for everything I'll put in "we know: no."

Frontier 3: world models

Now the hard one.

The phrase "world model" gets used in at least three different senses, and the conversation gets confused because people don't agree on which one they mean. I'll try to be specific.

Sense 1: a latent variable model, trained on video or embodied experience, that learns to predict future sensory states. This is roughly what Ha and Schmidhuber meant originally, and what DeepMind-style video-generation work has been pushing.

Sense 2: an internal model of causality and physics that a language model has implicitly learned by reading the internet, such that it can reason counterfactually about actions and consequences without being told.

Sense 3: Yann LeCun's vision of JEPA-style architectures that learn predictive latent representations of the world and use them as the substrate for planning, explicitly positioned as an alternative to autoregressive LLMs.

These are different claims with different evidence. The first is an architectural choice that's starting to work on specific domains (video prediction, embodied agents in simulation) and has very little to do with LLMs as currently constituted. The second is an empirical question about what autoregressive LLMs trained on internet text have actually learned, and the answer is "some, in some places, unreliably." The third is a research program that is far from demonstrated at frontier-model scale, though its advocates argue the current paradigm won't generalize without something like it.

Chollet's argument in On the Measure of Intelligence sits next to all of this. His claim, roughly, is that intelligence is skill-acquisition efficiency given priors and experience, not raw skill. ARC-AGI is his attempt to build a benchmark that tests for that. As of late 2025 and into 2026, o3-style test-time-compute models posted large gains on ARC-AGI, which some people took as a signal that we were close to general intelligence. The more careful reading is that they found a way to brute-force the specific kind of pattern search ARC tests for, and that we're still learning whether the same approach generalizes to truly novel problem structures.

So where does that leave "world models"? In the column of "we don't know" for most of the specific claims. We don't know whether LLMs are going to need an explicit physics/causality module bolted on, or whether a big enough multimodal-native model plus enough test-time compute plus enough interaction data will get there. LeCun has a bet and it's a reasonable bet. The counter-bet (that the current paradigm plus scale keeps working) is also reasonable. The honest posture is to hold both as open.

Frontier 4: the compute wall

Now the less romantic frontier. Money and atoms.

The bars above are to scale. GPT-3 used about 300 billion tokens. Chinchilla moved us to about 1.4 trillion. LLaMA 2 pushed to 2 trillion. LLaMA 3 jumped to about 15 trillion. Frontier runs in 2025-26 are estimated in the 20-40 trillion range. Villalobos et al. estimated the stock of high-quality, public, English-language web text at roughly 4-9 trillion tokens in 2022, with total human-generated public text in the hundreds of trillions. Frontier pretraining is already consuming a meaningful fraction of the available high-quality stock.

The word "wall" is doing a lot of work here, so let me be careful about what it actually means.

It does not mean "we're about to run out of text and models will stop improving." That framing is too tidy. There's multilingual text, multimodal data, synthetic data, private enterprise data, code, and simulation. Each of these has its own stock and its own quality profile. The Villalobos estimate is the English public web piece specifically, and even that has fuzzy boundaries depending on how you count "high-quality."

What it does mean is that the cheapest, most obvious axis (scrape more of the same kind of thing) is hitting diminishing returns, and the field has started actively pivoting to synthetic data pipelines, multimodal corpora, and curated private sources. That pivot is real and it's visible in how frontier labs talk about their training runs.

There's also the non-data side of the wall. Power, fab capacity, memory bandwidth, interconnect. Every one of those scales slower than the "just add more H100s" story implies, and every one of them has regulatory and supply-chain friction that doesn't go away with engineering. A 2027 run that's 10x the compute of a 2024 run is not just money; it's electrical substations and cooling water rights and export controls.

I don't have a confident forecast here. I do think the naive scaling extrapolation (where we casually talk about 100x or 1000x more compute by the end of the decade) is the least-likely scenario to actually happen on schedule, because the physical world has a lot of speed limits that the loss curve doesn't know about.

Things the field cannot yet answer

Now the part I've been building up to: the questions that are genuinely open, where the right thing to do is sit with them rather than resolve them prematurely.

• Do these models understand anything? This is a philosophy question pretending to be an engineering question, and both halves are interesting. There's no agreed-upon operational definition of "understanding" that distinguishes a 2026 frontier model's behavior from the folk-psychology version of the word. That doesn't mean the question is meaningless. It means we haven't built the measurement.
• Can current alignment techniques scale? Ngo et al. laid out the specific failure modes we should worry about as capability scales. None of those failure modes have been closed. RLHF, DPO, Constitutional AI and their descendants work well at the current capability tier. Whether they keep working at 10x or 100x the capability is an open empirical question with very asymmetric downside.
• What counts as a "reasoning" model? Right now, "reasoning" is an umbrella term for "the model uses more inference compute and gets better at certain benchmarks." That's a useful shorthand but it's not a definition, and the eval methodology is still catching up to what we're actually measuring. Chollet's framing is the most rigorous attempt I know of.
• How much of 2026 agent behavior is robust, and how much is a demo? You can get striking agent videos by cherry-picking trajectories. The honest distribution is much lumpier. Long-horizon planning past a few dozen steps, with recovery from real failures, is still not reliably solved. MCP and the provider-side agent primitives are making the plumbing better; the underlying cognition is still the bottleneck.
• What's the right mental model of consciousness, if any? I don't think I can give you anything here. I just want to acknowledge that the question is real and that nobody, including the frontier labs, has a credible operational answer.

The grid above is what I want you to take away from this post. I want the columns to become a habit. When you read a claim, ask which bucket it's in. "We know: yes" claims should have falsifiable evidence behind them. "We know: no" claims should have a concrete reason. "We don't know" is the column where most exciting claims actually live, and saying so out loud is more useful than filling it in with a confident guess. "We can't say" is the column for claims that are underspecified or where the relevant evidence is genuinely proprietary, and it deserves its own column so we don't conflate it with the other three.

Misconceptions

"Test-time compute is a solved new scaling axis." The returns are real and the paradigm is new. Calling it "solved" is premature. The curve saturates, the saturation point is task-dependent, and a lot of the early wins came from benchmarks (math, competitive programming) where verification is cheap. Generalizing to domains where verification is harder is an open problem.

"AGI is around the corner because o3 hit X on ARC-AGI." ARC-AGI is a benchmark, not a definition of general intelligence. Chollet was explicit about this when he introduced it. A model scoring well on ARC with massive test-time compute is informative, but it's not a phase transition. The right response is to look at which kinds of novelty the model generalizes to, which it doesn't, and how the gap closes.

"Multimodal-native means one model can't do anything specialized well." This is the mirror of the hype version. Multimodal-native models usually underperform narrow specialists on narrow tasks, but they win at everything that crosses modalities and they are what agent loops end up calling. The right framing is layered: generalists on the outside, specialists when the task is narrow enough to justify.

"We're out of pretraining data." Not quite. The cheap, obvious, English-public-web axis is hitting diminishing returns. The broader space (multimodal, multilingual, private, synthetic) is not out. The interesting question is which of those sources pay off at scale and which don't, and that's an empirical question that will get answered over the next 18-24 months.

On the frontier, as of April 2026

o3-style reasoning models in production. By mid-2025 the provider APIs started exposing dedicated reasoning models with per-query compute budgets that callers can dial up and down. The useful pattern, which falls straight out of the test-time compute picture above, is to route cheap questions to a standard model and expensive/high-stakes questions to a reasoning model with a larger compute budget. Most frameworks (OpenAI Responses, Anthropic's message-level reasoning controls, Gemini's thought signatures) expose this as a first-class surface by now.

The multimodal-native frontier. The 2026 generation of frontier models is, by most signals, natively multimodal across text, image, video, and audio. The public system cards are careful to hedge, but the architectural rumors (shared encoder, single latent space, training-time mixing of modalities at the pretraining stage) have been consistent enough across labs that it's probably the right mental model. Cross-modal tasks (look at a video, write a spec; listen to a call, draft a reply) are where these models open the biggest gap on the stitched-pipeline approach.

The data-mix arms race. Frontier pretraining mixes have become one of the most commercially sensitive pieces of the whole stack. Synthetic data pipelines (sometimes distilled from larger models, sometimes generated via tool loops, sometimes both) are doing real work at the top of the curve. Private enterprise data (code, logs, internal documents that partner companies license in bulk) is the other growth area. This is a quiet part of the field because nobody wants to tip their hand, but it's where a lot of the differentiation between 2026 frontier models actually lives.

Where I'd place bets, and where I wouldn't

A few specific forecasts so I can be wrong in public later.

I'd take a bet that multimodal-native wins on cross-modal tasks in production by end of 2027. The architectural reasoning is clean, the public benchmarks already lean this way, and the labs have been consistent about where they're headed.

I'd take a smaller bet that test-time compute keeps scaling on tasks with cheap verification (math, code, structured reasoning) through 2027, and a much smaller bet that it generalizes to open-ended tasks without a separate breakthrough on verification. The verifier problem is load-bearing and I don't see it solved yet.

I would not take a bet on any specific AGI timeline. I'd bet against the naive compute-scaling extrapolation hitting its 2027 milestones on schedule, mostly because substations and fab capacity move slower than loss curves do. I'd bet against the claim that current alignment techniques scale to capability levels 10x beyond today's without new work, though I think the work is happening.

The map I wanted to give you is in the eleven arcs before this one. If a piece of it still feels fuzzy, the one new row and the agent loop are the two I'd point to as the leverage points for understanding almost every frontier claim you'll read over the next couple of years. Test-time compute is a decoding story. Agent behavior is a loop story.

The full series index is here if you want to jump around, and the about page has contact info if you want to push back on anything I wrote.

A closing note

This is the last post. If you started at vectors and spaces and walked all the way up, thank you. That was the point of writing it, and I'm glad you were on the other end.

Writing this series changed how I think about the stack more than I expected it to. A lot of the mental models I thought I had turned out to be the vague shapes of mental models, and sitting down to write each post in a form sticky enough to teach was the thing that made them real. If anything lands the same way for you, then this worked.

The reason I didn't link to a "next post" in this one is that there isn't one. The series is a closed loop, dependency-ordered, and the frontier it ends on is genuinely uncertain, which is the right note to end on. If you want to keep going, the honest answer is: pick a piece of the stack that still feels fuzzy, open the primary source, and trace it yourself. That's what I did. It's what the about page describes more carefully. And it's the only method I actually trust to build intuition that sticks.

See you on the frontier.

Additional reading (and watching)

• OpenAI. (2024). o1 system card. And the subsequent o3 system card (2025). The public anchor for the reasoning-model wave.

• Snell, C., et al. (2024). Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters. arXiv:2408.03314. The empirical backbone for the test-time-compute scaling claim.

• Radford, A., et al. (2021). Learning Transferable Visual Models From Natural Language Supervision. arXiv:2103.00020. CLIP, the reference for stitched-encoder multimodal architectures.

• Google DeepMind. (2023-2025). Gemini technical reports. The clearest public example of the multimodal-native design philosophy at frontier scale.

• Ha, D. & Schmidhuber, J. (2018). World Models. arXiv:1803.10122. The "latent-variable predictive model of the world" flavor of the term.

• LeCun, Y. (2022). A Path Towards Autonomous Machine Intelligence. The JEPA position paper, arguing that autoregressive LLMs alone won't get us to planning and that predictive latent world models are needed.

• Chollet, F. (2019). On the Measure of Intelligence. arXiv:1911.01547. The measurement-theory paper behind ARC and ARC-AGI. The most rigorous published attempt to pin down what "general" means.

• Villalobos, P., et al. (2022). Will We Run Out of Data? An Analysis of the Limits of Scaling Datasets in Machine Learning. arXiv:2211.04325. The source for the ~60T upper-bound estimate on high-quality English public web text.

• Ngo, R., Chan, L., & Mindermann, S. (2022). The Alignment Problem from a Deep Learning Perspective. arXiv:2209.00626. The most careful existing catalog of failure modes current alignment techniques may or may not handle at scale.