Skip to content
Compounding Intelligence

Thesis

AI is still improved primarily by people.

A researcher finds a bottleneck, designs a change, runs an experiment, interprets the result, and decides what to try next. Every step of that loop is a candidate for automation, and the last one is the only one that compounds.

The pitch

Almost everyone building recursive self-improvement today works in verifiable domains: code, math, kernels, competitive programming. That is not a coincidence, it is a selection criterion. Those domains ship with an environment attached. The interpreter supplies the dynamics and the test suite supplies the reward, so the researcher gets the hard half of the problem for free and can spend all of their effort on the search.

  • World Models

    Ha and Schmidhuber, 2018 · Car racing, VizDoom

    The game score

  • Generative Agents

    Park et al., 2023 · A simulated town

    Human raters, judging believability

  • The AI Scientist

    Lu et al., 2024 · Machine learning research

    An automated reviewer

  • AlphaEvolve

    Novikov et al., 2025 · Algorithms, kernels

    An evaluation function, written by people

  • Darwin Gödel Machine

    Zhang et al., 2025 · Coding agents

    SWE-bench and Polyglot

  • Compounding Intelligence

    High-GDP open worlds

    Nothing is given. We build the grader.

Recent results we admire, and what grades each attempt. Every one of them picked a domain that grades itself.

We are choosing the regime where you get none of it for free.

A · VERIFIABLE DOMAIN attempt interpreter test suite loop closes in seconds grader given
B · OPEN WORLD t + 90 days the world, reacting policy outcome ? grader loop closes in months grader not given. We build it.

The same improvement loop in two regimes. On the left, every attempt is graded for free within seconds. On the right, the loop runs through other actors, closes months later, and the grader is the node nobody hands you.

Strip the given environment away and three ingredients remain. Two of them everyone needs. One of them only we have to build.

  • World the environment it acts in. A simulator of complex, critical, high-GDP systems that improves its own fidelity, and knows what its fidelity is.
  • Agent the thing that acts. A system that rewrites everything about itself.
  • Infrastructure the machine both run on. A stack that makes frontier training faster and provably correct, and that tunes itself.

The line between the last two is worth stating once, because it is the one people blur: same computation faster is Infrastructure, different computation better is Agent. An Agent result can never be claimed by making the GPUs go faster.

The near-term value is automated AI R&D: more reliable improvement per unit of research time, compute, and real-world interaction. The long-term ambition is compounding intelligence, where each verified generation is better at producing the next one.

gen 0

Compounding

Generation

00

×1.0 vs gen 0

vs people alone

compounding- - linear

World

Each turn is one generation passing World, Agent, and Infrastructure. Each starts 1.45× further out than the last, so the history behind it keeps shrinking.

Illustrative. The drawing is the ambition, not a result.

Every verified improvement should create a better way to make the next improvement.

Why high-GDP open worlds is the load-bearing phrase

We mean persistent, interactive systems with real economic consequence. Commerce, supply chains, energy, and production planning are examples, and scientific discovery is where it eventually leads. Four properties make these worlds different from benchmarks, and all four are the reason the World pillar exists.

People and markets respond

The environment is not stationary under our own policy. A better policy changes what other participants do, which changes what the policy should have been.

Outcomes arrive late and censored

Decisions can take months to resolve into value, and a large share of that value lands outside any practical attribution window. The reward is not a separate function bolted onto the world. It is a future state of the world, which is why it belongs inside the World pillar rather than beside it.

Objectives conflict

The interests of the participants do not agree, and no scalar reconciles them without a stated tradeoff that is itself a modelling choice.

There is no fixed benchmark

The distribution moves faster than any leaderboard can be refreshed, so a static eval suite silently becomes a measure of last year’s world.

The consequence worth stating plainly: a benchmark is a world model with an unstated and usually false fidelity claim. Everyone doing RSI on a fixed benchmark has a world model. They just have not been asked to defend it.

What qualifies as a pillar

We use a hard admission test, because a criterion that deletes candidate pillars is a good criterion. A pillar is legitimate only if its artifact can be both the subject and the object of an improvement step: representable, so it is explicit and diffable rather than living in a researcher’s head; scored by a non-circular scorer, or you are optimising self-agreement; closed under its own application; and raising the rate of future improvement rather than only today’s level.

The test does real work. It is why there is no fourth pillar called recursion, which is a verb rather than a slot, and no peer pillar called verification, which cannot score itself without either a stronger verifier or an appeal to reality. Verification lives inside World.

One asymmetry from that test is worth carrying through everything else. World and Agent and Infrastructure all convert compute into capability. Fidelity converts reality into license to believe. Different currency, and the second one is rationed. Three of the four things we could improve can improve while getting worse: infrastructure into faster wrong computation, a world into a self-consistent hallucination, an agent into a better metric exploiter. Only the reality-anchored one cannot fake it.

The three phases

Phase 1. Each pillar closes its own loop, independently. Three teams, zero coupling, and nothing here waits on the other two, which is why all three start at once rather than in sequence. The thing Phase 1 hides is worth naming up front: grading each pillar against a fixed target hard-codes fidelity as a constant, so all three will eventually hit the same wall, where saturation becomes indistinguishable from overfitting.

rewrites itself Self-Improving World dynamics, delayed signal, fidelity try score its own fixed grader what really happened, replayed on held-out traces rewrites itself Self-Improving Agent rewrites everything about itself try score its own fixed grader task suites it has not seen, per unit of compute spent rewrites itself Self-Improving Infrastructure fast, and provably correct, at frontier scale try score its own fixed grader wall-clock time, and a check that it ran right
Every loop is graded by something fixed. That is what makes Phase 1 cheap and publishable, and also what caps it.

Phase 2. Agent chooses the experiment, Infrastructure runs it, World says whether it worked and whether that was real. Each pair is a capability neither half has alone, and World + Agent is the pair you can only reach if you built the world first. That is the reason this particular three-way split is not arbitrary.

the experiment to run episodes, at training throughput signal, and a fidelity claim Agent chooses what to change, spend, stop, and keep World says what better means, and whether it was real Infrastructure runs it fast, and proves it ran what we asked fidelity, purchased REALITY money moved · users acted · the policy shipped
Reality sits outside the machine on purpose. It is the only signal the system cannot generate for itself.

Phase 3. The improver turns on itself. Recursion is not a fourth pillar. It is what happens when the same three are pointed inward. There is exactly one test that counts.

meta-gain(t) = improvement produced by generation t, minus improvement produced by generation 0, on the same held-out target system at equal compute.
AI builds better AI for high-GDP open worlds improves itself and again measured against, never replaced by Generation 0 W A I retained, frozen, re-run Generation 1 W A I rewrote its own W, A, and I Generation 2 W A I rewrote all three again, cheaper
Each generation rewrites its own three pillars and is measured against generation zero, which is kept frozen as the control.

Two commitments follow, and they are not optional. Fork, never improve in place, because a system editing its own scaffold is the one case where the thing being improved and the thing doing the improving are the same running process, which makes it both the fastest route to a demonstration and the easiest place to lose the control. And report meta-gain, not level, because a generation that scores higher on an easier target has produced nothing.

What would make us wrong

Stated in advance, because a vision that cannot be falsified is a slogan. If policies trained in our world do not beat log-trained policies when a real experiment checks them, the World pillar’s premise fails and this reduces to better AutoML. If an improver cannot outperform its own frozen ancestor after honest effort, recursion is not available at our scale, and we are an automated-improvement program rather than a compounding one. That is still valuable and it is a different pitch.

One open question would make the whole structure more optimistic rather than less. If patching the shortcuts an agent discovers generalises to shortcuts it has not found yet, then fidelity has a compute-driven improvement channel after all, verification is more self-improvable than we assumed, and the constraint that reality is rationed relaxes. It is cheap to test, so we test it early.