Verified knowledge, never silently lost.

A modern model can absorb an ocean of data and still hold nothing it can stand behind. What it learns is rarely checked, and what does get checked is rarely kept — the next round of training can quietly revise it. Capabilities appear and vanish between versions; correct behavior decays into confident error; and nowhere in the system is there a ledger that says which gains are real and which have already slipped away.

The name for the sharpest form of this is nearly as old as neural networks' modern revival: catastrophic forgetting, identified in 1989, when it became clear that a network trained on new material overwrites the old. Almost four decades of mitigation — replay buffers, regularization penalties, parameter isolation — has treated the symptom while leaving the cause in place. The cause is that knowledge in these systems has no native unit. Interpretability can sometimes locate a fact after the fact, and isolation methods can fence off parameters — but frozen weights only persist; they cannot be pointed to and tested. Nothing in the learning process itself produces an object that can be checked and, once checked, held.

Scale softens the symptom — larger pretrained models forget more slowly — but it converts no gain into a guarantee. A statistical tendency to retain is not a record of what was retained. Nor does moving knowledge out of the weights settle the matter: a retrieval store gives facts a location, and a long context gives a theory formed on the fly a temporary home, but neither gives knowledge a license. Nothing verifies a retrieved passage; text in a database does not compose into a simulator you can run forward; and a theory held in context evaporates at the end of the session and must be paid for again at the next one. Storage is not the hard part. Verified, compounding, load-bearing knowledge is.

That is the property this document argues for, and the argument runs in one line: accumulation requires a unit of knowledge that can be verified, and only certain kinds of learned structure can be. What follows is our case for what that structure is — and the unclaimed problem at the center of it.

Start from a different question: not how much can a system absorb, but how little does it need. A person sitting down at an unfamiliar game forms a working theory of its rules within a handful of tries — what the pieces are, what actions do, what the world will and won't permit. No reward signal has arrived yet. No dataset exists. And the theory, once formed, transfers: change one rule and a person adjusts that rule, not their entire understanding.

We adapt François Chollet's framing here: intelligence measured not by skill but by the efficiency with which experience is converted into a theory of the environment. By that measure, a system that needs millions of samples to learn what a child gets in ten has not understood more; it has understood less, expensively.

Efficiency at that level is not available from a blank slate. A learner that assumes nothing must consider everything, and drowns. The escape is old: Kant argued that experience is only possible at all because some organizing structure — objects, causes, space, time — is supplied by the mind rather than extracted from the data. The developmental psychologists who mapped Core Knowledge — Elizabeth Spelke above all — found the computational version in infants: a small set of innate primitives (objectness, contact causality, agency, number) that every human brings to every new world, and that make five examples enough. Chollet placed those priors at the base of ARC; we build with priors of this kind deliberately. Not a large ontology of facts — a small vocabulary of structure, chosen because it is what makes fast theory-formation possible at all.

What should a system do with its handful of interactions? Our answer: build a world model — but that term has come to mean too little. A video predictor is a world model in the weak sense: it continues the surface of things. We mean something stronger. A world model should be a causal simulator — a model you can interrogate, not merely sample from. Any action-conditioned model can answer what happens if I do this; the harder question is what happens if the world worked differently — change one rule and watch the consequences propagate. That question can only be asked of a model in which rules exist as addressable objects.

Judea Pearl spent a career making the underlying distinction exact: seeing, doing, and imagining are different grades of knowledge, and no amount of the first — absent causal assumptions — entails the second. We treat Pearl's ladder as the bar a world model must clear. But Pearl's machinery begins where the hard perceptual problem ends: it assumes the causal variables are already given. A learner facing raw observation is not given variables; pixels are not causes. The method for crossing that gap comes from the younger discipline of causal representation learning: Pearl identifies a causal effect given the variables; causal representation learning identifies the variables themselves.

This reframes what representation learning is for. An entangled embedding compresses the world without factoring it — genuinely useful for prediction and transfer, as a decade of deep learning attests, but mute under intervention: no direction in it can be independently tested, protected, or revised. The goal is a representation whose axes are the environment's causal variables. The lesson of the identifiability literature is that recovering such variables always costs an assumption — and interaction is the assumption we choose to pay with, because an agent gets it for free. Acting on the world breaks symmetries that passive observation leaves standing. A variable earns its place in the model by its distinct signature under action — the address of a variable is how you act on it.

Recovering the true variables is expensive, and the reason to pay is transfer. When the world changes, it almost never changes wholesale — a couple of mechanisms shift and everything else stands (the principle the causal literature calls sparse mechanism shift). A model built on the real variables localizes the change, revises the mechanism that moved, and keeps the rest. A model built on entangled features must relearn broadly, because in its coordinates the small change is smeared across everything. Fast adaptation is not a trick to add later; it is a property of having factored the world correctly.

A causal simulator still needs a substrate, and the choice of substrate decides whether knowledge can be verified. We write each learned law as a discrete program — a small, explicit rule that can be read, executed against new observations, and put to a test it can fail. Not because symbols are sacred, but because programs have the two properties weights lack: they are inspectable, and they are checkable. In worlds with crisp rules the check is exact; in noisy worlds it is statistical, with the acceptance criterion stated in advance — but in both cases verification stops being a hope about a black box and becomes a concrete test you can run. Environments with discoverable, testable laws — games, puzzles, simulated worlds, instrumented systems — are where this program starts; the open, messy end of the physical world is its frontier, not its first claim.

Programs bring a second gift: composition. A vocabulary of small laws can be combined into theories of situations never seen — and, in the other direction, recurring compositions can be abstracted into new vocabulary, the way a working scientist coins a concept for a pattern they keep re-deriving. The program-synthesis line of research (DreamCoder is the clearest statement) shows the loop concretely: solve with the vocabulary you have, then compress what worked into the vocabulary you keep. Detail lives in the programs you compose, not in the size of the library you store. The cost is equally concrete — search over programs explodes with depth, and a growing library buys shorter solutions at the price of a wider search — and taming that explosion is one of the debts our approach must pay, not a solved input to it.

Inside this program sits a problem we believe is unclaimed — though it has serious neighbors, and naming them is the honest way to locate it. Causal representation learning identifies variables under generous conditions: known intervention structure, plentiful data, offline analysis. Curiosity-driven reinforcement learning explores without any extrinsic reward, but what it learns is a policy or an entangled dynamics model, defined over a state vocabulary fixed in advance. Theory-based reinforcement learning induces genuine rule-theories of new games at human-like sample efficiency — but takes the object ontology as given. Open-world and novelty-detection research recognizes that something changed; symbol construction and predicate invention posit new terms, but offline, with a task already in hand.

What no line of work takes as its central object is the conjunction: something surprising happens, before any reward exists, and the learner must posit a new state variable on the spot — decide that the world contains a thing it was not tracking, work out what kind of thing it is and how it relates to what is already known, and start testing laws about it within a few interactions. People do this constantly; it is most of what "figuring out a new game" means. It is also precisely what today's systems are missing in the wild: the robot that flails in any home it was not trained in, and the agent that meets an unfamiliar interface and cannot form a theory of its state, are both failing at first contact — not at skill, at ontology. That gap — first-contact variable discovery — is the problem Ratchet Labs is organized around. Solve it and the rest of the stack has something to accumulate; skip it and every downstream component inherits variables that are subtly wrong.

Now assemble the pieces. Laws written as programs can be tested. Tested laws can be verified against the world the learner actually inhabits — each one carrying the scope it was verified in. And a verified law can be given the guarantee weights cannot offer: it can never be silently lost. In a changing world, verification is always provisional — a law that held can stop holding, a variable can turn out to be two — and a learner that could never revise would only accumulate error. So the guarantee is not that the wheel never moves; it is that it never slips. A verified law is retired only by an explicit act, on refuting evidence, with the record of what held, where, and until when preserved. New knowledge can always be added; proven knowledge can be superseded, but never erased by the mere arrival of more learning. Accumulation stops being a statistical tendency and becomes a structural property — the pawl drops behind the tooth.

That mechanism is a ratchet, and it is what we are named for. It is our answer to catastrophic forgetting: not a mitigation bolted onto a finished artifact, but accumulation built into the architecture from the start — continual learning by construction rather than by luck.

We hold this thesis with our eyes open, and it helps to say what would count against it. The dominant alternatives are serious. Latent-predictive world models in the JEPA family bet that predicting in a learned representation space — which forces the encoder to discard what doesn't matter — yields the needed abstraction implicitly, with no explicit variables or program library; their latents demonstrably capture real structure, and our reply is not that they learn nothing but that what they learn cannot be individually verified, protected, or revised. Value-equivalent models in the MuZero line bet that a world model need only be accurate about what affects value — a principled relevance filter; ours is different: surprise under action decides which variables deserve to exist, because we want theories that survive a change of task, which is exactly what reward-relevance does not buy. And the Bitter Lesson — that general methods leveraging computation, learning and search, ultimately beat built-in human domain knowledge — stands as a permanent audit on everything above. We are, in fact, betting on its second pillar: program induction is search, and the ratchet exists to make search's gains cumulative. But a prior vocabulary is domain content, and we accept that debt explicitly: every prior we keep must pay for itself in measured sample efficiency against its own ablation, and a prior that stops paying is retired.

So the thesis is falsifiable, and we intend to test it in public: build learners that meet unfamiliar worlds; measure the interactions they need to induce each law against the strongest latent-world-model baselines; audit, under continued learning, that nothing verified is ever silently lost — and publish what breaks. If explicit variables, checkable laws, and a one-way gate on verified knowledge do not deliver faster theory-formation and more durable accumulation than the alternatives, that result matters too, and we will say so.

If this is the question that keeps you up as well, write to us: hello@ratchetlabs.ai.

Forward only.