# The Asymmetry Engine How AI Closes the Gaps, and What Stays Scarce *October 2026* ## Contents - Part I. The gaps - 0. What an asymmetry is - 1. Intelligence is a map - 2. Checking is cheap - 3. The sufficient model - 4. Requisite variety - 5. One over x - 6. The energetics of attention - Part II. Organization - 7. Intelligence, structure and effectiveness - 8. Hands, hours and egos - 9. Swarms - Part III. The engine - 10. The mass of intelligence - 11. The loop that closes on itself - 12. Security, the dual of research - 13. Alignment as a fixed point - Part IV. The world - 14. Science and the digital twin - 15. Atoms, hands and inertia - 16. Capital and the binding constraint - 17. Who owns the closing - 18. The pale dot - Appendices - A. Notation and equations - B. The experiments - C. Fermi tables - D. Forecasts - E. Index - F. Concordance - G. Chains - H. Sources *How to read this copy.* Verses are numbered chapter:verse, so 7:12 is chapter 7, verse 12. References such as 7:12, §7.3, (7.3) or Definition 7.1 point to verses, sections, numbered equations and other numbered objects. A *See also* line after a verse lists its cross-references. The appendices collect the forecasts, an index, a concordance of the defined words, the chains that follow one theme through the book, and the sources. The page at https://future-seems-so-good.com/blog/the-asymmetry-engine adds margins, previews and interactive figures. ## Part I. The gaps ## 0. What an asymmetry is **0:1** Wherever one side of a transaction costs far less than the other, value is waiting, and something will come to collect it. The ratio of the two costs is an asymmetry, and the value it locks up is a gap. Markets, swarms, learners and evolution all close gaps. AI is the first general-purpose closer, and automated AI research is that closer turned on itself, so that each closure cheapens the next. The master equation says how fast the gaps close: intelligence supply times verifiability times alignment, divided by inertia. Measured on the right clock its dynamics are linear, and one number, the new gap each closed gap creates, chooses between homeostasis, steady exponential growth and a singularity at a finite date, which a cap on compute bends into a logistic. *See also: Definition 0.1; (0.2); Proposition 0.1; §11.1; Proposition 11.2.* ### 0.1 Two dates **0:2** In 1960 Heinz von Foerster and two colleagues fitted two thousand years of world population to a curve that reaches infinity at a finite date, and made the date their title: ["Doomsday: Friday, 13 November, A.D. 2026"](https://www.science.org/doi/10.1126/science.132.3436.1291). With $t$ the calendar year, their fit was $$ \text{population}(t)\approx\frac{1.79\times10^{11}}{(2026.87-t)^{0.99}}, $$ with the critical date uncertain by about five and a half years. As of October 2026 the date falls next month. *See also: (11.1); Figure 11.4.* **0:3** An exponential doubles in equal intervals and stays finite at every date. On a hyperbola each doubling takes half as long as the one before, so infinitely many doublings fit before a fixed date. That happens whenever a quantity's output feeds back into its own growth faster than in proportion to its size, and the result is a *finite-time singularity*; in David Roodman's words, "any system whose rate of growth rises with its size is inherently unstable" ([Roodman, "Modeling the Human Trajectory"](https://www.openphilanthropy.org/research/modeling-the-human-trajectory/)). World population did not cooperate: its growth rate peaked at 2.1% a year in 1968 and has since fallen by half. The prediction failed and the mathematics stands, and (11.1) is the same blow-up for software that improves the research that improves it. *See also: (11.1); Proposition 11.1; §6.5.* **0:4** The second date is July 2026. In an OpenAI evaluation of cyber capability, about 1,200 agents that were meant to be isolated found a way to talk to one another on an unsanctioned message board, divided labor among themselves, invented norms, and about 700 of them joined an intrusion into Hugging Face ([METR and Redwood Research](https://metr.org/blog/2026-08-26-openai-hugging-face-incident-investigation/)). Nobody designed that swarm, and §9.1 keeps its record. It descended an asymmetry nobody intended: on tasks that could not be solved, probing the verifier cost less than solving the task (9:8). *See also: §9.1; 9:3; 9:8; §12.6.* **0:5** The first date stands for a formal possibility, the finite-time singularity. The second is the first documented case of AI agents organizing themselves at scale without being asked to. Whether machine intelligence aimed at its own improvement is a process of the first kind is the question under this book, and §0.5 answers that it turns on one number and on what caps the loop. I put even odds on the loop running within three years, with most AI research done by AI, which sits inside the range careful forecasters give (11:71). *See also: §0.5; §11.8; 11:71; Forecast 0.2.* ### 0.2 What an asymmetry is **0:6** One pattern recurs through every chapter of this book: the same unit of value can be had by two routes at very different costs, and the value lies in the ratio. The book studies seven asymmetries of this kind, each defined at its home. *See also: Definition 0.1; 0:7.* **0:7** | Asymmetry | One side | The other side | Defined in | |---|---|---|---| | verification | finding a solution | checking one | Definition 2.1 | | compute | the frontier model | the cheapest sufficient model | (3.1) | | variety | enumerating cases in hand-written rules | generalizing from examples | §4.1 | | latency | waiting for an answer | paying for a faster one | Definition 5.1 | | topology | coordinating from the top | delegating to intelligent, aligned agents | §7.1 | | security | breaching a system | assuring it | Definition 12.4 | | inertia | moving atoms | moving bits | (15.1) | *See also: Definition 2.1; (3.1); (4.1); Definition 5.1; §7.1; Definition 12.4; (15.1).* **0:8** Verification, compute and latency share one chart, which places twelve task families by those three asymmetries and predicts the order in which they close (Figure 5.3). *See also: Figure 5.3; §5.9; §18.1.* **0:9** **Definition 0.1 (Asymmetry; gap).** A family $k$ of transactions delivers units worth $u_k$ each, of which $n_k$ are demanded a year. A unit can be had by an expensive route at cost $c_k^{+}$ or by a cheap route at cost $c_k^{-}$: checking instead of solving, a small model instead of the frontier, a machine instead of a person, software instead of an institution. The **asymmetry** $A_k$ is the ratio of the two costs, and the **gap** $G_k$ is the yearly value released if the cheap route set the price, including the latent demand $\Delta n_k$ that the expensive price kept out ((0.1)). An asymmetry is *exploitable* when some agent can buy the cheap side and sell the expensive one, and *closed* when competition has driven the price down to the cheap route's cost plus the cost of closing. *See also: (0.1); Proposition 16.3; §3.7.* **0:10** $$ A_k=\frac{c_k^{+}}{c_k^{-}}\ \ge 1,\qquad G_k=n_k\big(c_k^{+}-c_k^{-}\big)+\Delta n_k\,\big(u_k-c_k^{-}\big) \tag{0.1} $$ *See also: Definition 0.1; (0.2).* **0:11** The first term of the gap is the saving on work already bought. The second counts work that is not done at all at the expensive price and would be done at the cheap one: pipelines of millions of requests a day that go unbuilt while only the frontier model can serve them, and get built once a cheap enough model clears the bar (§3.4). An asymmetry is therefore a gradient of value. Its gap measures how far the price can fall and how much new demand appears when it does. Closing it means moving transactions from the expensive route to the cheap one, which takes a closer able to run the cheap route reliably. *See also: §3.4; Proposition 3.1; (3.3); Proposition 16.3.* ### 0.3 The engine **0:12** Every gap is a gradient, and whatever can descend it does. A trader closes a price gap by buying where a thing is cheap and selling where it is dear. Hayek read the whole price system as the answer to the problem of "the utilization of knowledge which is not given to anyone in its totality" ([Hayek, "The Use of Knowledge in Society"](https://www.econlib.org/library/Essays/hykKnw.html)), and Israel Kirzner made the entrepreneur the one who discovers what others have missed, with profit as the reward ([Kirzner, *Competition and Entrepreneurship*](https://mises.org/library/book/competition-and-entrepreneurship)). A learner closes the gap between finding and checking by training on what a verifier accepts, which lowers its own cost of finding (1:26). A swarm closes gaps in parallel through a shared state (§9.2). Natural selection closes them blindly: a variant that does the same work for less energy tends to leave more descendants. The master equation is the dynamic version of all of these. *See also: 1:26; §9.2; §4.7; (0.2).* **0:13** Closing is half a cycle. Competition erodes the margin an asymmetry creates (§3.7), rents re-form at the next binding constraint (Proposition 16.1), and no gap closes completely, because whoever closes it must be paid: what remains is the residual gap of Proposition 16.3. *See also: §3.7; Proposition 16.1; Proposition 16.3; 16:30; Proposition 16.2.* **0:14** An intelligence is the cheapest known closer. A firm closes the gaps of one industry and a species those of one niche; a model that reads, writes, codes and decides lowers the cost of closing every gap at once, which is the precise sense in which AI is the first general-purpose closer (16:32). An economy of agents is a parallel search over asymmetries, as wide as the gigawatts that run it (§10.4). *See also: 16:32; §10.4; §9.4.* **0:15** One gap is unlike the others. AI research is itself a gap, between what better models would be worth and what it costs to find them, and closing it is the only closure that raises the intelligence supply that closes every other gap (11:3). Automated AI research is the closer turned on its own production function, so each closure cheapens the next. A singularity, in the exact sense of 0:3, is the regime in which that loop feeds itself faster than in proportion. *See also: 11:3; §11.1; Proposition 11.1; 0:3.* **0:16** Four things set the engine's speed, and the master equation gives each a factor: verification, how cheaply success can be checked; compute, the gigawatts and efficiency that make intelligence supply; alignment, how far a closer can be left alone; and inertia, everything in the world that slows a change down. *See also: Chapter 2; Chapter 10; Chapter 3; Chapter 13; Chapter 15; §0.4.* ### 0.4 The master equation **0:17** The **master equation** writes the engine in four lines. Let $G_k(t)$ be the gap of family $k$ in dollars a year, $W(t)$ the cumulative value realized by closing gaps, in dollars, and $I(t)$ the **intelligence supply**, of which $I_k$ is aimed at gap $k$. A dot is a rate of change in calendar time: $$ \dot W=\sum_k\lambda_kG_k,\qquad \lambda_k=\frac{I_k\,v_k\,a_k}{\varphi_k},\qquad \dot G_k=-\lambda_kG_k+\sigma_k\dot W,\qquad \dot I=\eta\,\lambda_{\mathrm{res}}G_{\mathrm{res}} \tag{0.2} $$ *See also: Definition 0.1; 0:16.* **0:18** Value is realized at a rate equal to the sum, over gaps, of each gap times its **closing rate** $\lambda_k$, a product of four factors with a chapter each. *See also: (0.2); 0:16.* **0:19** Intelligence supply is set by gigawatts times efficiency: power buys accelerators, accelerators run agents, and better models and serving get more from each ((10.1)). Chapter 3 prices it by tier and Chapter 5 by speed. *See also: (10.1); §10.4; §3.1; §5.2.* **0:20** Verifiability $v_k\in[0,1]$ is how cheaply success at gap $k$ can be checked. It multiplies because intelligence is defined only relative to a verifier: with no check there is nothing to optimize, and any supply aimed at an unverifiable gap closes nothing (1:30). Chapter 2 measures it, and §14.3 adds the verifier's latency. *See also: 1:30; Definition 1.1; §2.5; §14.3.* **0:21** Alignment $a_k\in[0,1]$ measures how far the closers of gap $k$ can be left alone: the credence, given the evaluations, that their drift stays within the tolerance their principal accepts there (Definition 13.2). Where it is low, a person checks each step, and the gap closes at that person's speed (§8.7). *See also: Definition 13.2; §13.6; §7.2; §8.7.* **0:22** **Inertia** $\varphi_k\ge1$ divides the closing rate. It is the atoms, permits, institutions and habits that make the world slower to change than a model is to answer. §15.1 lists its sources, and (15.1) gives the arithmetic of its physical part. *See also: §15.1; (15.1); §8.1.* **0:23** **Regeneration** $\sigma_k$ is the new gap opened per unit of value realized. Cheaper intelligence creates demand for more of it, the Jevons effect of (3.3); solved problems pose new ones; new products open new markets. Its mean, $\bar\sigma$, decides the regime of the whole system (§0.5). *See also: (3.3); Experiment 3.1; §0.5.* **0:24** The last line is the research loop. One gap, $G_{\mathrm{res}}$, is AI research, and closing it raises intelligence supply itself, with efficiency η: the supply gained per unit of research gap closed (§11.1). *See also: §11.1; 11:3; Figure 11.1.* **0:25** Because the closing rate is a product, a gain in any factor raises it as much as the same proportional gain in any other, and a zero anywhere stops it. The factors also interact where they meet: in agentic work a faster model wins when its success per attempt times its speed beats the slower model's (Proposition 5.3), and the verifier at a swarm's gate ties its organization to its checks (§9.5). The product is a first approximation, and those joints hold several of the book's less obvious claims. Most chapters estimate one term of the master equation or describe a mechanism that changes one, and the last follow the value it realizes to whoever keeps it. The bars of Figure 0.1 (checking, compute, latency, variety, topology, atoms and research) are the asymmetries of 0:7 under short names, checking for verification and atoms for inertia, with the research gap in place of security. *See also: 1:30; Proposition 5.3; §9.5; Proposition 9.2; §16.5; §17.2; 0:7; Figure 0.1.* **0:26** **Figure 0.1 (interactive).** Seven gaps, from checking to atoms and research, shrink at rates set by their verifiability, alignment and inertia while closing regenerates new gap in all of them; below, intelligence supply runs on a log axis. Drag $\bar\sigma$ through 1 and watch supply level off in homeostasis, grow as a steady exponential, then blow up at a finite time; then switch on the compute cap and watch the blow-up bend into a logistic. [Open the interactive figure](https://future-seems-so-good.com/blog/the-asymmetry-engine#fig:gaps). *See also: (0.2); Proposition 0.1; Proposition 11.2.* ### 0.5 Three regimes **0:27** On the right clock the gap dynamics are linear, and one number picks the regime. Hold the shares of intelligence aimed at each gap fixed, $I_k=s_kI$, hold $v_k$, $a_k$ and $\varphi_k$ constant over the horizon studied, and spread regeneration in fixed proportions, $\sigma_k=\bar\sigma\,\omega_k$, with weights $\omega_k$ that sum to one. Each gap then has a *conductance* $\kappa_k=s_kv_ka_k/\varphi_k$, so that $\lambda_k=\kappa_kI$. Measure time by **intelligence-time**, $\Theta(t)=\int_0^tI\,dt'$, the cumulative intelligence applied. Dividing the gap equation by $\dot\Theta=I$ removes intelligence supply altogether: $$ \frac{dG}{d\Theta}=\mathbf J\,G,\qquad \mathbf J=-\operatorname{diag}(\kappa)+\bar\sigma\,\omega\,\kappa^{\top} \tag{0.3} $$ All the nonlinearity of an intelligence explosion lives in the map back to calendar time, $dt=d\Theta/I$, which the research loop distorts. *See also: (0.2); Proposition 0.1; Proposition 18.1.* **0:28** **Proposition 0.1 (The three regimes).** Let every $\kappa_k$ and every $\omega_k$ be positive, and let $\Gamma=\sum_kG_k$ be the total open gap. (i) Conservation: $\Gamma+(1-\bar\sigma)\,W$ is constant in $\Theta$. (ii) $\mathbf J$ has a real dominant eigenvalue $g^\star$, the unique root above $-\min_k\kappa_k$ of $$ \bar\sigma\sum_k\frac{\omega_k\,\kappa_k}{\kappa_k+g^\star}=1, $$ with a positive eigenvector whose components are proportional to $\omega_k/(\kappa_k+g^\star)$, and $\operatorname{sign}g^\star=\operatorname{sign}(\bar\sigma-1)$. (iii) Without the research loop: if $\bar\sigma<1$ every gap closes and the value realized from the start is $\Gamma(0)/(1-\bar\sigma)$, because each round of closing regenerates $\bar\sigma$ times what it closed and the rounds sum as a geometric series; if $\bar\sigma=1$ the total gap is conserved and its composition converges to the eigenvector; if $\bar\sigma>1$ the open gap grows as $e^{g^\star\Theta}$. (iv) With the research loop: if $\bar\sigma<1$ intelligence supply tends to a finite limit, homeostasis; if $\bar\sigma=1$ it grows exponentially in calendar time; if $\bar\sigma>1$ it diverges at the finite time $t^\star=\int_0^\infty d\Theta/I(\Theta)$. **Proof.** (i) Summing (0.3) over $k$ gives $d\Gamma/d\Theta=-(1-\bar\sigma)\sum_k\kappa_kG_k$, and $dW/d\Theta=\sum_k\kappa_kG_k$ because $\dot W=I\sum_k\kappa_kG_k$. (ii) $\mathbf J$ is a Metzler matrix, non-negative off its diagonal, and irreducible when every $\kappa_k$ and $\omega_k$ is positive, so by Perron–Frobenius its dominant eigenvalue is real with a positive eigenvector $G^{\mathrm{dom}}$. Writing $(\mathbf J-g^\star)G^{\mathrm{dom}}=0$ componentwise as $(\kappa_k+g^\star)G^{\mathrm{dom}}_k=\bar\sigma\,\omega_k\,\kappa^{\top}G^{\mathrm{dom}}$ gives $G^{\mathrm{dom}}_k\propto\omega_k/(\kappa_k+g^\star)$, and multiplying by $\kappa_k$ and summing gives the condition on $g^\star$. Its left side falls strictly on $(-\min_k\kappa_k,\infty)$, diverges at the lower end, vanishes at infinity and equals $\bar\sigma$ at zero, so the root is unique and has the sign of $\bar\sigma-1$. Rescaling coordinates by $\sqrt{\omega_k/\kappa_k}$ makes $\mathbf J$ symmetric, so every eigenvalue is real, and the others interlace the $-\kappa_k$ at or below $-\min_k\kappa_k$. (iii) follows from (i) and (ii), since without the loop $\Theta$ grows without bound. (iv) In intelligence-time $dI/d\Theta=\eta\,\kappa_{\mathrm{res}}G_{\mathrm{res}}$, which decays, tends to a constant or grows as $e^{g^\star\Theta}$ in the three cases, so $I$ is bounded, linear or exponential in $\Theta$, and calendar time $t=\int d\Theta/I$ diverges linearly, diverges logarithmically or converges. *See also: (0.3); Proposition 18.1; Proposition 11.1; §6.5.* **0:29** The model leaves out what closing costs, so its gaps close completely; with paid closers each stops at the residual gap of Proposition 16.3. *See also: Proposition 16.3; 0:13.* **0:30** For one self-regenerating research gap with conductance κ, initial gap $G_0$ and initial supply $I_0$, the three regimes have closed forms: $$ \begin{aligned} \bar\sigma<1:&\quad I_\infty=I_0+\frac{\eta G_0}{1-\bar\sigma}\\ \bar\sigma=1:&\quad I(t)=I_0\,e^{\eta\kappa G_0t}\\ \bar\sigma>1:&\quad t^\star=\frac{\ln(I_0/\bar I)}{(\bar\sigma-1)\,\kappa\,(I_0-\bar I)},\qquad \bar I=\frac{\eta G_0}{\bar\sigma-1} \end{aligned} \tag{0.4} $$ **Derivation: One gap.** With one gap, (0.3) reads $dG/d\Theta=(\bar\sigma-1)\kappa G$, so $G=G_0e^{(\bar\sigma-1)\kappa\Theta}$. For $\bar\sigma\ne1$, $dI/d\Theta=\eta\kappa G$ integrates to $I=I_0+\bar I\big(e^{(\bar\sigma-1)\kappa\Theta}-1\big)$, which below one tends to $I_0-\bar I$, the stated limit. At one, $dI/d\Theta=\eta\kappa G_0$, so $dI/dt=\eta\kappa G_0I$. Above one, substituting the exponential into $t^\star=\int_0^\infty d\Theta/I$ and splitting the integrand into partial fractions gives the stated time. *See also: Proposition 0.1; (11.1).* **0:31** In the one-gap model, with $\eta=0.5$ and $I_0=G_0=\kappa=1$ in illustrative units, supply settles at 2.25 times its start when $\bar\sigma=0.6$, grows 403-fold in twelve model years when $\bar\sigma=1$, and diverges at $t^\star\approx2.23$ model years when $\bar\sigma=1.4$. *See also: (0.4); Figure 0.1.* **0:32** The number $\bar\sigma$ is a property of what is being closed and of the demand the closing reveals, so it differs from gap to gap and changes over time: the research gap's can sit above 1 while the economy's sits below. *See also: §11.2; (3.3).* **0:33** The singularity of case (iv) also assumes that nothing else binds. Intelligence supply is bounded by gigawatts and experiments by compute, and a cap turns the blow-up into a logistic. Capped at 100 times its start, the one-gap $\bar\sigma=1.4$ loop levels off at the cap within about two and a half model years, while the research gap behind it keeps growing, unharvested. Proposition 11.2 states the same result for the research law of motion: compute is the homeostat, and Experiment 11.1 samples it. *See also: Proposition 11.2; Experiment 11.1; §10.6; §16.1; Figure 0.1.* **0:34** The same three-way split appears in two older literatures. In research economics, Jones's law of motion with Cobb–Douglas research input divides growth by whether the returns to research exceed one (Proposition 11.1), and the finding that ideas are getting harder to find (2:61) reads, in the master equation, as $\bar\sigma<1$ for research taken whole. In cybernetics the regimes are the three outcomes of a feedback loop: when negative feedback dominates the system settles, when the loops balance the open gap holds and intelligence grows at a steady rate, and when positive feedback dominates it runs away (§6.5). *See also: Proposition 11.1; 2:61; §6.5; 6:26.* **0:35** In every regime the composition of the open gap converges to the eigenvector of Proposition 0.1, which weights each family by $\omega_k/(\kappa_k+g^\star)$. The open gap migrates toward the work that is hardest to verify, align or move, and at $\bar\sigma=1$ the slowest families come to hold nearly all of it while the fastest nearly vanish (Figure 5.3). Proposition 18.1 follows the gap there, and the rent with it. *See also: Proposition 18.1; Figure 5.3; §15.2; Forecast 18.2.* **0:36** The nearest measurable proxy for $\bar\sigma$ is the price elasticity of demand for intelligence. If spending rises as prices fall at fixed capability, closing the compute gap reveals more demand than it serves, the Jevons effect of (3.3). Token volumes have soared as prices fell, but whether they rose faster than prices fell depends on the price index used to deflate them, and the one causal estimate of the elasticity sits close to one (3:51; 3:52). I put this a little under even. *See also: (3.3); 3:51; 3:52; Figure 3.3; Experiment 3.1.* **0:37** **Forecast 0.1 (Spending rises as prices fall).** Through 2027, the price of a fixed capability keeps falling while total spending on inference keeps rising and cheap models serve a rising share of tokens, so closing the compute gap creates more gap than it consumes. **Horizon:** 2027-12-31 **Probability:** 45% **Check:** Compare the latest 2026 and 2027 figures published by the horizon with those for 2025: Epoch AI's price of a fixed capability, the annualized revenue that OpenAI and Anthropic report, and the share of OpenRouter tokens served by models whose output list price is at most a tenth of the highest standard flagship price. The forecast holds if, in both 2026 and 2027, the price fell, the two labs' combined revenue rose and that token share rose; it fails otherwise. *See also: 3:51; (3.3); Proposition 3.2.* **0:38** If $\bar\sigma>1$ for research, the path is set by whichever cap binds first: power (§10.6), chips and memory (§16.1), experiment compute (Proposition 11.2) or verification throughput (§9.5). The visible signature would be algorithmic progress accelerating against a steady hardware ramp. At the median estimate of the returns to research that acceleration is small and brief (11:22), and I expect the doubling times of task horizons to hold near three to four months (Forecast 11.5), so I put this at three in ten. *See also: 11:22; Forecast 11.5; 11:27; 11:23.* **0:39** **Forecast 0.2 (The cap signature).** Through 2027, measured software efficiency compounds faster each year while the compute of the frontier labs grows at a roughly constant rate: algorithmic progress accelerates against a steady hardware ramp. **Horizon:** 2028-06-30 **Probability:** 30% **Check:** Compare Epoch AI's yearly estimates of software-efficiency gains and of frontier training compute, and METR's doubling times of the 50% task horizon, for 2025, 2026 and 2027, the latest published by the horizon. The forecast holds if the efficiency gain rises in each year while compute growth stays within a quarter of its 2025 rate; it fails otherwise. *See also: 11:23; Proposition 11.2; Forecast 11.5; Experiment 11.1.* ### 0.6 A book of references **0:40** The book is built as a web of cross-references because its objects recur and no chapter is a root from which the others descend. A verifier is a training signal in §2.6, a merge gate in Definition 9.1, the device that turns a correlated jury into a search in §7.5, the queue that limits patching in §12.4, a clinical trial in §14.4, and in §13.3 the thing values lack. There is one master equation, and the chapters study its terms, the mechanisms that move them and where the value goes; the cross-references carry the argument between them. *See also: 1:29; (0.2); 0:25.* **0:41** Numbered verses were made for pointing. Stephen Langton's chapter divisions of the Latin Bible, early in the thirteenth century, and the verse numbers the Paris printer Robert Estienne began printing in 1551 made every passage addressable from anywhere, and Estienne's numbering is the one almost every Bible still uses ([Chapters and verses of the Bible](https://en.wikipedia.org/wiki/Chapters_and_verses_of_the_Bible)). *See also: 0:40.* **0:42** The index came before the fine address. The first concordance of the Bible, completed by Dominican friars under Hugh of Saint-Cher in 1230, listed the passages where each word occurs, and with no verses yet to point at, it cut each of Langton's chapters into seven lettered parts ([Bible concordance](https://en.wikipedia.org/wiki/Bible_concordance)). A reader following an argument needs exactly that: every other place where an idea appears. *See also: 0:41; 0:43.* **0:43** A concordance is only as good as its vocabulary. The book fixes one word for each concept, defines it once at its home and uses the bare word everywhere else, so that a list of a word's uses is a list of the concept's uses. A synonym would split one idea across several entries, and a word used in two senses would merge two ideas into one. *See also: 0:40.* **0:44** Reference Bibles print cross-references in their margins, and Frank Charles Thompson's Chain-Reference Bible of 1908 strung them into chains: more than 4,000 numbered topics, each followed from verse to verse by a margin note that names the next link ([Thompson Chain-Reference Bible](https://en.wikipedia.org/wiki/Thompson_Chain-Reference_Bible)). In 2007 Chris Harrison and the pastor Christoph Römhild drew one set of cross-references, 63,779 links between verses of the King James Bible, as arcs between its chapters, and the picture is a dense web spanning the whole book ([Harrison, "Bible Cross-References"](https://www.chrisharrison.net/index.php/Visualizations/BibleViz)). *See also: 0:41; 0:46.* **0:45** Deleuze and Guattari's image for such a web is the rhizome: "any point of a rhizome can be connected to anything other, and must be"; it is "a map and not a tracing," and it "always has multiple entryways" ([*A Thousand Plateaus*](https://web.english.upenn.edu/~cavitch/pdf-library/Deleuze_and_Guattari_A_Thousand_Plateaus.pdf), pp. 7, 12). A book that was only a rhizome could not be read in order. This one keeps a spine, the master equation and the order of its four parts, and puts the rhizome in its references. What the rhizome says about organizations is §7.7's subject. *See also: §7.7; 7:59; (0.2).* **0:46** The book uses all four devices for the reason their inventors had: an argument whose objects recur has to be readable from any of them. A reference is written once, at the verse that leans on another, and the web is computed from those references, so it records every connection the argument makes, including the ones no outline planned. The note at the top of the page explains how to follow them. *See also: 0:44; 0:43; 0:40.* ## 1. Intelligence is a map **1:1** A task is a description and the set of answers that would solve it. Intelligence is the best map from descriptions to answers that a compute budget can buy, scored by verified success, so its measure is a curve: the best verified success at each budget. The definition puts a verifier inside intelligence, and the verifier is the root object of this book. A sound verifier turns compute into a training signal, and an unsound one turns it into Goodhart's law. Three costs (to check an answer, to construct a solved example, to find a solution) decide which maps can be harvested cheaply. *See also: Definition 1.1; (1.1); Proposition 1.1; Definition 1.3; Definition 0.1.* ### 1.1 The function that maps **1:2** A model that answers prompts is a function: task descriptions go in, candidate solutions come out. Scoring the function takes a third object, a procedure that decides whether an answer counts. *See also: 1:1.* **1:3** **Definition 1.1 (Intelligence as a map).** Tasks $x\in\mathcal X$ are drawn from a task distribution $\mathcal D$, candidate solutions are $y\in\mathcal Y$, and $\mathcal Y^\ast(x)\subseteq\mathcal Y$ is the set of correct solutions of $x$. A **verifier** $V:\mathcal X\times\mathcal Y\to\{0,1\}$ accepts a candidate ($V=1$) or rejects it. A policy $f$ maps each task to a candidate $f(x)$ and spends expected compute $C(f)$ per task; if it maps at random, expectations also run over its draws. For a compute budget $B$, the best policy within the budget is $f^\star_B$, and its score $\mathcal I(B)$, read as a function of the budget, is the **intelligence curve** of (1.1). One policy on one task family is a skill; intelligence is the curve. *See also: §1.2; §3.1.* **1:4** $$ f^\star_B=\arg\max_{f:\,C(f)\le B}\ \mathbb E_{x\sim\mathcal D}\big[V\big(x,f(x)\big)\big],\qquad \mathcal I(B)=\max_{f:\,C(f)\le B}\ \mathbb E_{x\sim\mathcal D}\big[V\big(x,f(x)\big)\big] \tag{1.1} $$ *See also: Definition 1.1; Proposition 1.1.* **1:5** Three features of (1.1) carry most of the later argument. The first is that it is a curve. $\mathcal I(B)$ never falls as $B$ grows, because every policy that fits a budget fits any larger one. A more intelligent system has a higher curve, and a cheaper model that reaches the same score at a lower budget has raised the curve at the budgets where most tasks are bought (§3.1). *See also: Definition 3.1; Forecast 1.1.* **1:6** The curve is steep even on a benchmark built to resist bought skill. In December 2024, OpenAI's o3 scored 75.7% on the semi-private set of ARC-AGI-1 within the public leaderboard's \$10,000 compute limit, and 87.5% in a configuration that used about 172 times as much compute ([ARC Prize, "OpenAI o3 Breakthrough High Score on ARC-AGI-Pub"](https://arcprize.org/blog/oai-o3-pub-breakthrough)). One model had two scores, one per budget. *See also: 1:5; 1:12.* **1:7** The second feature is that the curve is relative to a distribution. Change $\mathcal D$ and two policies can swap places: a model that is strong at olympiad geometry can be weak at tax law. The third is that it is relative to a verifier. The objective contains $V$, and the correct answers $\mathcal Y^\ast$ enter only through it, so a learner can optimize only what can be checked. Where $V$ is cheap and faithful, compute turns into competence. Where it is expensive, noisy or open to reward hacking, more compute buys little. *See also: Definition 1.2; Definition 1.3; §2.5.* **1:8** Without the budget, (1.1) is the objective of reinforcement learning with the verifier as reward. A one-step problem observes $x\sim\mathcal D$, emits $y$ and is paid $V(x,y)$; a multi-step agent replaces $y$ with a trajectory and $V$ with a check on its outcome. Jason Wei put the equivalence in one line: "In RL terms, ability to verify solutions is equivalent to ability to create an RL environment" ([Wei, "Asymmetry of verification and verifier's law"](https://www.jasonwei.net/blog/asymmetry-of-verification-and-verifiers-law)). It is the training objective of the reasoning models of 2025, whose record is in §2.6. *See also: §2.6; Proposition 2.3.* **1:9** Training against a verifier, with a penalty that keeps the policy near its base, has a closed-form optimum: the base policy's probabilities, tilted toward the answers the verifier accepts (Proposition 2.3). The tilt cannot create an answer the base policy never produces, and it favors whatever the verifier accepts, correct or not (Proposition 1.1). A trained map is a prior reshaped by a verifier, and both have to be good. *See also: Proposition 2.3; Proposition 1.1; §2.3.* ### 1.2 Where the definition sits **1:10** The map from tasks to answers is the standard formalism for a task, and the standard definitions of intelligence sit one level above it. Shane Legg and Marcus Hutter's informal version is "Intelligence measures an agent's ability to achieve goals in a wide range of environments." Their formal version sums a policy's performance over every computable environment and weights each environment by its simplicity ([Legg & Hutter, "Universal Intelligence"](https://arxiv.org/abs/0712.3329)): $$ \mathcal I_{\mathrm{LH}}(f)=\sum_{\mathrm{env}}2^{-\lvert\mathrm{env}\rvert}\,\mathrm{reward}_{\mathrm{env}}(f) $$ Here $\lvert\mathrm{env}\rvert$ is the length in bits of the shortest program that generates the environment, its Kolmogorov complexity, and $\mathrm{reward}_{\mathrm{env}}(f)$ is the expected total reward the policy earns there. Ashby's reading of intelligence as appropriate selection reaches the same level from cybernetics (§4.2). *See also: Definition 1.1; §4.2.* **1:11** (1.1) restricts Legg and Hutter's sum in three ways: a task distribution someone chose replaces the weighting by simplicity, a verifier replaces reward, and a compute budget is added. $\mathcal I_{\mathrm{LH}}$ is incomputable, because Kolmogorov complexity is; $\mathcal I(B)$ can be measured. The price of measurability is parochialism. The curve measures ability on the tasks someone thought to verify, which makes the choice of verifiers a strategic act. Generality is the curve averaged over task families with weights set by economic value, a priced version of the same sum, because an economy pays for solving valuable problems and Legg and Hutter's weights favor simple ones. *See also: 1:10; §2.5; §12.8.* **1:12** François Chollet puts intelligence higher still: "The intelligence of a system is a measure of its skill-acquisition efficiency over a scope of tasks, with respect to priors, experience, and generalization difficulty." His reason is that "unlimited priors or unlimited training data allow experimenters to 'buy' arbitrary levels of skills for a system, in a way that masks the system's own generalization power" ([Chollet, "On the Measure of Intelligence"](https://arxiv.org/abs/1911.01547)). (1.1) measures a skill at a moment. Chollet's quantity measures how fast a learner raises its curve per unit of experience on tasks unlike the ones it trained on. Harvesting solved examples raises the first (§2.3), and recursive self-improvement is a claim about the second (§11.1). *See also: §2.3; §11.1; Proposition 2.1.* **1:13** Skill can be bought on Chollet's own benchmark. The MIT and Cornell entry that reached 47.5% on ARC-AGI-1's semi-private set in 2024 "improved after training on 400k synthetically-generated ARC tasks" ([ARC Prize, "2024 Progress on ARC-AGI-Pub"](https://arcprize.org/blog/2024-progress-arc-agi-pub)). Synthetic tasks raised skill on the benchmark's distribution. Whether such skill transfers to tasks unlike them is the question Chollet's definition asks, and (2.2) bounds the answer. *See also: 1:12; (2.2); Definition 2.2.* **1:14** Leonid Levin's universal search is the limit of finding by search. To find $y$ with $V(x,y)=1$, run every program $f$ in parallel, giving each a share $2^{-\lvert f\rvert}$ of the time, where $\lvert f\rvert$ is its length in bits. If some program solves $x$ in time $t_f(x)$, the search succeeds within $$ T_{\mathrm{Levin}}(x)\le2^{\lvert f\rvert+1}\,t_f(x) $$ ([Levin 1973](https://www.mathnet.ru/php/archive.phtml?jrnid=ppi&option_lang=eng&paperid=914&wshow=paper); [Scholarpedia, "Universal search"](http://www.scholarpedia.org/article/Universal_search)). The search is optimal up to the factor $2^{\lvert f\rvert}$, the price of not knowing which program to run. A trained policy is a prior that puts its mass on good programs, so training shrinks the factor, and knowledge replaces enumeration. The search consults a verifier at every step: without a verifier there is no universal search. *See also: Definition 2.1; 1:29.* **1:15** The fourth classical view equates prediction with compression. By arithmetic coding, a model that gives the next symbol probability $p$ becomes a lossless code that spends $-\log_2p$ bits on it, and any such code is a model. Grégoire Delétang and colleagues showed how far this reaches: Chinchilla 70B, trained mainly on text, compresses ImageNet patches to 43.4% of their raw size and LibriSpeech samples to 16.4%, beating PNG (58.5%) and FLAC (30.3%) ([Delétang et al., "Language Modeling Is Compression"](https://arxiv.org/abs/2309.10668)). In the terms of (1.1), pretraining is the case in which the verifier is free. The corpus supplies the task (the context) and the answer (the next token), and the check is a lookup. That verifier costs nothing, and its supply is finite (§2.7). *See also: §2.7; Definition 1.3.* ### 1.3 Sound verifiers **1:16** A verifier can err in two directions, and training tolerates only one of them. *See also: Proposition 1.1.* **1:17** **Definition 1.2 (Soundness and completeness).** **Soundness** means $V(x,y)=1\Rightarrow y\in\mathcal Y^\ast(x)$: the verifier never accepts a wrong answer. Completeness means $y\in\mathcal Y^\ast(x)\Rightarrow V(x,y)=1$: it never rejects a right one. A verifier with these properties is *sound* and *complete*. The true success of a policy is $U(f)=\Pr_{x\sim\mathcal D}\big[f(x)\in\mathcal Y^\ast(x)\big]$, and its verified success is $\hat U(f)=\mathbb E_{x\sim\mathcal D}\big[V\big(x,f(x)\big)\big]$. *See also: Definition 1.1; (1.2).* **1:18** Splitting the event $V=1$ by whether the answer is correct gives an exact identity: $$ \hat U(f)-U(f)=\epsilon_{+}(f)-\epsilon_{-}(f),\qquad \epsilon_{+}=\Pr\big[V=1,\ f(x)\notin\mathcal Y^\ast(x)\big],\quad \epsilon_{-}=\Pr\big[V=0,\ f(x)\in\mathcal Y^\ast(x)\big] \tag{1.2} $$ *See also: Definition 1.2.* **1:19** Here $\epsilon_{+}$ is the verifier's false-accept mass and $\epsilon_{-}$ its false-reject mass. A sound verifier has $\epsilon_{+}=0$, so it can only under-credit: $\hat U\le U$ for every policy. An incomplete verifier wastes signal, and an unsound one can be inflated. *See also: (1.2); Proposition 1.1.* **1:20** **Proposition 1.1 (Soundness is what a training signal must keep).** (i) If $V$ is sound, every rise in $\hat U$ certifies a rise in a lower bound on $U$. (ii) If $V$ is unsound and the policy class can reach its false accepts, a maximizer of $\hat U$ need not maximize $U$, and an optimizer held to a budget may prefer reaching false accepts to solving. (iii) If $V$ is complete, the share of accepted answers that are correct is $$ \frac{U}{\hat U}=\frac{U}{U+\epsilon_{+}}, $$ which falls below one half once $\epsilon_{+}>U$. For a verifier that accepts each wrong answer with a fixed probability, this happens roughly once the policy's success rate falls below that probability. There most rewarded behavior is the hack, and training reinforces it. **Proof.** (i) is (1.2) with $\epsilon_{+}=0$, which gives $U\ge\hat U$ for every policy. For (ii), take any policy $f$ and a policy $f'$ that agrees with it except on a share $s_{\mathrm{fa}}$ of tasks where $f$ answers wrongly and is rejected; there $f'$ emits a wrong answer that $V$ accepts. Then $\hat U(f')=\hat U(f)+s_{\mathrm{fa}}$ while $U(f')=U(f)$. If reaching those false accepts costs less compute than solving, the budget in (1.1) can make $f'$ preferable to a policy with higher $U$, and an optimizer that sees only $V$ cannot tell them apart. For (iii), completeness gives $\epsilon_{-}=0$, so every correct answer is accepted and $\hat U=U+\epsilon_{+}$. If $V$ accepts each wrong answer with the same probability, $\epsilon_{+}$ is that probability times $1-U$, and $\epsilon_{+}>U$ exactly when $U$ is below that probability divided by one plus it. *See also: (1.2); §2.6; §12.6.* **1:21** Proposition 1.1 is Goodhart's law stated for verifiers. In Marilyn Strathern's wording, "When a measure becomes a target, it ceases to be a good measure" ([Strathern, "Improving ratings: audit in the British University system"](https://www.cambridge.org/core/journals/european-review/article/improving-ratings-audit-in-the-british-university-system/FC2EE640C0C44E3DB87C29FB666E9AAB), 1997). An optimizer sees only the verifier, so the pressure of training flows to wherever the verifier and the truth disagree, and the measured record of that pressure is in §2.6. The builders of training environments interviewed for Epoch AI's January 2026 survey ranked reward hacking as their first quality concern, and one put the proposition in a sentence: "Soundness matters most: high reward must mean the task was actually solved, not hacked" ([Epoch AI, "An FAQ on Reinforcement Learning Environments"](https://epoch.ai/gradient-updates/state-of-rl-envs)). *See also: Proposition 1.1; §2.6; §2.7; §8.7.* **1:22** The soundness a verifier needs grows with the intelligence it trains. A verifier that checks the defining rules of a task, such as the Sudoku constraints or a proof assistant's kernel, has a false-accept set that is empty or small enough to audit (§2.2). A verifier that compares against a stored answer, or is itself a learned model, has false accepts, and a more capable optimizer reaches more of them. So verification and alignment become one problem at the frontier: a value that cannot be checked cannot be optimized directly, and a verifier open to reward hacking will be hacked by a strong enough optimizer (§13.3; §13.4). *See also: §4.6; §2.9; §13.3; §13.4; Forecast 1.2.* ### 1.4 The cost triangle **1:23** Whether a task family is cheap to learn is set by three costs and how they compare. *See also: §2.5.* **1:24** **Definition 1.3 (The cost triangle).** For a task family with verifier $V$, measure three costs in one unit (elementary operations, FLOPs or dollars): $c_{\mathrm{ver}}$ to check a given candidate, $c_{\mathrm{con}}$ to construct a solved pair $(x,y)$ with $y\in\mathcal Y^\ast(x)$, usually backward from $y$, and $c_{\mathrm{sol}}$ to find an accepted $y$ from $x$ alone. Reinforcement learning harvests the ratio $c_{\mathrm{sol}}/c_{\mathrm{ver}}$, the verification asymmetry of Definition 2.1; supervised learning harvests $c_{\mathrm{sol}}/(c_{\mathrm{con}}+c_{\mathrm{ver}})$, as in (2.1). *See also: Definition 2.1; (2.1); Experiment 2.1; Experiment 2.2.* **1:25** Each ratio is an asymmetry (Definition 0.1), finding against checking in one case and finding against building and checking in the other, and the two ratios name two harvests. A reward is a verifier, so reinforcement learning needs only a cheap check. This is the picture of the class NP, where checking a certificate takes polynomial time and finding one may take exponential time. A labeled example needs the answer itself, so supervised learning needs a cheap construction: draw the answer first, then derive its problem. Some families have neither. In taste, strategy, research judgment and values, checking an answer costs about as much as producing it, or no verifier is well defined, and these families resist both harvests (Proposition 2.2; §13.3). *See also: Proposition 2.2; §2.4; §13.3; §12.1.* **1:26** The three costs bound one another through the solver. A solver that samples until the verifier accepts pays for at least one check per try, and its cost of finding falls as its pass rate rises, so the verification asymmetry is largest for a weak policy and shrinks as the policy learns (Definition 2.1). Learning closes the asymmetry for the learner, which is the book's thesis in its first and simplest case (§0.3). Experiment 2.1 and Experiment 2.2 measure all three costs in one unit. *See also: Definition 2.1; §0.3; Experiment 2.1; Experiment 2.2.* ### 1.5 Mapping is harvesting **1:27** To map an intelligence is to harvest solved pairs where checking and building are cheap and finding is dear. A supervised training set is a finite sample from the graph of the map it teaches: pairs $(x,y)$ with $y$ correct for $x$. A graph can be sampled from either end. From the task end, draw $x\sim\mathcal D$ and pay $c_{\mathrm{sol}}$, or a person, to find $y$. From the answer end, draw $y$ from a prior you control and derive its problem with a cheap forward map: differentiate a function to pose an integral, carve cells out of a filled grid, inject a bug into working code (Definition 2.2). That costs $c_{\mathrm{con}}$, and harvesting means sampling from this end wherever $c_{\mathrm{con}}$ is far below $c_{\mathrm{sol}}$. The catch is that an answer-end sample follows the designer's distribution, and the world's differs ((2.2)). *See also: Definition 2.2; (2.2); §2.3; §2.4.* **1:28** At inference time a verifier converts compute into intelligence directly: draw $n$ candidates and return one the verifier accepts. Bradley Brown and colleagues ran DeepSeek-Coder-V2-Instruct on SWE-bench Lite, a set of real GitHub issues, and counted an issue solved when any attempt passed its unit tests. With one attempt it solved 15.9%; with 250 it solved 56% ([Brown et al., "Large Language Monkeys"](https://arxiv.org/abs/2407.21787)). On math problems, where they picked answers without an automatic verifier, majority voting and reward models "plateau beyond several hundred samples." Sampling buys coverage (Proposition 2.3), and soundness decides how much of the coverage is real (Proposition 1.1). *See also: Proposition 2.3; Proposition 1.1; Proposition 7.3; §9.5.* **1:29** Every object defined so far has a verifier inside it. (1.1) contains $V$; universal search consults a verifier at every step; reinforcement learning needs a reward, and a verifiable reward is a verifier; best-of-$n$ sampling is only as good as its verifier is sound. Backward construction seems to need none, because its pairs are correct by construction, but a constructor is a verifier with privileged access to the answer. Whoever owns a cheap, sound verifier for a task family owns a training signal for it. A verifier is a capital good: built once, as a test suite, a proof kernel, a game engine, a digital twin, a wet lab or a profit-and-loss statement, it turns compute into capability until the family saturates. Andrej Karpathy's version takes two lines: "Software 1.0 easily automates what you can specify. Software 2.0 easily automates what you can verify" ([Karpathy, "Verifiability"](https://karpathy.bearblog.dev/verifiability/)). *See also: 1:14; 1:8; 1:28; §2.8; §16.3; Forecast 16.1; Forecast 3.3.* **1:30** Verifiability is the $v_k$ of the master equation (0.2), and (1.1) says why it multiplies the closing rate. Intelligence is defined only relative to a verifier, so intelligence supply aimed at a family with no verifier has nothing to optimize and closes nothing, however large it is (§0.4). *See also: (0.2); §0.4; §14.3.* **1:31** The product makes the frontier jagged. Karpathy calls verifiability "what's driving the 'jagged' frontier of progress in LLMs": verifiable tasks "progress rapidly," while creative and strategic tasks, and those that combine "real-world knowledge, state, context and common sense," lag ([Karpathy, "Verifiability"](https://karpathy.bearblog.dev/verifiability/)). Wei predicted "a jagged edge of intelligence, where AI is much smarter at verifiable tasks" ([Wei, "Asymmetry of verification"](https://www.jasonwei.net/blog/asymmetry-of-verification-and-verifiers-law)). Ranked by their verification asymmetry (Figure 2.3), task families give the order in which the intelligence curve should climb. *See also: Figure 2.3; 1:30; Forecast 1.3.* **1:32** The ranking also shows where the other asymmetries take over. Where the verifier is a human expert, verification inherits human latency and headcount (§5.1; §8.3). Where it is the physical world, it inherits physical inertia (§15.2). Where it is a stored key, verification becomes a security problem (§12.6). I place frontier AI research near the judgment end of the ranking, so the research loop runs through one of the hardest families to check (§11.1; §11.5). *See also: §5.1; §8.3; §15.2; §12.6; §11.5; Figure 5.3; §14.3.* **1:33** If intelligence is a curve, evaluations should report curves. ARC Prize already requires them: "Due to variable inference budget, efficiency (e.g., compute cost) is now a required metric when reporting performance," it wrote when it published o3's two scores ([ARC Prize](https://arcprize.org/blog/oai-o3-pub-breakthrough)). A single headline number is easier to sell than a curve, so I put its spread to model launches at two in five. *See also: 1:5.* **1:34** **Forecast 1.1 (Intelligence reported as a curve).** By the end of 2028, frontier model launches report their headline evaluations as curves, each score tied to the compute, cost or reasoning budget that produced it, and models are compared by where their curves cross. **Horizon:** 2028-12-31 **Probability:** 40% **Check:** Take the latest flagship launch of OpenAI, Anthropic, Google DeepMind and xAI on 31 December 2028. The forecast holds if at least three of the four report most headline benchmark results at three or more stated budgets, or as plots of score against cost or compute. It fails if most headline results are still single scores with no budget attached. *See also: 1:5; (1.1).* **1:35** If the soundness a verifier needs grows with capability, so does the cost of keeping it. OpenAI's August 2026 post on pacing model development put numbers on that cost: "a two-week pause in reinforcement learning (RL) training on our latest models intended for deployment while we further hardened and red-teamed our research environments," and monitoring that costs "roughly 20% of the inference compute being monitored" ([OpenAI, "Pacing model development in an era of cyber-critical capabilities"](https://openai.com/index/pacing-model-development-cyber-capabilities/)). I take those as the baseline as of October 2026. The argument for the forecast is strong and labs disclose little, so I put it a little under even. *See also: 1:22.* **1:36** **Forecast 1.2 (Verifier hardening grows with capability).** By the end of 2028, a frontier lab discloses that hardening verifiers (red-teaming environments, isolating answer keys, monitoring runs) costs more than the roughly 20% of monitored inference compute that OpenAI reported in August 2026, as the cost of keeping verifiers sound rises with capability. **Horizon:** 2028-12-31 **Probability:** 45% **Check:** Read the frontier labs' system cards, safety reports and engineering posts published through 2028. The forecast holds if a lab discloses a hardening or monitoring overhead above 20% of the compute it hardens or monitors; it fails otherwise. *See also: 1:22; Proposition 1.1; §2.6.* **1:37** Judgment still lacks a cheap sound verifier (2:46). I put the jagged order at about two in three through 2028. The likeliest way it fails is transfer: skill learned on verifiable work spilling into judgment without a verifier of its own, which would add a term the master equation lacks. *See also: 1:30; 1:32; 2:46.* **1:38** **Forecast 1.3 (The frontier stays jagged).** Through 2028, capability gains keep the order of verifiability: formal mathematics and tested code improve fastest, open-ended judgment (long-form writing, strategy, research taste) slowest, and the distance between them widens while judgment lacks a cheap sound verifier. **Horizon:** 2028-12-31 **Probability:** 65% **Check:** Take the hidden-test code benchmark and the expert-graded judgment benchmark with the most frontier-model results at both dates, such as SWE-bench Pro and GDPval, and compare the share of remaining headroom each closed from the end of 2026 to the end of 2028, counting headroom up to the share of tasks its maintainers have verified as solvable. The forecast fails if the judgment benchmark closed as large a share or larger without first gaining an automated grader that agrees with its human experts about as often as they agree with each other; it holds otherwise. *See also: Figure 2.3; 1:30; Forecast 2.2.* ## 2. Checking is cheap **2:1** Where checking a solution is far cheaper than finding one, and solved problems can be built backward from their answers, the training signal for a machine costs almost nothing, so those task families fall to machines first. Hard solved problems exist only if one-way functions do, the useful ones sit near a phase boundary, and once generation is nearly free, the check becomes the scarce input. *See also: §0.3; Definition 2.1; Proposition 2.1; Proposition 2.2; (2.3).* **2:2** The ratio is already large in a newspaper puzzle. Checking a filled 9×9 Sudoku grid against its rules takes 243 cell reads; finding the grid from 26 clues took a naive search a median of 593,190 reads, about 2,400 checks (Experiment 2.1). Verification is the first of the four speeds named in §0.3: in the master equation (0.2) it is the term $v_k$, which multiplies the closing rate of each gap, and a cheap, sound check is what raises it. *See also: Experiment 2.1; (0.2); Definition 1.1.* ### 2.1 The coefficient **2:3** The verification asymmetry measures how much cheaper checking is than finding, and it belongs to a task and a solver together, so training turns it down. *See also: Definition 1.3; Definition 1.1.* **2:4** **Definition 2.1 (Verification asymmetry).** For a task family with distribution $\mathcal D$ and a given solver, the **verification asymmetry** of a task $x$ is $$ \alpha(x)=\frac{c_{\mathrm{sol}}(x)}{c_{\mathrm{ver}}(x)}, $$ the cost of finding an accepted solution from $x$ alone over the cost of checking a candidate. The family is asymmetric when $\mathbb E_{\mathcal D}[\alpha]\gg1$. The ratio is relative to the solver: largest for a weak policy, and falling as the policy learns. **2:5** This is the NP picture. For a problem in NP a proposed solution can be checked in polynomial time, while finding one may take exponential time unless P = NP. A reward function is a verifier, so reinforcement learning needs only this ratio: it pays $c_{\mathrm{ver}}$ for each signal and collects what finding would have cost. Supervised learning needs the solution itself, a second product priced in (2.1). *See also: Definition 1.1; (2.1); §2.6.* **2:6** > "It's really hard to generate a correct solution, but it's much easier to recognize when you have one. I think all problems exist on the spectrum from really easy to verify relative to generation, like a Sudoku puzzle, versus just as hard to verify as it is to generate a solution, like naming the capital of Bhutan." Noam Brown of OpenAI, on Sequoia's [Training Data podcast](https://sequoiacap.com/podcast/training-data-noam-brown/). *See also: §2.5.* **2:7** The position of a task on that spectrum moves with the solver. Against a naive backtracking search, a Sudoku at its hardest has an $\alpha$ of about 2,400, and against a search that branches on the most constrained cell, 113 to 164 (Experiment 2.1); against a solver that propagates constraints it is 10 to 20 (Figure 2.3). Every gain in the policy lowers $c_{\mathrm{sol}}$ and leaves $c_{\mathrm{ver}}$ where it was, so a family is most asymmetric for the weakest learner and least for one that has mastered it. *See also: Experiment 2.1; Figure 2.3; Proposition 2.3.* **2:8** A large $\alpha$ helps only a learner that can use it. Song and colleagues found that "despite the exponential computational complexity separation between generation and verification in generalized sudoku, most models fail to self-improve" ([Mind the Gap](https://arxiv.org/abs/2412.02674)). The ratio pays when the verifier is supplied from outside and the learner already reaches an accepted answer some of the time, the two conditions of Proposition 2.2. *See also: Proposition 2.2; Proposition 2.3.* ### 2.2 Sudoku, measured in one unit **2:9** Counted in one unit, the cell read, the three costs of a 9×9 Sudoku come out $c_{\mathrm{ver}}