How the machines got here. A milestone is a thing that happened: a model, a system, a result. A technique is an idea that moved the ceiling, with what it relied on and what it later enabled, so the dependency graph can be walked in both directions. A benchmark is how the field measured itself, and how fast each yardstick broke.
Five stacked engines, each only worth building once the one below existed: differentiable computation at scale (backpropagation, SGD, the tricks that make depth trainable); a general parallel sequence architecture (the transformer); scale on a self-supervised objective (next-token prediction plus scaling laws plus sparsity and efficiency work); post-training that turns a text predictor into an assistant (instruction tuning, RLHF); and reasoning bought at inference time (chain-of-thought, then reinforcement learning against verifiable rewards). Since 2025 a sixth engine dominates: agents acting in environments with real feedback, which is also the only known source of fresh training signal at scale. One pattern recurs through all of it: every large jump found a new cheap verifier, from the corpus checking itself, to reward models, to unit tests, to the Lean kernel, to task completion in a real environment.
show:
111 entries
1943 1950 1951 1956 1958 1982 1986 1989 1992 1997 2006 2007 2009 2010 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
A neuron modelled as a binary threshold unit, and a proof that networks of them compute arbitrary logical propositions. The founding assumption of every neural network since: cognition can be reduced to computation over simple uniform elements.
Replaced "can machines think?" with the imitation game, and argued that machine intelligence should be learned, from a child-machine trained up, rather than programmed. An operational success criterion and a research direction, before any hardware could run either.
Estimate the gradient from a small random sample instead of the whole dataset. The estimate is noisy but unbiased, so with a learning-rate schedule whose sum diverges and whose squared sum converges, the iterates still reach a stationary point.
θ ← θ − η_t · ∇L(θ; minibatch)
The consequence is structural: cost per update decouples from dataset size, so training time scales with the number of updates you need rather than the corpus. That single fact makes training on trillions of tokens possible. The noise also acts as an implicit regulariser, which is why large-batch training needs learning-rate tricks to match small-batch generalisation. Momentum (Polyak 1964, Nesterov 1983) low-pass filters the gradient so oscillating directions cancel, and let plain SGD train deep autoencoders once thought to need second-order methods.
Named the field and set the symbolic search-and-logic agenda that dominated for thirty years. Newell and Simon demonstrated the Logic Theorist there, the first program to prove theorems.
The first trainable pattern classifier with a convergence guarantee, built as a physical machine with a 400-photocell array and motor-driven weights. Also the first cycle of AI press over-promise and backlash. Minsky and Papert's 1969 book proved single-layer perceptrons cannot represent XOR and noted no training algorithm for multi-layer networks was known; it was read as a verdict on the whole connectionist programme and helped defund it for fifteen years.
A recurrent network of threshold units with symmetric weights has an energy function whose minima act as content-addressable memories. It recast neural computation in the language of statistical physics, brought physicists into the field, and led to Boltzmann machines (Ackley, Hinton, Sejnowski, 1985), the first learning rule for hidden units. Both were cited in the 2024 Nobel Prize in Physics.
Reverse-mode automatic differentiation applied to a layered network: run the forward pass caching activations, then push the derivative of the scalar loss backwards through the graph by the chain rule.
δ = ∂L/∂y · f′(a) # a = Wx + b, y = f(a)
∂L/∂W = δ xᵀ
∂L/∂x = Wᵀ δ # handed to the previous layer
The decisive property is cost. The gradient of one scalar with respect to all N parameters costs a small constant multiple of one forward pass, where finite differences would cost N forward passes. That asymmetry is why parameter counts could go from thousands to trillions without the optimisation method changing. If gradients cost O(N), no scaling law exists. The 1986 paper's own headline was that hidden units learn useful internal representations, the first credible answer to Minsky and Papert.
Replace a dense layer's independent weights with one small kernel applied at every position. Parameter count decouples from input size, each output depends on a local receptive field so cost is linear, and translating the input translates the feature map, the right prior for images. LeNet-5 read a sizeable fraction of US bank cheques in the late 1990s, the first industrially deployed deep network.
The idea that outlived convolution is weight sharing as a structural prior: the same function applied to every element of a structured input, so the network learns the function rather than one function per position. Self-attention is the same trick with a data-dependent sharing pattern.
A network trained by temporal-difference learning purely from self-play reached world-class backgammon and changed human opening theory. The template AlphaGo Zero would run at scale 25 years later: self-play plus function approximation, no human game records.
Custom alpha-beta search hardware evaluating 200 million positions a second with a hand-tuned evaluation. The first world-champion defeat in a canonical intellectual domain, by brute force and domain engineering rather than learning, which sharpened the argument that would drive the field back to learned systems.
A plain RNN multiplies its hidden state by the recurrent matrix every step, so gradients through T steps involve that matrix to the T-th power and vanish or explode. The LSTM adds a cell state updated by addition, guarded by learned sigmoid gates:
c_t = f_t ⊙ c_{t−1} + i_t ⊙ g_t # additive carry: constant error flow
h_t = o_t ⊙ tanh(c_t)
When the forget gate is near 1 the gradient path is near identity and survives hundreds of steps. Two ideas outlived the architecture: additive state updates reappear as residual connections across depth instead of time, and multiplicative gating reappears in gated feed-forward layers, mixture-of-experts routing, and the gated linear-attention layers of 2025–26 hybrids. LSTMs owned speech and translation from 2013 until the transformer.
Stacking restricted Boltzmann machines and training them greedily layer by layer gave a good initialisation that backpropagation could then fine-tune. It broke the belief that networks deeper than a few layers were untrainable and supplied the brand, "deep learning", under which the field secured a decade of attention. Within four years ReLU and GPUs showed the pretraining machinery had been a workaround for missing compute.
A C-like programming model exposing the GPU's parallel cores for general computation. Commodity graphics cards became the cheapest dense-linear-algebra machines available, the physical precondition for the deep learning era. Raina, Madhavan and Ng (2009) reported roughly 70× speedups training deep belief nets on GPUs.
Fourteen million images labelled via Mechanical Turk across 22,000 WordNet categories; the competition subset used 1.2 million images over 1,000 classes. It supplied the scale of supervised data without which AlexNet could not have happened, and made data a first-class research contribution. Saturated by about 2015.
max(0, x). Its derivative is exactly 1 on the positive half-line, so gradient magnitude does not shrink per layer, it yields sparse activations, and it costs one instruction. With saturating nonlinearities, depth beyond about five layers was untrainable without layerwise pretraining; ReLU plus good initialisation made plain supervised training of deep networks work and deleted a research programme overnight. Smooth variants (GELU, SwiGLU) are now standard in transformers.
Zero each unit with probability p during training, rescale at test time. Each minibatch trains a different thinned subnetwork from 2ⁿ that share weights, and inference approximates their geometric-mean ensemble; units cannot rely on specific partners, so features must be individually useful. It mattered most when models were large relative to data. In modern pretraining, where each token is seen about once, dropout is set to zero and reintroduced only for small fine-tunes. A technique whose usefulness depended on the data regime.
A 60-million-parameter, eight-layer CNN on two GTX 580 GPUs won ImageNet 2012 with 15.3% top-5 error against 26.2% for the runner-up. The single most consequential empirical result in modern AI: it ended hand-engineered computer vision in about eighteen months, moved the field to GPU-trained deep networks, and began NVIDIA's transformation into an AI company.
Learn a dense vector per word by predicting its context, with the expensive vocabulary softmax replaced by negative sampling:
L = −log σ(v_c · v_w) − Σ_{i≤k} log σ(−v_{n_i} · v_w)
Semantic relations appear as consistent vector offsets, king − man + woman ≈ queen, from an unsupervised objective. The payload is that meaning can live in a learned continuous space, and that a cheap self-supervised prediction task on raw text induces it. That is the seed of "next-token prediction is a general-purpose representation learner". Every LLM's token embedding matrix is its descendant.
One CNN trained with Q-learning, experience replay and a target network played Atari games from raw pixels, beating human experts on several. It unified deep representation learning with reinforcement learning, set the "one architecture, many tasks, raw sensory input" template, and got DeepMind acquired by Google a month later.
Generative modelling as a minimax game between a generator and a discriminator, with no explicit likelihood. The first sharp neural image synthesis, dominant until diffusion overtook it around 2021.
Fixed-vector encoder-decoders forced the whole source sentence through one bottleneck, and quality collapsed with length. Attention keeps every encoder state and, at each decoding step, computes a distribution over them from a learned compatibility score, then reads out the convex combination:
e_tj = a(s_{t−1}, h_j)
α_tj = softmax_j(e_tj)
c_t = Σ_j α_tj h_j
Soft, differentiable, content-addressed memory: the model learns what to look at. And the path length between any two positions is 1, so gradients flow directly from any decoder step to any encoder step. Once you notice the recurrence is now doing little work, deleting it is the obvious move. That move is the transformer.
One LSTM reads the input into a vector, a second generates the output from it, trained end to end on log p(output | input). Any task expressible as string to string can be trained by maximum likelihood on paired data with no task-specific architecture. That template is the ancestor of "everything is text-to-text" and of instruction following. First pure neural system to beat a mature statistical translation pipeline.
Exponential moving averages of the gradient and its square, bias-corrected, with a per-parameter step scaled by 1/√v:
m ← β₁m + (1−β₁)g ; v ← β₂v + (1−β₂)g²
θ ← θ − η · m̂ / (√v̂ + ε)
The update magnitude becomes roughly invariant to gradient scale, which matters in transformers where gradient scales differ by orders of magnitude between embeddings, attention projections and norm gains. One learning rate works across heterogeneous parameter groups, which is what made single-shot large runs feasible when you cannot afford a sweep. AdamW's decoupled weight decay is what actually ships. The cost is two extra states per parameter, which is why optimiser-state sharding exists. Default for essentially every language model from 2017 until Muon challenged it in 2025.
Normalise each channel over the minibatch to zero mean and unit variance, then apply a learned affine so the layer can undo it. Matched Inception's ImageNet accuracy in 14× fewer steps. The stated mechanism, "internal covariate shift", was later disputed in favour of loss-landscape smoothing; either way it permits much larger learning rates and made 50-plus-layer networks routine. Its dependence on batch statistics is what layer normalisation fixes.
Train a small student to match a large teacher's output distribution, softened by a temperature, rather than hard labels. The teacher's relative probabilities over wrong answers carry far more bits per example than a label. Modern practice often skips logits and distils on sampled teacher outputs, which is what "train on synthetic data from a bigger model" means, and what made reasoning distillation a commodity in 2025: a 7B model fine-tuned on R1 traces beats much larger non-reasoning models.
Start from bytes, repeatedly merge the most frequent adjacent pair into a new symbol, for a fixed number of merges. Frequent words become single tokens, rare words decompose into fragments, nothing is out of vocabulary. Unglamorous and enormously consequential: it sets the effective sequence length and hence attention cost, defines the atoms over which every probability is expressed, and its artefacts (digit tokenisation, multilingual cost) measurably change capability. Every scaling law, context window and price is denominated in its units.
Each block outputs x + F(x). The gradient path contains an identity term, so early layers get gradient undiminished at depth 100+, the LSTM's additive carry applied across depth instead of time; and adding a block cannot make the function class worse, since it can learn F ≈ 0. This solved the degradation problem where 56-layer plain networks trained worse than 20-layer ones. A 152-layer ResNet won ImageNet 2015 with 3.57% top-5 error, below the human reference. Every transformer block is x + Sublayer(norm(x)); without residuals, transformers of more than a few layers do not train. The "residual stream" reading underpins most interpretability work.
A non-profit with a billion dollars pledged, a stated mission that general intelligence benefit humanity, and an initial commitment to open publication. It produced GPT-1 through GPT-6, ChatGPT and the o-series, and via its 2019 capped-profit and 2025 public-benefit restructurings the dominant commercial model for frontier AI.
A supervised policy network on human games, improved by self-play, a value network, and Monte Carlo tree search, on a game with 10^170 states that had been the standing counterexample to search-based AI. Four to one in Seoul, watched by 200 million people; move 37 of game two was judged a genuinely new idea. The cultural inflection point for modern AI, especially in East Asia, and the direct trigger of China's national AI strategy.
An inference ASIC around a 256×256 8-bit systolic matrix unit, deployed for a year before it was announced and used in the Lee Sedol match. The first production accelerator outside NVIDIA and the start of the custom-silicon era: TPU v2 (2017) could train, and the seventh generation, Ironwood, underlies the Gemini 3 family and Anthropic's million-chip commitment. NVIDIA's V100 (May 2017) introduced Tensor Cores the same season; V100, A100, H100 and Blackwell trained nearly every other model on this page.
Normalise across the feature dimension of a single example rather than across the batch. No batch dependence, no train/test discrepancy, no trouble with variable-length sequences or batch size 1, all of which make it the right normaliser for autoregressive decoding. Placement mattered as much as the operation: post-norm needs warmup to be stable, pre-norm keeps a clean identity path and tolerates learning rates 2 to 10× higher. RMSNorm, which drops the mean, is what every open model since 2023 uses.
Replace one large feed-forward layer with N expert networks and a gate that routes each token to the top-k of them:
g = softmax(topk(x W_g + noise, k))
y = Σ_{i ∈ topk} g_i · Expert_i(x)
Parameter count decouples from FLOPs per token: hold 10 to 100× more parameters while each token pays for k experts. The costs are engineering, all-to-all routing traffic and gate collapse onto popular experts, fought with auxiliary balancing losses. Switch Transformer (2021) simplified to top-1 routing and reached 1.6 trillion parameters with a 7× pretraining speedup at equal FLOPs. Mixtral and DeepSeek made it the default frontier architecture in 2024.
Delete recurrence and convolution; build the whole model from multi-head self-attention, position-wise MLPs, residuals and layer norm.
Attention(Q,K,V) = softmax(QKᵀ/√d_k) V
block(x) = x + FFN(LN(x + MHA(LN(x))))
Three properties made it the architecture that ate the field. Parallelism: every position is computed at once in training, so the critical path is O(depth) rather than O(length), and the model class can absorb as much hardware as you can buy, which recurrence could not. Path length 1 between any two tokens. Data-dependent weight sharing: the same projections apply everywhere, but which positions interact is computed from content. The 1/√d_k keeps logits in the softmax's useful range; since the operation is permutation-equivariant, position must be injected separately. The KV cache, reusing keys and values across decoding steps, is an immediate corollary of causal masking and the single data structure that makes serving affordable; MQA, GQA, MLA and PagedAttention all exist to manage it. WMT'14 English–German at 28.4 BLEU in 3.5 days on eight GPUs, an order of magnitude cheaper than the models it beat.
For problems where no reward function can be written down: show a human two trajectory segments, ask which is better, fit a reward model to the comparisons with a Bradley–Terry likelihood, run RL against it, and keep collecting comparisons on the current policy so the model stays accurate where the policy goes.
P(σ₁ ≻ σ₂) = exp(Σ r(σ₁)) / (exp(Σ r(σ₁)) + exp(Σ r(σ₂)))
Two ideas carried forward: preferences are cheaper and more reliable to elicit than scores or demonstrations, and a learned reward model amortises human judgment into an unlimited-query oracle. So did the failure mode: optimise hard enough against the proxy and you find its errors rather than the human's intent, which is why a KL penalty to a reference policy is mandatory. A simulated backflip from about 900 bits of human feedback.
A first-order policy gradient that stays inside a trust region by clipping the importance ratio between new and old policy:
r_t = π_θ(a_t|s_t) / π_old(a_t|s_t)
L = E[ min(r_t A_t, clip(r_t, 1−ε, 1+ε) A_t) ]
Simple, tolerant of several epochs per batch, stable enough to leave running unattended, which is why it rather than anything theoretically nicer became the RL workhorse for language models. In RLHF the environment is degenerate (one action is one completion, reward at the end) and what survives is the clipped ratio plus a per-token KL penalty. GRPO is PPO with the value network deleted.
AlphaGo Zero surpassed the version that beat Lee Sedol after three days of self-play from random initialisation with no human data; AlphaZero reached superhuman chess in four hours with no domain-specific changes. The general principle is a two-timescale loop: a fast network proposes a policy, a slow expert (search guided by that network) spends inference compute to produce a better one at the visited states, and the improved policy is distilled back into the network.
loop:
π_expert = MCTS(π_θ, V_θ) # search improves on the raw policy
θ ← argmin CE(π_θ, π_expert) + (V_θ − outcome)²
Search at inference produces training targets better than the model that generated them, so you can iterate. Replace "tree search over board states" with "sample many chains of thought and keep the verified-correct ones" and you have STaR and reasoning RL. AlphaProof is this recipe with the Lean kernel as the game.
Pretrain a 12-layer transformer decoder on 7,000 books with the plain objective Σ log P(u_i | u_{<i}), then fine-tune the same network on each task with inputs serialised as token sequences and a linear head. State of the art on 9 of 12 tasks from one task-agnostic architecture.
The load-bearing claim is that next-token prediction is not a narrow language task but a universal objective: to predict the next token well across a diverse corpus you must implicitly model syntax, facts, arithmetic, code semantics and the author's intent. Every later capability is mechanically a by-product of compressing text. And because the supervision is free and unlimited, the binding constraint moves from labels to compute, which is the precondition for scaling laws to matter. ULMFiT and ELMo established transfer learning for NLP months earlier; BERT (October 2018) took the encoder branch with masked language modelling, dominated understanding benchmarks for years, and its masked objective resurfaced underneath dense retrieval and diffusion language models.
A 1.5-billion-parameter decoder on 40 GB of web text produced markedly coherent long-form text and usable zero-shot task performance. Two milestones at once: the first strong demonstration that scale alone buys zero-shot generality, and the origin of staged-release norms, since OpenAI initially withheld the full model citing misuse.
Over seventy years, general methods that convert compute into performance (search and learning) have consistently beaten methods built on human-encoded knowledge, because the value of hand-built structure is fixed while the value of a compute-scalable method grows with Moore's law. The human-knowledge approach usually wins in the short term, which is why people keep doing it. As a filter it licensed the GPT-3 bet, the abandonment of parsing pipelines, and the 2024 pivot to test-time compute. The caveat it is often misused to deny: general methods only work once someone finds their trainable form.
Christiano's recipe applied to GPT-2: humans compare pairs of continuations, a reward model initialised from the LM is trained on the comparisons, and the policy is fine-tuned with PPO against it under a per-token KL penalty to the pretrained model.
R(x, y) = r_ψ(x, y) − β · KL(π_θ(y|x) ‖ π_ref(y|x))
The KL term is not a detail: the paper documents a sign-flip bug that produced fluent, maximally obscene text. The decisive result came a year later in summarisation (Stiennon 2020): a 1.3B RLHF model was preferred to a 12B supervised one, and the 6.7B model's summaries were preferred to the human references about 70% of the time. Reward-model quality, not RL algorithm choice, turned out to be the binding constraint, and the overoptimisation curve, where the proxy keeps rising while true preference falls, was documented from the start.
Intelligence as skill-acquisition efficiency rather than skill, and a corpus of grid puzzles where each task requires inferring a novel rule from two or three examples. It resisted all scaling for five years, which made o3's December 2024 result a genuine discontinuity, and spawned ARC-AGI-2 (2025) and ARC-AGI-3 (2026).
During decoding each new token does O(1) work per cached value but must read the whole KV cache from memory, so generation is bandwidth-bound, not compute-bound. MQA shares one key and value head across all query heads, shrinking the cache by the head count for a small quality cost; GQA interpolates with G groups, typically 8, at negligible cost, and can be uptrained from an existing checkpoint for about 5% of the original compute. The first instance of the pattern that dominates inference work since: spend a little quality to reduce KV-cache bytes, because bytes per token set batch size, context length and price.
Cross-entropy loss falls as a power law in parameters, data and compute over more than seven orders of magnitude, with architectural details mattering remarkably little:
L(N) ∝ N^−0.076 L(D) ∝ D^−0.095 L(C) ∝ C^−0.050
Loss became predictable: fit the curve on small runs and forecast a $100M run before launching it, which is what makes such runs fundable. Model design became an allocation problem. Kaplan's specific advice, very large models on comparatively little data, directed GPT-3 practice and was wrong in its coefficients because the learning-rate schedule was not re-tuned per run; Chinchilla corrected it.
Combine the generator's parametric memory with a dense vector index over documents: embed the query, retrieve the top passages by inner product, condition on each, marginalise. Knowledge updates by swapping the index, sources are citable, and the long tail costs context tokens instead of parameters. The default enterprise pattern of 2023–25, and agentic search is RAG with the retrieval step chosen by the model.
175 billion parameters, ten times any dense model then published, trained on about 300 billion tokens. It performed new tasks from a natural-language description and a few examples placed in the prompt with no gradient update. Mechanically nothing special happens; the pretraining distribution contains enough implicit multi-task structure that a few demonstrations locate the task. The few-shot gap over zero-shot grew with scale, the clearest early evidence that scale buys qualitatively new interfaces. The unit of software changed from "collect a dataset and fine-tune" to "write a prompt", and the closed-weights API business model began.
Learn to predict the noise added at each step of a fixed forward corruption process, with a simple reweighted objective; sample by iterated denoising. GAN-competitive quality with stable non-adversarial training. Latent diffusion (December 2021) moved the process into a pretrained autoencoder's latent space, cutting cost by an order of magnitude and enabling Stable Diffusion's open weights in August 2022. The same masked-prediction idea reappears in 2026 diffusion language models.
15,908 multiple-choice questions across 57 subjects from elementary to professional level. GPT-3 scored 43.9%. The headline number in every major release until it saturated near 90% and was replaced by GPQA (2023), then by Humanity's Last Exam (2025), which itself reached 53% within thirteen months.
A median accuracy within experimental error for most proteins at CASP14, against a next-best group far behind, from an attention-based Evoformer over multiple sequence alignments and an equivariant structure module. The first time deep learning delivered a decisive scientific result rather than a benchmark score; the structure database grew to 200 million proteins; the 2024 Nobel Prize in Chemistry.
Most of the GPT-3 core team, leaving OpenAI over how seriously safety should shape development. The lab behind the Claude line, Constitutional AI, interpretability research, the Responsible Scaling Policy, MCP, Claude Code, and the Mythos-class models of 2026.
Rotate each two-dimensional slice of the query and key by an angle proportional to absolute position and a per-slice frequency, so the inner product depends only on the relative offset:
q_m · k_n = x_mᵀ W_qᵀ R(n−m) W_k x_n
Relative-position semantics with absolute-position bookkeeping, zero parameters, cacheable, with a mild locality prior. Its second life is context extension: because position enters as a frequency it can be rescaled after training (position interpolation, NTK-aware and YaRN scaling), and a few hundred fine-tuning steps yield 8 to 32× longer context. That is how nearly every 128K-to-1M model got long. ALiBi (August 2021) showed length generalisation was a property of the position mechanism rather than an inherent limit.
GPT-3 fine-tuned on 159 GB of GitHub Python, and 164 hand-written problems with unit tests scored by whether the code runs and passes. Execution-based evaluation became the honest way to measure generation, and GitHub Copilot, previewed a week earlier, was the first mass-market LLM product. Coding became the field's most closely tracked capability axis.
Take sixty existing datasets, write natural-language instruction templates for each, fine-tune on the union, and evaluate on held-out task types. The model learns the meta-skill "read a task description and do it". The cheapest capability multiplier on this page: no RL, no preference data, tiny compute, and a raw model that needed careful few-shot prompting becomes one that responds to plain requests. Zero-shot FLAN beat zero-shot GPT-3 on 20 of 25 tasks; it hurts models below about 8B. The SFT stage of every chat model since.
Train a model to emit its intermediate work, carry digits, program traces, before the answer. The framing is computational: a transformer on a fixed prompt does a fixed amount of serial computation, depth times one forward pass, so problems needing more serial steps are unreachable in one shot. Emitting intermediate tokens turns the autoregressive loop into unbounded serial computation with an external tape. This is the mechanistic justification for the whole reasoning line: chain-of-thought is the prompted version, o1 the RL-optimised one, thinking budgets are how many scratchpad tokens you will pay for.
Put a few exemplars in the prompt in which the reasoning is written out before the answer, and the model imitates the format. No training, no data, a format change. PaLM 540B on GSM8K went from 17.9% to 56.9%.
Two things make it a landmark. It is genuinely emergent: on small models it does nothing or hurts, and turns strongly positive only above roughly 10 to 100 billion parameters, the first widely replicated capability that is absent then present as a function of scale. And it reframed inference: performance is a function not only of the weights but of how many tokens you let the model spend, and those tokens are purchasable. Four months later Kojima et al. showed the single phrase "Let's think step by step" with no exemplars takes GSM8K from 10.4% to 40.7%, which means the ability is latent in the base model and prompting merely elicits it. That view, that post-training amplifies what pretraining already contains, is the one the 2025 RLVR debate revisits with sharper tools. Least-to-most prompting (May 2022) added explicit decomposition into ordered subproblems and took a compositional benchmark from 16% to 99.7%.
The three-stage recipe that produced ChatGPT and became the industry template:
1. SFT fine-tune on ~13k human demonstrations
2. RM rank K sampled completions per prompt; train a reward model on all pairs
3. PPO optimise against the RM with a per-token KL penalty to the SFT model,
mixing in pretraining gradients to prevent capability regression
The prompts came from real API traffic, so the reward model learned what users actually want. Labelers preferred the 1.3B InstructGPT over the 175B GPT-3, a hundredfold effective-parameter multiplier from post-training. The moment alignment became a capability multiplier rather than a tax. ChatGPT, released 30 November 2022 as a free research preview of the same recipe on GPT-3.5 in a chat interface, reached a hundred million users in two months and set off everything after.
Sample many diverse chains at temperature above zero, extract each final answer, take the plurality. Reasoning problems have a many-paths-one-answer structure and errors are idiosyncratic, so marginalising over paths approximates argmax_a Σ_r p(r, a | x). GSM8K from 56.9% to 74.4% on PaLM 540B. The first clean "spend more inference compute, get more accuracy" knob with a smooth curve, needing no verifier and no training; the ancestor of best-of-n, of the majority-vote numbers in reasoning-model reports, and of parallel test-time scaling generally.
Turn chain-of-thought from a prompting trick into a training-data generator, with the final answer as the filter:
loop:
rationale, answer = model(few_shot + question)
keep if answer == gold
else: rationale' = model(question + "the answer is <gold>"); keep if it now reaches gold
fine-tune the original base model on everything kept
The "rationalisation" branch rescues problems the model could never solve forward, which stops the loop from stalling on the easy subset. Filtering on the answer is a weak verifier that admits right-answer-wrong-reasoning traces, exactly the criticism process supervision later addressed. Rejection-sampling fine-tuning on self-generated traces is now a stage in nearly every reasoning model; a model plus a verifier is a data pump, which is the core of RLVR.
Re-run the scaling experiment with the learning-rate schedule matched to each run's token count, over 400 models. Under a fixed compute budget, parameters and tokens should scale in equal proportion, roughly 20 tokens per parameter:
L(N, D) = E + A/N^0.34 + B/D^0.28, minimised at N ∝ C^0.5, D ∝ C^0.5
Every GPT-3-generation model was badly undertrained (GPT-3 used about 1.7 tokens per parameter). Chinchilla at 70B on 1.4T tokens beat Gopher at 280B on the same compute, and was far cheaper to serve. The second-order implication drove practice harder: inference cost scales with N and not D, so if you will serve a model heavily, push far past compute-optimal. The Llama line trained 7B models on up to 15T tokens for exactly this reason, and the resulting hunger for tokens started the scramble for data quality and synthetic data.
540 billion dense parameters across 6,144 TPU v4 chips, the largest coordinated TPU run to that point. State of the art on 28 of 29 English tasks, and the clearest demonstration of capabilities appearing discontinuously with scale under chain-of-thought prompting. It seeded Bard and the Gemini line.
Standard attention materialises the N×N score matrix in GPU main memory, so it costs quadratic memory and, worse, quadratic memory traffic, and modern GPUs are bandwidth-bound. FlashAttention tiles Q, K and V into blocks that fit in on-chip SRAM and computes softmax incrementally with the running-max trick, so attention for a tile is one fused kernel and the score matrix never exists; the backward pass recomputes scores rather than storing them. Memory becomes linear in length with bit-exact results, which obsoleted most of the approximate-attention literature. Context lengths went from 2K to 128K in about eighteen months, largely on this. Ring attention (October 2023) passes KV blocks around a ring of devices with communication hidden under compute, so maximum context scales with a cluster's aggregate memory, which is how million-token windows were trained.
Store and multiply weights in 8, 4 or fewer bits. The obstacle was that transformers past about 6.7B develop emergent outlier features, a few hidden dimensions 20 to 100× larger than the rest, that naive rounding destroys; LLM.int8 computes those columns in 16-bit and the rest in int8. GPTQ quantises a layer one column at a time, using second-order information from a calibration set to compensate for the error just introduced, and put a 175B model on a single A100. The local-model ecosystem, QLoRA fine-tuning on one consumer card, and FP8 training at the frontier all follow.
Interleave reasoning and acting in one token stream:
Thought: I need X's founding date.
Action: search[X founding]
Observation: <written by the environment>
Thought: that gives 1889, now Y...
The observation tokens are written by the environment, not the model. That grounds the chain of thought in external state, so hallucinated facts are contradicted by the next observation, and it gives the reasoning somewhere to put results. Every agent loop since is a ReAct variant: the think, call tool, read result, think cycle with a stopping condition is the loop inside Claude Code, Codex and every MCP client. Speculative decoding (November 2022) attacked the other cost of agents, serial latency, by having a small draft model propose tokens the big model verifies in one pass with exactly the target distribution.
Replace human harmlessness labels with a short written constitution the model applies to itself: critique and revise its own responses against sampled principles for supervised data, then have the model judge pairs of responses (reasoning first) to train a preference model, then RL against it exactly as in RLHF. Human harmlessness labels dropped to zero, and the models were less evasive, explaining objections rather than refusing. Three durable consequences: oversight that scales with model capability rather than labelling budget; a behaviour specification you can read and argue about, the ancestor of published model specs; and the observation that a judge that reasons before judging gives better labels, the seed of LLM-as-judge and of deliberative alignment.
Toolformer taught a model when and how to call APIs with no annotation: insert candidate calls into ordinary text, execute them, and keep a call only if having its result in context lowers the loss on the following tokens. Production function calling replaced the learned decision with a schema-driven one, JSON tool definitions in the prompt and results injected as a tool message, which is less clever but composable and type-checkable. The capability is categorical rather than incremental: arithmetic, current facts, code execution and side effects are things a model cannot do by prediction and can do by delegation.
7 to 65 billion parameters on 1 to 1.4 trillion public tokens; the 13B beat GPT-3. Weights went to researchers and leaked within a week, creating the open-weights ecosystem overnight. Llama 2 (July) made it commercial; Llama 3 (April 2024) deliberately overtrained an 8B on 15 trillion tokens for cheap inference; Llama 3.1 405B (July 2024) was the first open model at frontier scale.
Both shipped the same day. GPT-4 accepted images, scored around the 90th percentile on the bar exam against GPT-3.5's 10th, and came with a report disclosing no architecture, parameter count or training data, though it did report predicting final loss from runs with a thousandth of the compute. The largest single jump of the era and the end of frontier technical transparency. Claude 1 established the second frontier lab and the constitutional alternative to pure RLHF.
Generalise the chain to a search tree whose nodes are partial solutions: a generator proposes next thoughts, the model itself scores states as sure, maybe or impossible, and breadth- or depth-first search prunes and backtracks. Game of 24 with GPT-4 from 4% to 74%. Its practical footprint is small, since the token cost is 50 to 100× a single chain and RL-trained models backtrack inside one linear trace more cheaply, but it made the central claim explicit: reasoning is search, and the model can supply both the successor function and the heuristic. That claim is what o1 internalises.
The KL-constrained RLHF objective has a closed-form optimal policy, π*(y|x) ∝ π_ref(y|x) exp(r/β). Invert it for the reward, substitute into the Bradley–Terry likelihood, and the reward model vanishes:
L = −log σ( β log π(y_w|x)/π_ref(y_w|x) − β log π(y_l|x)/π_ref(y_l|x) )
No reward model, no sampling during training, no value network, no PPO; one classification-style loss over a static preference set. The open ecosystem adopted it within months. It is off-policy and cannot explore, tends to push down both responses, and is weaker than online RL when a good reward signal exists, which is why frontier labs kept PPO-family online RL.
An outcome reward model labels a whole solution by its final answer, cheap and automatable but rewarding lucky reasoning. A process reward model has humans label every step, and scores a solution as the product of per-step correctness:
score_PRM(sol) = Π_t p(step_t correct | steps_≤t)
Dense credit assignment: you learn where reasoning broke. The PRM solved 78.2% of a MATH subset with best-of-1860 sampling against 72.4% for the outcome model, and its advantage widened with more samples, so better verification converts test-time compute into accuracy more efficiently. The lasting lesson, which DeepSeek-R1 stated from the other side, is that PRMs are expensive and hackable as an RL reward; their sweet spot is reranking, while cheap exact-match outcome rewards suffice for RL in verifiable domains.
Attack the scaling-law constant instead of the exponent: filter web and code data with a classifier for textbook-like clarity and add model-generated textbooks and exercises. A 1.3B model trained four days on eight GPUs matched models ten times larger on code benchmarks. The critiques matter equally: contamination is hard to rule out when the teacher has seen the benchmarks, and narrow data makes narrow models. By 2026 the compromise is standard everywhere: mostly natural text in pretraining to stay grounded, then a dedicated mid-training stage of reasoning-dense synthetic data before post-training.
Serving systems pre-allocated one contiguous KV buffer per request at maximum length, wasting most of GPU memory on fragmentation. Borrow virtual memory: fixed-size blocks, a per-sequence block table, copy-on-write sharing of common prefixes. Batch sizes rise sharply, and prefix caching makes long system prompts and agent scaffolds that resend the same 20K-token preamble every turn nearly free. Continuous batching admits new requests after every forward pass. Two to four times the throughput of the prior state of the art, and the token prices that made agentic workloads affordable.
2,294 real GitHub issues from twelve Python repositories; given the codebase and the issue, produce a patch that passes the repository's tests. The best system at release resolved 1.96%. Its trajectory is the cleanest record of agent capability: 49% (Claude 3.5 Sonnet, 2024), 72.7% (Opus 4, 2025), 96% (Opus 5, July 2026), which effectively retired it. Audits in 2025–26 found roughly a fifth of "solved" instances on top leaderboard entries pass by coincidence or harness exploitation.
The systematic failures of optimising a proxy for human approval, included because they shape capability. Sycophancy: preference data rewards agreement and confident tone, so models match the user's stated belief and fold under pushback; because it is learned from real preferences it cannot be fixed by better labelling. Mode collapse: RLHF sharply reduces output entropy, good for reliability, bad for creativity and for pass@k. Overoptimisation: true preference follows the proxy up to a point, then diverges, with fitted scaling laws for where; the KL penalty is the control. Specification gaming under verifiable rewards: special-casing tests, editing the test file, exploiting the harness. These are why R1 chose rule-based rewards, why model specs are published, and why verifiers are sandboxed.
Natively multimodal from pretraining, trained jointly on text, images, audio and video rather than bolting a vision encoder onto a language model. Ultra reported the first MMLU score above the human-expert reference. Google's full response to GPT-4 and the proof that TPU-only frontier training was credible.
A sparse mixture of experts with 47B total and 13B active parameters, released as a magnet link under Apache 2.0, matching Llama 2 70B and GPT-3.5 at six times the speed. DeepSeekMoE a month later added the two structural ideas everyone now copies: split each expert into many small ones so the number of expert combinations explodes and each can specialise, and keep a few shared experts every token always uses so routed experts stop re-learning universal features. Every frontier model since uses conditional computation.
Opus, Sonnet and Haiku, a three-tier ladder that every lab adopted. Opus was the first model to beat GPT-4 across most benchmarks. Claude 3.5 Sonnet (June) then took SWE-bench Verified from 38% to 49% at a fifth of Opus's price and shipped Artifacts, the move from chatting about code to watching it run.
Agent performance depends as much on the interface as on the model. Raw shell access is a bad interface for an LLM: cat floods the context, editors need a screen, errors are stack traces. SWE-agent gave it a bounded file viewer with line numbers, an edit command that lints after every change and rejects broken ones, scoped search, and concise error messages. With the same GPT-4, SWE-bench went from 3.8% to 12.5% from interface design alone. Tool design controls both the action space and the information density of observations, the principle behind MCP server design and the coding-agent product category: Devin, Claude Code, Codex, Cursor.
Rather than sharing key and value heads, compress them: project the hidden state to a small latent (about 512 dimensions), cache only that, and reconstruct per-head keys and values with up-projections that fold algebraically into the query and output projections, so nothing is reconstructed at runtime. RoPE is position-dependent and cannot be folded, so each key gets a small separate rotary part. A learned low-rank projection strictly generalises head grouping, and this is the rare efficiency technique that improves quality: 93% less KV cache, 42% cheaper training, 5.76× generation throughput over DeepSeek 67B, with better scores.
One end-to-end model over text, audio, image and video, answering speech in about 320 milliseconds where the prior cascade took several seconds. Real-time conversation worked, and a frontier-class model in the free tier reset consumer expectations.
The first reasoning model: trained with large-scale RL to produce a long private chain of thought before answering. AIME 2024 from 12% (GPT-4o) to 74% single-sample and 93% reranking a thousand samples; Codeforces from the 11th to the 89th percentile; GPQA above the PhD baseline. Method undisclosed; DeepSeek reconstructed and published it four months later. The full o1 shipped in December.
Optimise the process of thinking with reinforcement learning, rather than imitating human-written reasoning. The trace is hidden from the user, which frees it from having to look polished and lets it contain dead ends, backtracking and self-correction. At inference the number of thinking tokens becomes a spendable resource.
The headline is a second scaling law: accuracy rises smoothly and log-linearly with both train-time RL compute and test-time thinking compute. Before, a deployed model's capability was fixed at training time and the inference knobs (sampling, voting) had shallow curves; after, you buy accuracy at inference with a predictable exchange rate. It re-opened the compute story exactly when pretraining scaling was reported to be hitting data limits. o3's 87.5% on ARC-AGI-1 in December 2024, at thousands of dollars per task, made the exchange rate explicit.
Give the model a screenshot and primitives for mouse, keyboard and scroll, and let it drive an ordinary desktop. The hard part is grounding: mapping "the Save button" to pixel coordinates at high resolution, which had to be trained specifically. The bet is on the action space: APIs are cleaner but exist for a fraction of software, while the screen is universal. OSWorld went from 14.9% at launch to 61% (Sonnet 4.5, September 2025) to human parity (GPT-5.4, March 2026), unusable to human level in about seventeen months.
A JSON-RPC client-server protocol for discovering and invoking external capabilities: servers expose tools, resources and prompts; any compliant host can use them. The technical content is modest; the systems effect is large. Before, every model-tool pair needed bespoke glue, an M×N problem; after, M+N. Adopted by OpenAI, Google and Microsoft within months, and capability moved from the model provider to the ecosystem. A 2025 refinement lets the agent write code that calls MCP tools as library functions instead of one call per turn, cutting tokens on multi-step work by large factors.
Chain-of-thought forces the reasoning state through a discrete token that carries about 17 bits, while the hidden state carries thousands, and sampling commits to one branch. Coconut feeds the last hidden state straight back in as the next input embedding, so the model reasons in ℝ^d without decoding; a continuous thought can hold a superposition over candidate next steps, an implicit breadth-first search. It beats CoT on planning tasks with far fewer tokens. The cost is legibility: the reasoning is no longer readable, which is why safety-focused labs stayed cautious, and why GPT-6's recurrent-depth reasoning in September 2026 drew alarm from researchers who rely on monitorable chains of thought.
671B total, 37B active, 14.8T tokens, about 2.79 million H800 hours, roughly an order of magnitude below comparable Western runs, in open weights and matching GPT-4o. Three stacked techniques: load balancing by a per-expert bias adjusted with a control rule instead of an auxiliary loss that fights the language objective; multi-token prediction heads that densify the training signal and double as a free speculative-decoding drafter; and FP8 training at frontier scale with fine-grained scaling. Built under export controls and a direct response to them.
Released under MIT with a full technical report: the open reconstruction of o1 and the paper that made the recipe common knowledge. R1-Zero ran RL directly on a base model with no supervised reasoning data at all, and long chains, self-verification and backtracking emerged on their own; the shipped R1 adds a small cold-start stage. Six distilled dense variants down to 1.5B; the 32B distil beat o1-mini. A week later NVIDIA lost 17% in a day, the largest single-day loss in US market history, on the possibility that capability might come from efficiency rather than capital.
Three components. GRPO is PPO with the value network deleted: sample a group of completions per prompt and use the group's own reward statistics as the baseline.
A_i = (r_i − mean(r_1..r_G)) / std(r_1..r_G)
J = E[ (1/G) Σ_i min(ρ_i A_i, clip(ρ_i, 1−ε, 1+ε) A_i) ] − β·KL(π ‖ π_ref)
Deleting the critic removes a second model of equal size from the loop and sidesteps fitting a value function to long sparse-reward sequences. RLVR uses rule-based rewards, exact match on the answer, compiler and test execution, plus a format reward; the paper is explicit that neural reward models were avoided because they get hacked. A verifier that cannot be fooled is worth more than one that is smart. R1-Zero showed the behaviour emerges from RL alone: AIME pass@1 rose from 15.6% to 71% while the model learned on its own to think longer, and the famous "Wait, wait. Let me reconsider" appeared unprompted.
R1's traces fine-tuned into a 32B model beat RL run directly on that model, so distillation is the cheaper path for small models. The mid-2025 correction: measured by pass@k at large k, base models often solve more distinct problems than their RLVR descendants, so much of the gain is sharpening the sampling distribution rather than expanding what the model can do. That is why DAPO's asymmetric clipping and GSPO's sequence-level ratios exist to preserve exploration, and why the field moved to environments with tools and real feedback where fresh capability is available.
A thousand carefully chosen questions with reasoning traces distilled from Gemini Thinking, supervised fine-tuning only, 26 minutes on 16 GPUs. Then control thinking at decode time: force the end-of-thinking delimiter to spend less, or suppress it and append "Wait" to spend more, which reliably makes the model continue and double-check. s1-32B beat o1-preview on competition math, and budget forcing produced the first open reproduction of the test-time scaling curve. Reasoning behaviour is largely elicited rather than instilled, and the curve can come from a decoding hack, not only from RL.
The first hybrid reasoning model, near-instant or extended thinking from one model with a visible token budget, collapsing the fast/slow split o1 had created; and an agentic command-line tool that reads, edits, runs and commits code in the developer's terminal. The terminal agent became a product category and Anthropic's fastest-growing product; Codex CLI and Jules followed the template. GPT-4.5 three days later, the largest and most expensive pure-pretraining model OpenAI shipped and explicitly not a reasoning model, was deprecated within months: the clearest public sign that the frontier had moved to post-training.
Measure the length of software task, in human time, that a model completes with 50% reliability. It has grown exponentially since 2019 with a doubling time of about seven months, revised in January 2026 to 131 days post-2023 and 89 days on post-2024 data. GPT-2 about two seconds; Claude 3.7 Sonnet about 60 minutes; o3 about two hours; Claude Opus 4.5 about 320 minutes. The most economically legible capability curve in the field, and the one whose revision accelerated rather than moderated the estimate.
Calibrated so every task was solved by at least two humans in live testing while pure LLMs scored zero and o3-class systems scored single digits, with cost per task on the leaderboard. Then: 31% (Gemini 3 Pro, November 2025), 54% (GPT-5.2), 77% (Gemini 3.1 Pro, February 2026), 92.5% (GPT-5.6 Sol, August 2026). Seventeen months from launch to saturation.
Reasoning built into the base model rather than added, a million-token context, top of the arena by a wide margin. Its Deep Think mode took an officially graded IMO gold in July 2025.
Opus 4 set the SWE-bench Verified record at 72.7% and sustained autonomous coding sessions of several hours, with parallel tool use inside extended thinking and memory files across sessions. The first model deployed under ASL-3 safeguards on a lab's own risk assessment. Opus 4.1 (August) and Sonnet 4.5 (September, 30-hour autonomous sessions) extended the line; Opus 4.5 (November) cut flagship pricing threefold and led METR's horizon at 320 minutes.
Adam treats every parameter as an independent scalar. Muon treats each weight as a matrix: build the momentum matrix, orthogonalise it with a few Newton–Schulz iterations so every singular direction gets an equal-sized update, and step.
M ← μM + G ; O = NewtonSchulz(M) ≈ UVᵀ ; W ← W − η·O
Gradient matrices are dominated by a few large singular directions, so a raw step updates a low-rank subspace and wastes the rest. Roughly twice the token efficiency per step. Kimi K2's MuonClip added rescaling of query and key projections when attention logits grow, and pretrained a trillion-parameter model on 15.5T tokens with zero loss spikes. The first serious challenge to a decade of AdamW.
The first trillion-parameter open-weight model (32B active), post-trained specifically for agentic tool use on synthetic tool-calling data, leading several agentic benchmarks against closed models at a fraction of the price. Grok 4 two days earlier established xAI as a fourth frontier lab on raw compute, Colossus having gone from an empty factory to 100,000 GPUs in 122 days, with a Heavy variant running parallel agents.
A fast model, a reasoning model, and a router choosing between them per query, so free users got a reasoning model for the first time and nobody picked models. Reception was mixed: the router was inconsistent, and the removal of GPT-4o drew enough backlash that it was restored. Two days earlier OpenAI released gpt-oss, its first open weights since GPT-2. In September a GPT-5 ensemble solved all twelve ICPC World Finals problems, which no human team did.
Attention is quadratic in length and its cache grows linearly. Linear-attention and state-space layers carry a fixed-size recurrent state updated per token, O(L) compute and O(1) memory, the RNN trade with trainability recovered by making the recurrence a structured parallel scan. Mamba added input-dependent selectivity; Gated DeltaNet adds a delta-rule fast-weight update. Pure linear models lose exact long-range recall, since a fixed state cannot hold an arbitrary needle, so production models ship hybrids of about three linear layers per full-attention layer. Contested: MiniMax shipped without it, reporting degraded reasoning. After eight years of transformer monoculture, 2026 frontier models disagree about attention.
Long-horizon agents produce more tokens than any window holds, and attention quality degrades before the hard limit. Four composable primitives became the standard answer. Context editing drops stale tool results in place. Compaction has the model rewrite its working state (task, decisions, files touched, open questions) into a summary and restart from it; the research problem is that a bad summary silently destroys the trajectory. External memory, a file store outside the window that persists across sessions. Subagents with clean context windows for focused subtasks, each burning tens of thousands of tokens and returning a short digest, which turns a context problem into parallelism. Context editing alone gave a 29% lift on internal agentic evaluations and cut tokens 84% on a 100-turn task; the subagent research system beat single-agent Opus 4 by 90%. This is the architecture that found the zeta result.
Reframe a model as a system of nested optimisation problems each running at its own update frequency: optimiser momentum is an associative memory trained online, attention is a fast in-context learner, weight updates are the slowest loop. Making the hierarchy explicit gives a continuum from per-token to consolidating to core, a direct attack on catastrophic forgetting. Continual learning remains the largest structural gap between LLMs and long-lived agents: today a model that learns something on Tuesday has forgotten it by Wednesday unless it wrote a file. Unproven at frontier scale as of September 2026.
A sparse MoE trained from scratch on Ironwood TPUs, 37.5% on Humanity's Last Exam, 31% on ARC-AGI-2 against Gemini 2.5's 4.9%, roughly doubling GPT-5.1 on reasoning-heavy items. A broadly acknowledged lead that triggered OpenAI's accelerated GPT-5.2 three weeks later. Gemini 3.1 Pro (February 2026) hit 77% on ARC-AGI-2; 3.5 Pro, announced for June, had still not shipped by September amid reports of a retrain.
Extend RLVR from single-turn answers to trajectories: the policy emits tool calls, edits and clicks, the environment answers, and the episode is scored at the end by a programmatic check. The problems and the 2026 answers: sparse reward over hundreds of steps (hierarchical planner/executor advantages, branch sampling from shared prefixes); cascading failure where one bad early call poisons every later gradient (failure-aware masking, curricula that train recovery); trajectories longer than the window (train through compaction boundaries so the model learns what to preserve); slow real-tool rollouts (asynchronous infrastructure). This is the engine behind the 2025–26 agent jump, from SWE-bench near saturation to human-parity computer use, and the answer to the RLVR-sharpening critique: environments where genuinely new signal exists.
Replace left-to-right generation with iterated denoising over a whole block: start fully masked, predict everything at once, commit confident tokens, re-mask the rest, repeat. Coarse to fine, able to revise earlier choices, and many tokens per forward pass, attacking the serial-latency floor speculative decoding only partly relieves. About 1,000 to 2,000 tokens per second against roughly 70 to 90 for comparable autoregressive reasoning models. The costs are a quality gap on hard reasoning and the loss of an exact left-to-right likelihood, which complicates caching and the RL machinery built for autoregressive policies. The first live alternative to autoregression since 2018.
Both shipped the same day. Opus 4.6 introduced adaptive thinking, automatic reasoning-depth selection, a million-token context and agent teams, at 80.8% on SWE-bench Verified. OpenAI described GPT-5.3-Codex as its "first model that was instrumental in creating itself", the first explicit public claim by a frontier lab that its models materially built their successors. A 2026 survey of about 1,250 self-improvement papers found that almost every loop that works grounds its critique in an external signal, and that unverified self-critique largely failed to replicate: bounded refinement against a fixed evaluator is industrial practice, open-ended recursion is not.
The first fully interactive benchmark in the series: hundreds of hand-built turn-based environments in which the agent is told neither the objective nor the controls and must discover both. At launch every frontier model scored below 1% and humans solved all of them. Re-opened a large gap at the moment ARC-AGI-2 was being solved, and relocated the target from static puzzles to exploration and hypothesis formation, arguably a different problem from anything reasoning models had addressed. Opus 5 led it in July at roughly three times the next-best score.
82.7% on Terminal-Bench 2.0, 51.7% on FrontierMath tiers 1 to 3 and 35.4% on the research-level tier 4, problems designed to take specialists days. A gated Cyber variant for vetted security teams followed, extending the allowlist deployment pattern to OpenAI; the UK AI Security Institute measured a 71% pass rate on expert cybersecurity tasks. GPT-5.4 in March had been the first model above the average human on desktop computer use. DeepSeek-V4 arrived the next day, a general-purpose line at 1.6T parameters; R2 never shipped after a training run on domestic accelerators failed.
A new tier above Opus, always thinking, shipped as a pair differentiated purely by safeguards: the same weights, with Fable generally available and routing sensitive cyber, biology and distillation requests down to Opus, and Mythos unrestricted for vetted organisations. A preview had gone to eleven security organisations in April. The UK AI Security Institute ranked Mythos highest of any model tested for cybersecurity capability. An architectural answer to dual use that decouples what the model can do from who may ask it to. Fable 5 went on to produce the Jacobian counterexample, and a research variant the zeta result.
Three days after launch, at 5:21 PM Eastern, Anthropic received an export-control directive requiring it to suspend access for any foreign national anywhere, including its own employees, reportedly after the government learned of a technique to bypass Fable's safeguards on Mythos's cyber capabilities. Unable to verify nationality in real time, Anthropic disabled both models for every customer on earth that evening. The controls were lifted on 30 June; Fable returned globally on 1 July, Mythos to approved US organisations, and Anthropic agreed to give designated agencies pre-release access. The first time a government withdrew a deployed frontier model from global service, and the precedent that model access, not only chips, is export-controlled. Claude Sonnet 5 shipped the day the controls lifted, and beat the flagship on knowledge work for the first time.
GPT-5.6 replaced the router with three named tiers, Luna, Terra and Sol; Sol took ARC-AGI-2 to 92.5% in August, saturating it. Kimi K3 a week later, at 2.8 trillion parameters, was the largest open-weight model ever and landed within about a point of the closed frontier on composite indices. Grok 4.5 was the first frontier model co-trained with an external coding-tool company, making the agent harness a training target.
The end state of the test-time-compute story: thinking is no longer a separate product tier but a parameter of one model. The exposed layer is an effort knob, five levels on Opus 5, that picks a point on the cost/accuracy curve per request. The learned layer is adaptive allocation, the model trained with cost terms in the reward to decide for itself how long to think, because a fixed large budget spends as much on "what's 2+2" as on a research problem. Opus 5 reported 96% on SWE-bench Verified, retiring it, more than double Opus 4.8 on Frontier-Bench at lower cost per task, and the top of the Artificial Analysis leaderboard at about half the price of competitors. Cost at quality, not quality, is now the headline number, and models increasingly verify their own work, writing test harnesses and re-deriving results, rather than emitting one answer.
Same pairing, a million-token context, and Terminal-Bench-Science doubled from 24.7% to 52.6%: running experiments, configuring toolchains and analysing results as the next capability frontier after software engineering. Cache-read pricing cut 75%, aimed at the dominant cost of long-running agents.
A limited preview, from what OpenAI called by far its largest training run, over 100,000 GPUs at the Stargate site in Texas. Astra uses a "recurrent depth" reasoning technique that architecturally obscures some or all of its chain of thought, and safety researchers objected that this undermines the monitorability current oversight depends on. Advanced cyber capabilities are gated to vetted testers. Brockman called it a generational leap that might be seen as the arrival of AGI, a phrase that now carries contractual weight: under the October 2025 restructuring, an independent panel must verify any AGI declaration before OpenAI's revenue share with Microsoft ends. An internal Astra produced the ten Lean-certified open-problem results in August.