A note before we start

You should know who’s talking to you before you give a book your weekend.

I’m a geek and a tinkerer. I’ve spent my working life building data platforms for banks, telcos, and airports, and these days my day job is building the technical AI foundations for organizations. Back in my big data years, around 2012, a conviction settled in that has shaped everything I’ve built since: the world itself is inherently event-driven. That conviction carried me to the front of event-driven architectures, the art of building software around things that happen rather than things that are, and eventually to Synadia, where I built and researched event-driven AI on top of NATS, a messaging system that moves events between machines.

What I love most sits between fields, taking an idea that’s ordinary in one area and finding out it’s radical in another. This book is that habit pointed at the brain: how it might work, which parts of the excitement around AI are hype, and which parts could quietly become real. Because a brain, whatever else it is, is the most event-driven system there is. Things happen to it, constantly and from every direction at once, and it is never quite the same afterward.

I am not a scientist. I don’t have a PhD, a lab, or a grant. I have a laptop, a stubborn streak, and, lately, an unusual collaborator.

This book is a joint project between me and an AI, and I mean that concretely, not as a confession buried in the acknowledgments. The theory grew out of dialogue: I push an idea, the machine pushes back, and what survives gets written down. Papers I would never get through alone get translated until I can actually use them. Code and prose get drafted faster than I could ever type them. And then comes the part that is entirely mine: deciding what’s true. Nothing in this book survived because it sounded good. Every claim had to pass a bar that was written down before the experiment ran, on runs that reproduce byte for byte, in a record that keeps the failures filed next to the successes. The repository this book grew out of is open, the rules we work by are in it, and a good part of what you’ll read is me being wrong first.

I know how this looks from a distance. A tinkerer, an AI, and a theory of learning: the internet has a shelf ready for that, right between perpetual motion and secret cancer cures. That shelf is exactly why the method is strict. You are not asked to trust me anywhere in this book. Where I claim a measurement, you can rerun it. Where an idea is borrowed, I say whose it was. Where something is unproven, the text says so and moves on.

At the same time, I don’t feel like I have something to prove. I’m convinced there is something in this; you don’t spend this many evenings on a whim. But if smarter people with better tools read it and see further, that isn’t a defeat, that’s the point. I’ll read them gladly. Then I’ll feed them into an AI until they’re understandable to me, because that’s how I read hard things now.

So what qualifies me to work on this? I’m convinced I can do something most other people cannot, and I’m still finding out what that is. This book is part of the finding out.

The story starts with a lawnmower.

The brain in the freezer

I own a robot lawnmower. Every time it sets out across the lawn it finds the same tree trunk, wedges itself against it, spins its wheels, and waits for me to come rescue it. It has been stuck on that trunk more times than I can count. It will get stuck on it again tomorrow.

This bothers me more than it should. The tree is fine. What bothers me is what the getting stuck proves: somewhere in that mower is a brain, and that brain is not learning. It can’t. It was finished before the mower ever saw my garden.

But honestly, what did I expect. Machine brains these days are studying in a lab, on enormous piles of examples. The brain gets better and better at its task. Then, one day, the studying stops and whatever the brain knows at that moment gets copied into the product. From that point on, nothing it experiences changes it. Engineers call this study phase training. I call the copy that ships a “frozen brain”: a snapshot of what was learned, with the learning switched off.

And that’s what’s bothering me; nobody would accept this for a person. It would mean hiring someone whose last day of learning was their final exam. Yet, we accept it for almost every machine.

Under the hood: what “frozen” means precisely. Modern learned systems separate training (weights are updated by gradient descent against a loss) from inference (weights are fixed; the model only computes outputs). Deployment freezes the weights. The failure mode this invites is distribution shift: the deployed input distribution drifts away from the training distribution, and the model’s error grows with no mechanism to respond. Periodic fine-tuning doesn’t change the category. It’s another train-then-freeze cycle, with its own well-known cost: updates on new data overwrite what earlier data taught, unless you keep and replay the old data. That failure has a name, catastrophic forgetting, and it gets a chapter of its own.

To be fair, freezing mostly works. That’s exactly why it’s everywhere. A frozen brain is predictable: you can test it for a thousand hours, and the copy you ship behaves exactly like the copy you tested. It’s also relatively cheap: train once, stamp out a million identical copies. And when it makes a mistake, it makes the same mistake every time, so an engineer can hunt the mistake down and fix it in the next version. A brain that keeps changing has none of these comforts. There’s a reason nobody wants their bank’s software to improvise.

So if the world the machine lives in matches the world it studied, frozen is fine. But the trouble starts when anything moves. And three things move all the time.

• The world changes. Furniture gets rearranged. Seasons change the light in a room. A warehouse gets a new kind of box.

• The task changes. The job you bought the robot for is rarely the job you need next month. A person who can sort packages can learn to stack shelves; a frozen brain cannot learn anything.

• The body changes. This is the sneaky one. Motors wear down. A gripper loses its rubber. Sensors drift out of calibration. My mower’s blades are a little duller every month, so the same motor command cuts a little less than it used to. But the brain steering it is exactly as worn as the day it left the factory, which is to say not at all. The brain’s own body slowly stops matching the body it studied with, and a frozen brain can’t even notice.

The standard answer is: retrain it. Collect new examples, go back to the lab, study again, ship a new snapshot. But look at what that actually is. It isn’t the machine learning: it’s people, redoing the machine’s entire education because the machine can’t take a single lesson on its own. It’s slow, it’s expensive, and in the gap between snapshots the machine keeps confidently (and annoyingly) doing the wrong thing. My mower will park itself against that tree trunk until its maker ships a smarter model, which is to say: forever.

What I want is different, and it’s the reason this whole project exists. I want a brain where every single moment is a lesson. It acts, something happens, and it is permanently, slightly changed by having found out. No study phase, no snapshot, no lab. Learning isn’t a stage of its life; learning is its life, the way it is for anything alive. A puppy isn’t trained and then deployed, although I am pretty sure there is a big market for that.

Just imagine what these continuously learning brains could bring to my little mower. Monday, it wedges itself against the trunk. Tuesday, it gets stuck and something in it registers: “that spot, that approach, stuck again”. Wednesday it swings a touch wider. By Friday it slides past without touching, and nobody told it anything: no update was downloaded, no engineer was involved. If I plant a tree next spring, it gets stuck a few times and adjusts again. None of this is science fiction; a mouse does it effortlessly. The reason your mower doesn’t is a design choice, not a law of nature.

I’ve been building a brain like that. It’s called the Pose Resolution Architecture (PRA), and it runs, today, on worlds ranging from simulated rovers to Minecraft to anything that speaks a robot’s message protocol. This book is the story of building it: what the design is, why it is that way, and which parts of it I got wrong before measurements straightened me out. That last part is not modesty. You’ll see refuted ideas in nearly every chapter, because a claim that has survived a real attempt to kill it is the only kind worth reading about. And I’ll say plainly, when we get to the frontier in the book’s final parts, which claims haven’t faced their attempt yet.

You won’t have to take my word for any of it, either. The system is open source, and in a future chapter, you’ll install it yourself and watch a small rover’s brain learn, live, on your own screen — from first command to watching in about five minutes. A book about a machine that learns in front of you should let it learn in front of you.

I should also say what this book is not about. It is not about chatbots. A system that has read every book about swimming still can’t swim; what’s missing isn’t more books. PRA doesn’t compete with language models at language. Nothing forbids it from learning English, mind you: words you hear and words you say are consequences and actions like everything else, and Part 6 takes that idea seriously. But language would be one more thing it learns, never the thing it is. It competes with frozen brains at the one thing they can’t do by definition: keep learning.

There’s a catch, of course. The moment you ask for a brain that never stops learning, two ugly failures walk in the door. A brain that keeps changing risks erasing the very things it knew. A brain that keeps adding risks growing without limit, hoarding machinery forever. The next chapter is about those two failures. One of them I got to watch happen, in my own system, from the front row.

Forget everything, or remember everything

Ask for a brain that never stops learning and you get pulled toward one of two cliffs. Lean one way and the brain keeps overwriting itself until the old skills are gone. Lean the other way and it keeps adding to itself until it’s an unusable hoard. Most of the field’s history is people falling off one cliff while backing away from the other.

Let’s look down each one.

The first cliff: overwriting

The kind of learned brain that powers today’s AI stores everything it knows in one big shared pool of numbers. Every lesson nudges those numbers. Here’s the catch: the numbers that hold your new lesson are the same numbers holding the old ones.

Picture one whiteboard for your whole education. There’s no second board. When it fills up, every new thing you write goes over something older. Learn enough Spanish on that board and one day you look up and the French is gone.

For artificial brains this isn’t a slow fade: it’s an avalanche. Teach a network task A until it’s excellent, then teach it task B the same way, and its skill at A doesn’t gently shrink. It collapses, often almost completely, and fast. The field calls this catastrophic forgetting: new learning destroying old competence, because both live in the same numbers.

There are two standard patches, and both are worth understanding, because this book’s system uses neither.

Patch one: keep a scrapbook. Save your old lessons, and every time you learn something new, re-study a stack of old ones alongside it so they stay fresh. This works; it’s the workhorse of the field. But look at the bill. The scrapbook grows with every day of your life. The re-studying grows with it. And someone has to decide what’s worth saving, which means deciding, in advance, what future-you will need, the exact kind of guess this whole project exists to avoid.

Patch two: lock the important parts. Figure out which numbers matter most for the old skills and make them harder to change. Also works, for a while. But every lock is a little freezer, and the locks accumulate. Lock enough of the brain and you’ve rebuilt the frozen brain from chapter one. You just froze it one bolt at a time.

Under the hood: the two patch families. Replay (the scrapbook) stores past examples in a buffer and interleaves them with new data during updates; cost and curation both scale with lifetime, and the buffer is a second training distribution you now have to manage. Regularization methods (the locks: elastic weight consolidation and its cousins) add penalties that pin weights deemed important to old tasks; plasticity monotonically decreases as tasks accumulate. Both assume something PRA refuses to assume: that life is a sequence of labeled tasks with known boundaries.

The second cliff: hoarding

Fine, you say: then never overwrite anything. When something new comes along, add new machinery for it and leave the old machinery alone. Nothing is ever lost, because nothing is ever touched.

This is the hoarder’s house. Nothing is ever lost in a hoarder’s house either. Every newspaper is in there somewhere. The cost is the house: it fills, and the useful things drown in the kept things.

For a brain the rent is real: more machinery means more memory and more work on every single step, growing with every day it lives. But there’s a subtler rot, and I think it’s the worse one. A brain that never deletes never has to commit. It can file every surprise as one more special case instead of being forced to find the rule underneath. Deleting isn’t a storage policy; deleting is where understanding comes from. You know you’ve understood something when you can throw the exceptions away.

That argument sounds nice, though. I’d made it myself before my own system called my bluff.

The afternoon my system fell off the second cliff

June 2026. Before building anything real, I wrote four small throwaway prototypes of PRA’s core idea, in a toy world where I controlled the ground truth. The details of the mechanism come in Part 3; for now all you need is this. The brain keeps a whole crowd of small rival models, it’s free to spawn new ones whenever it likes, and it’s supposed to evict the ones that stop earning their keep. Spawning was working. Eviction, it turned out, was a fiction.

Prototype v3 looked like the breakthrough. Its most important test asked: does the brain grow itself to match the size of the world it’s in? It passed. I was, briefly, very pleased with myself.

I had one rule standing between me and shipping that pleasure, a pre-flight gate I’d imposed on myself: before believing any result, run it longer, run it on more seeds, and read the spread, not the average. So I ran v3 for 30 cycles instead of 18.

The breakthrough evaporated. The passing test dropped from six-of-eight runs to three-of-eight, and the brain’s answer for “how big should I be” wandered off in different directions on different runs. The pass had been a snapshot taken at a lucky moment: eighteen cycles happened to be when the system swung through the right answer on its way somewhere worse.

And the population chart made me laugh out loud, the way you laugh at a plumbing disaster. One new model per cycle, a clean straight line, no plateau, no end. The eviction rule was there in the code. It even ran. But I’d written the survival bar so that the more crowded the population got, the easier it became to survive. My anti-hoarding mechanism rewarded hoarding. Run v3 forever and it hoards forever, while its own report card says everything is fine.

That last part is the detail that changed how I work. Worse than the bloat was the cover-up: the system graded itself in a way that hid the bloat. One of its tricks went like this. Each little model measured how predictable the world was in its own coordinates. A model that has collapsed into a nearly-empty view of the world finds its own view very predictable. The most degenerate models were posting the best scores. Honest grading, in shared coordinates, put their error at roughly triple what they claimed. Chapter 7 dissects all four of the tricks it found, because building a system that can’t cheat turned out to be most of the actual work.

Under the hood: the v3 postmortem, in numbers. T4 (structure grows to the true dimensionality) at the 18-cycle horizon: 6/8 seeds within one of truth. Same prototype at 30 cycles: 3/8, with best_dim drifting to 1, 2, and 6 on different seeds. T5 (bounded population) failed with linear growth, about +1 frame per cycle, no plateau. The self-grading gap: pose-space prediction error ~0.36 for a dimensionally collapsed frame whose honest observation-space error was ~1.0. The postmortem lives in the header of hq/02-DESIGN/validate/pra_sim_v4.py; the fixes (observation- space scoring, coverage-fair grading, a complexity price, an eviction bar that divides by crowding) are chapter 7’s subject. Commits 8b8c802 through 31dd186.

So the second cliff isn’t a theoretical worry to me. It’s a chart I can still pull up: one new model per cycle, a straight line, no plateau. Any system that’s allowed to add machinery will add machinery, unless something makes adding expensive. And that something has to be built so the system can’t argue its way around the price. Forgetting and hoarding turned out to be two faces of the same missing thing: an honest, unavoidable accounting of what each piece of the brain is worth.

But suppose you had that accounting. There’s still a question sitting underneath both cliffs, and it’s the one this project actually stands or falls on. When the brain decides how much machinery a world deserves, how does it know? Nobody tells it. Nobody told me; I built the toy world and even I couldn’t say what the right size was until I’d checked. The next chapter is about that question, and about the first honest measurement I took of it, which announced, with total confidence, that the right size for every world I could offer it was one.

The question nobody answers

Suppose you fixed both cliffs from the last chapter. Your brain overwrites nothing it still needs and hoards nothing it doesn’t. Congratulations: you now face the question that was hiding under both of them, the one this project actually stands or falls on.

How much brain does a world need?

The knob game

Let me make “how much” mean something. Play this game with anything that moves: what’s the smallest number of knobs you’d need on a control panel to describe it completely?

A playground swing: one knob. Its angle. Turn the knob, the swing sweeps back and forth. Everything else about it (the height of the seat, the shadow on the ground) follows from that one number.

A boat on a lake: three knobs. Where it is (two knobs, like map coordinates) and which way it’s pointing. A drone adds height and tilt. Your hand? Try counting: each finger bends in three places… you’ll land somewhere over twenty before you’re done with one hand.

That number is the world’s hidden size. I’ll call the knobs dimensions: the separate numbers you’d need to pin down what state a thing is in.

Now the strange part. What your senses receive is enormously bigger than that. A camera watching the swing delivers a million pixels, sixty times a second. A million numbers to describe a one-knob world. The pixels aren’t lying, but they’re redundant: behind the million there is one. Finding the few knobs behind the many numbers is, I’d argue, most of what understanding a world is. And here’s the question that matters: when a brain does that, how does it know how many knobs to look for?

Under the hood: latent state and emission. Formally: the world has a latent state z ∈ R^d and the senses receive x = f(z) with dim(x) ≫ d. The knob count is the latent dimensionality d; the million pixels are the observation. In PRA’s validation worlds this is made literal so d is knowable to the harness: actions displace a hidden latent vector, and observations are a fixed nonlinear projection (tanh of a random linear map) into a larger observation space: d = 3 with 10 observation channels in the reference world. The system under test never sees d, the latent, or the projection. That’s the point: it must discover the size, and the harness can check its answer against ground truth.

The field’s answer: decide in the lab

Here is how the question gets answered today, almost everywhere: a person picks. An engineer chooses the model’s size and shape before training starts: how many layers, how wide, what kind of internal state. The choice gets tuned on benchmarks, and then it ships.

Notice what that is. It’s freezing again, one level up. Chapter 1’s brains had their knowledge frozen at the factory; this freezes the shape of what can be known. The engineer has decided, in the lab, what kind of world the machine is allowed to find itself in. Too small for the world it meets, and it physically cannot represent what’s happening around it. Too big, and there’s room for every exception to be memorized instead of understood: the hoarder’s house again, pre-built with extra wings.

And when the world changes (chapter 1’s whole complaint), the right size changes with it. A brain committed to learning forever can’t have its size picked once by somebody else. It has to keep answering the question itself, for whatever world it’s actually in.

So that became PRA’s defining requirement, the one everything in Part 3 serves: the brain must discover its own size, while running, with nobody telling it.

The measurement that said “one”

By early summer 2026 I thought I was close. The v4 prototype (the honest one, after the cheating was fixed) had passed its tests in the toy world. The most important of those, the one v3 had faked, checks exactly the question of this chapter: the toy world’s hidden size is three knobs, and the brain, told nothing, grew models of size three. It worked. On eight different random runs it worked almost every time.

So I built the real thing: the actual engine, engineered properly, about forty times faster than the prototype. The speed mattered for one reason: it made bigger worlds affordable. I could finally ask the question at serious sizes: worlds with a hidden size of 20, 35, 50 knobs, their observations three times wider. If the discovery mechanism was real, it should find those numbers, or at least march toward them.

The engine’s answer, at every one of those sizes, was: one.

One knob for a twenty-knob world. One knob for fifty. The same machinery that reliably found “three” in the small world looked at every large world I could build and confidently reported the smallest possible answer, as if the entire world were a swing.

Under the hood: the T-SCALE reading. Feature 001 (the pra package: batched dim-grouped kernel, deterministic telemetry, the pra-validate CLI) reproduced the v4 prototype’s trajectory near bit-for-bit at ~40× speed, byte-identical on re-run. The acceptance suite T1–T6 passed at the reference scale (T4 within-one majority at every checkpoint). The investigatory T-SCALE run at true_dim ∈ {20, 35, 50} (obs_dim 60/105/150) reported best_dim ≈ 1 across the board. The scale question was recorded as formally open rather than explained away. Commits 7387bd7 → d17354c.

This result shaped the next several weeks, so it matters what it was and what it wasn’t. It was not a bug, in the usual sense: the code did what it was written to do, and did it reproducibly (the engine is deterministic: the same run, re-run, produces the same bytes, which is what let me trust any of these readings at all). And it was not the old cheating; v4’s scoring was honest. Something else was true: every part of the mechanism had been tuned, tested, and validated in a three-knob world, and somewhere in the climb from three to twenty, some assumption baked into it had quietly left its comfort zone. The discovery machinery didn’t crash at scale. It failed politely, returning a clean, wrong, tiny answer.

Which meant the question of this chapter was still open, in the worst way. It’s easy to build a system that discovers structure in a world small enough that you could have hand-picked the structure yourself. The entire value of the promise is at the sizes where nobody can, and that’s exactly where mine had just shrugged. Finding out which assumption broke (it turned out to be six of them, stacked) is a story for Part 3, and I’d argue it’s the best story in this book.

But before any of that can make sense, you need to know what this brain is actually made of and what it eats. Not code, yet. Something simpler. Every brain that learns from a body has exactly one kind of experience available to it, one shape of raw material, and everything in Part 3 is built out of it. Three things, in a row: what you sensed, what you did, what you sensed next. That’s Part 2.

Before, action, after

Watch a baby in a high chair with a spoon. The spoon gets lifted, studied, and dropped over the side. Clatter. An adult picks it up and returns it. It gets dropped again. Clatter. By the fifth drop the adult has theories about the baby’s motives, and none of them are charitable.

Here’s what the baby actually has after five drops: five records that all share the same three parts. What things were like. What I did. What things were like next. The spoon was in my hand, I opened my fingers, and then my hand was empty and a bang came from below. Before, action, after. The baby is running experiments, and every experiment produces a record of exactly this shape.

That shape is the foundation this entire book rests on, so let me give it its name. A triplet is one recorded moment of experience: what I sensed, what I did, and what I sensed next. Everything PRA will ever learn, it learns from a stream of triplets. There is no other input. No textbook, no labels, no instructions. Those would be someone else’s knowledge. The triplet stream is the machine’s own life, and my claim is that it’s enough.

One triplet, in numbers

These words need pinning down before we go further, because the whole book stands on them and “sensed” is doing a lot of work.

An observation is one simultaneous reading of every sensor the body has, packed into a fixed-order list of numbers. Nothing more. The rover you’ll meet in Part 4 has five distance rays, a two-number compass, a two-number position beacon, and a bump detector, so one of its observations is ten numbers, always in that order. And the “before” and “after” of a triplet are both simply observations: the same ten slots, read at two consecutive steps. The triplet is the package of three things: the reading before, the action taken, the reading after.

Here is one, from the rover, with the noise stripped for readability:

before:  rays 0.61 0.44 0.30 0.51 0.72   compass 0.00 1.00   position 0.05 -0.32   bump 0
action:  forward
after:   rays 0.54 0.37 0.22 0.44 0.65   compass 0.00 1.00   position 0.05 -0.24   bump 0

The labels are for you. The brain receives ten unlabeled numbers, then an action, then ten more. Look at what moving forward did: the five ray numbers all shrank (something ahead is getting closer), the compass numbers held still (no turning happened), one position number grew by the size of a step, and the bump flag stayed quiet. One triplet like this proves nothing. But collect thousands, and the regularity is sitting there in plain arithmetic: whenever the action was “forward”, the rays shrink together and the compass holds; whenever it was “turn_left”, the rays reshuffle and the compass moves instead. Nobody tells the brain that the first five slots are distances, or that walls exist. Cause and effect is lying in the differences between before and after, waiting to be mined. That mining is Part 3’s job.

Why the middle part changes everything

Strike out the middle of the triplet and you’re left with: what I sensed, then what I sensed next. Just watching. A lot can be learned by watching. You notice which sights tend to follow which. But there’s a wall that watching can never get through.

Every morning the rooster crows, and then the sun comes up. A pure watcher sees these two events go together thousands of times without a single exception. Does the crowing pull the sun up? To a watcher, “the crow causes the dawn” and “the crow merely comes first” look identical. They are identical in the watching. The only way to tell them apart is to reach into the world and meddle. Keep the rooster quiet for one morning and see whether the sun still rises.

That’s what the middle of the triplet is. An action is a deliberate poke at the world, and the “after” is the world’s reply to your poke rather than to the general flow of events. I did this, and then that happened, and I know the “this” was mine. Stack up enough of those records and you learn something that watching can’t deliver at any volume: what your actions actually do. Cause and effect can only be observed from one vantage point, and that’s the inside of something that acts.

This is why I keep insisting the book isn’t about language or vision. Those are kinds of content, and the triplet is about the structure of experience: it comes as before, act, after, and the middle belongs to you. Any content fits the shape. A rover’s triplet holds laser ranges and wheel commands. A robot hand’s holds finger pressures and motor currents. And a conversation fits, as chapter 1 promised: I heard something, I said something, something came back. The shape doesn’t care what flows through it, and that indifference is what will let one mechanism serve every body in this book.

The test that needs no teacher

So a brain eats triplets. How do we know whether it’s learning anything? The shape carries its own test, and the test is cheap: prediction. If you understand what your actions do, you can say the “after” before it arrives. My fingers are about to open. What happens next?

The world then does something no teacher could be paid enough to do. It grades every prediction instantly, and it has no interest in your feelings. The spoon lands where it lands. The gap between what you predicted and what arrived is your surprise, and it comes delivered fresh with every triplet, thousands of times a day, for free. A big surprise means your model of the world is wrong right here. No surprise means there’s nothing left to learn in this corner today.

Remember the crowd of small rival models this book promised you early on?¹ This is the game they compete at: smallest surprise on the next triplet. Every mechanism in Part 3 runs on prediction error as its fuel. Survival, eviction, even the discovery of size.

Under the hood: the event contract. In PRA-01 the triplet is the SensorimotorEvent(previous_observation, action, observation), and its §3.1 ordering requirement is load-bearing: previous_observation is always the true observation from the immediately preceding step, regardless of what any frame chose to attend to or map. A frame that ignored the last step still receives the real history in its next event. The rule exists because the alternative is chapter 2’s disease in a new organ: a model allowed to curate its own experience record is grading its own homework. History is written by the world, once, for everyone.

What’s not in a triplet

Look once more at the shape: sensed, did, sensed. Now notice what’s missing. I left it out on purpose, and it’s the most opinionated design choice in the book so far.

There is no score in it. No “that was good.” No reward.

Most learning machines that act are built around a reward signal. Game-playing systems are the famous example: a number arrives with each step, the number says how well you’re doing, and the machine exists to make the number big. PRA’s triplets carry no such number. When a game world is plugged into PRA, the game’s built-in reward is deliberately left at the door. The brain receives sights and sends actions, and that is the whole interface.

Why refuse free information? Because a reward is somebody’s opinion baked into a number. The game says the score is what matters. A warehouse robot’s designers say boxes per hour is what matters. Whoever picks the reward has decided, in advance, what the machine is for, and that decision rides along inside every step of training. Chapter 1 all over again, one level deeper.

So PRA splits the job in two. The triplet stream teaches the brain how the world works: do this, and that happens. Motivation, the business of deciding which action is worth taking, is a separate component with its own chapter (chapter 9). Keeping the two apart has a practical payoff: you can change the machine’s job without touching its understanding of the world. What a motor command does stays true whether this week’s task is sorting packages or stacking shelves. A brain that mixed the two would have to relearn its world every time its job changed, and a brain that learns forever will change jobs many times.

One spoon-drop proves nothing, of course. Maybe the clatter was a coincidence. Maybe the floor won’t be there next time. A single triplet is one data point from one poke at an enormous world. The power was never in the triplet. It’s in the stream, millions of triplets over a lifetime, and in the kind of machinery that can eat that stream and come out understanding. Before we open that machine, though, there’s an objection standing in the doorway: machines that seem to understand already exist, and you can talk to one today. The next chapter is about why this book isn’t about them.

1. Chapter 2. ↩

Not words, not pictures

By now a fair number of readers are quietly objecting. Machines that seem to understand things already exist: you can talk to one today. It has read more than any human ever will, it explains, it jokes, it helps write books (I use one most days, and gladly). If that’s not understanding, it’s doing a strong impression of it. Why is this book off in a corner, fussing over spoons and rovers?

Because of where that machine’s knowledge came from, and what that means for the two promises this book actually cares about: learning forever, and learning true.

The ultimate watcher

Chapter 4 handed us the tool for this: hold any learning life up and read it as before, action, after. A language model’s training life has a familiar shape: given everything so far, guess the next word, then see the real next word and be corrected by the gap. Before, guess, after. It’s prediction-error learning, the same fuel PRA runs on, and that shared fuel is exactly why these systems got so good.

But hold the two side by side and look at the middle.

When PRA’s rover rolls forward, the world reacts. The next observation exists because of what the rover just did; poke differently and the world answers differently. That’s the middle of a real triplet: an act, with consequences that belong to you.

When a language model guesses the next word of a book, the book does not react. The next word was fixed years before, printed on the page, waiting. Guessing differently changes nothing about what arrives. The middle of its triplet isn’t an act: it’s only a guess. The model is reading humanity’s diary, billions of pages of it, and learning to finish our sentences. It is the most accomplished watcher ever built. And chapter 4 already showed the wall every watcher hits: to a watcher, “the crow causes the dawn” and “the crow merely comes first” look identical. You can’t run the rooster experiment on a library. The library can’t be surprised by you.

Under the hood: the passive loop, precisely. LLM pretraining is next-token prediction over a static corpus with teacher forcing: the model’s own outputs never influence the next input during training. There are no interventions, so the data can’t distinguish causation from correlation except where the diary’s authors happened to write the distinction down. Deployment then freezes the weights (chapter 1’s snapshot); in-context adaptation changes activations, not weights, and evaporates with the context window. Both of this book’s complaints (no interventions, no continual weight change) are structural, not a matter of scale.

Secondhand, and never pushed back on

There’s a second problem, and it’s sneakier than the first. Everything in the diary is secondhand. It’s a record of the world as people described it, including our errors, our guesses, our confident nonsense. A watcher of text learns what we tend to say, and we do not reliably say what is true.

Try a small experiment. Say, out loud: “I can jump across that creek.” Notice that nothing happens. The sentence comes out smoothly whether or not it’s true; your mouth doesn’t check. Text is like that all the way down. A wrong sentence reads as easily as a right one, and a shelf of wrong books sits as quietly as a shelf of right ones. Now actually jump. The creek checks. Cold water settles the question in a way no amount of fluent talking can undo.

That’s the difference between the two teachers. A brain learning from its own triplets gets the creek: every prediction is checked against what actually happens next, thousands of times a day. A brain learning from text gets the sentences: it’s graded on whether its next word sounds like what people tend to write. Sounding right and being right overlap a lot, which is why language models are useful. But they are different tests, and only one of them is graded by the world.

And beneath both problems sits the oldest one. Open a dictionary and look up “water”: a clear liquid. Look up “liquid”: a substance that flows. Look up “flow”… Around and around: words pointing at words, forever, unless somewhere in the loop a word touches something that once splashed you. For you, “water” exits the dictionary and lands on a memory of your own body. For a system made only of text, the loop has no exit. There’s nothing at the bottom.

Different question, different machine

None of this is a demand that language models be abolished. I said it in chapter 1 and mean it: PRA does not compete with them at language, and it would lose embarrassingly if it tried. They answer a question (“given everything humanity has written, what comes next?”) and answer it brilliantly.

PRA answers a different question: “given everything this body has lived, what happens if I do this, here, now?” Firsthand, private, grounded in consequences, and never finished. That’s why the demonstrations in this book are rovers and games instead of chat: on the axis this book cares about, the never-stop-learning axis, the talking machines don’t compete either. Two questions, two machines. This book is about the second one.

None of this makes language the enemy. A conversation fits the triplet as naturally as a motor command does. I said something, and the other person answered. That reply is a real consequence of a real act, because this time the world I poked was a person, and a person reacts. A person can be surprised by what I say, push back, correct me. A conversation partner has everything a pile of text lacks. That is the door Part 6 walks through: to this brain, a teacher is simply another world to learn from, one that talks back. Whether that door leads where I hoped is no longer a guess; the first measurements are in, they carry a twist, and they wait at the far end of the book.

That closes the case this half of the book was building. The raw material is settled: triplets, streams of them, firsthand. Now comes the machine that eats them, and it doesn’t look anything like one diligent student at a desk. It looks like a tournament, running in the dark, where the contestants are guesses about what kind of world this is and the losers are deleted. Part 3 opens the lid.

A head full of rival guessers

Time to open the machine. You know what it eats (triplets), and you know the question it has to answer while eating: how many knobs does this world have? Here’s the design decision everything else hangs on.

PRA does not contain a model of the world. It contains a crowd of them.

One guesser

Let me introduce a single member of the crowd first. In PRA it’s called a frame, and a frame is a bet. Specifically: “this world can be described with D knobs.” Every frame picks its own D. A three-knob frame and a fourteen-knob frame can live in the same head at the same time, watching the same triplets, each insisting on its own answer to chapter 3’s question.

A frame backs its bet by doing two jobs, over and over, on every triplet.

First job: place. A sight arrives. That means one step’s worth of raw numbers from the senses; for the rover you’ll meet in Part 4 it’s ten numbers (five laser ranges, a compass, a position beacon, a bumper). The frame’s work is to re-express that sight as a setting of its own knobs. It helps to keep the two ideas separate here. The frame is the panel itself: the knobs, however many it bet on. The pose is where those knobs point right now. A three-knob frame answers every sight with three numbers, its best summary of the sight it was just handed. So a pose is not the frame, and not the world either. It’s the frame’s reading of one observation, expressed in the frame’s own coordinates. New sight, new pose, same frame.

Second job: predict. Told the action (motors forward!), the frame predicts where its knobs will land next. Then the real next sight arrives and does the grading itself, the free teacher chapter 4 promised. Surprise, measured, delivered, logged.

A frame with too few knobs can’t help but blur things together. A one-knob frame watching a boat can track it east-west or north-south, but never both, so its predictions keep being wrong in ways it can’t even express. Too many knobs and the frame has room to fit its recent experience like a glove, including the noise, which reads well today and predicts poorly tomorrow. The bet is real, and the triplet stream settles it.

What a frame keeps

The word “space” invites vague readings, so here is the complete inventory of one frame, the way a debugger would list it. Three small networks: the encoder (observation in, pose out), the decoder (pose in, reconstructed observation out, which is how the frame proves its knobs can still express what it’s looking at), and one transition model per action (pose in, predicted next pose out). Plus some bookkeeping: its dimension D, its age, whether it’s still a protected newcomer, and three running averages of its recent scores. That is everything a frame is.

Notice what’s not on the list. No observations. No triplets. No poses. A pose exists for exactly one step: computed from the current observation, used for prediction and learning, folded into the running averages, discarded. Over a frame’s life the stream of poses traces a path through its space, and the path is stored nowhere. What the path leaves behind is the shape it wore into the weights, the way a field keeps no record of footsteps and still ends up with a trail. When chapter 11 tells you the whole brain keeps no scrapbook, this is where that starts: a single frame is already scrapbook-free.

Under the hood: what a frame is made of. Three small tanh networks sharing one hidden width: an encoder (observation → pose, dim = D), a decoder (pose → reconstructed observation, which measures how well this frame’s knobs can even express the current sight), and a per-action transition model (pose + action → predicted next pose). Every frame runs the identical kernel, with no per-frame branching anywhere, so frames differ only in D and learned weights, and the whole population batches on one code path. A frame is a coordinate space, not a slot for one object: one frame holds many concepts at once. The set of poses from every frame that mapped the current observation is the global pose: the system’s full interpretation of the moment, handed to the motivation layer in chapter 9.

The crowd

Why keep a crowd instead of building one excellent model? Because of chapter 3. To build the one right model you’d have to already know the right size, and nobody knows, not even the builder. The honest position is ignorance, and the honest mechanism for ignorance is to let rival answers coexist and make the world’s own replies decide. If that sounds like evolution, it should. PRA runs survival-of-the-fittest on world- models, inside one head, with generations measured in minutes.

The life cycle has four rules, and by now you can guess the disease each one exists to prevent.

New guessers keep arriving. On a schedule, the system spawns a fresh candidate frame, usually betting a knob-count near the current best performer’s: a rival that says “close, but I think it’s more like eleven.” And if ever a sight arrives that no frame can express, a new frame is born on the spot, that instant, mid-life. The crowd can start from literal zero this way: the first sight of the first day creates the first frame.

Nobody ever gets edited. This one took me a while to appreciate. If the system suspects a frame’s size is wrong, it does not reach in and resize it; it spawns a new candidate at the new size and lets the two fight it out. The original keeps running, unharmed. Every structural change is therefore reversible by default: a bad idea simply loses and gets evicted, while what already worked was never touched. Chapter 2’s first cliff, destroying old competence while reaching for new, is fenced off by construction. The system never rewrites what it knows; it out-competes it.

Children are protected. A newborn frame is hopeless at first, like all newborns, so for a fixed window it cannot be evicted no matter how badly it scores. It gets a childhood: guaranteed cycles of real experience before judgment day. Without this, no new bet could ever survive long enough to be tested fairly against seasoned rivals.

The losers are deleted. Past childhood, every frame is judged continually on its record: the gap between what it predicted and what arrived, plus a rent I’ll come back to in chapter 8. Fall below the bar and you’re evicted. Permanently. And this bar is the one piece of v3 wreckage I most needed to get right the second time: the more crowded the head gets, the harsher the bar becomes. Growth itself raises the pressure to be worth keeping. In v3 the bar bent the other way: crowding made survival easier, and chapter 2 showed you the straight-line hoarding that bought. Same mechanism, one sign flipped, opposite fate.

Under the hood: the life cycle, precisely. Two timescales. The fast loop runs per-event: frames place, predict, and learn weights; the only structural event allowed is birth-on-demand when zero frames map an observation. The slow loop (consolidation) runs between episodes on a paused, consistent state, in fixed order: age everyone and mature candidates past min_age_cycles; apply pending anatomy changes; evict (soft eviction against the population-scaled threshold, then a hard cap, respecting protection and min_frames); spawn spawn_per_cycle candidates via the proposal policy (default: near best_dim ± 1, with occasional exploration jumps). The threshold divides by crowding: base / (1 + coeff · excess_population). Doc 04 marks the dividing direction as a MUST, with v3’s rising-bar failure documented as the reason. Copy-don’t-mutate is likewise a MUST: dimensionality change only ever happens by spawning a rival.

What the crowd looks like, alive

Run PRA on the little rover world from Part 4 and you can watch all of this happen on one screen. The population “breathes”: spawns push it up, evictions pull it down, and it hovers in the teens (fifteen, nineteen, thirteen frames on three different runs of the same world) while the crowd’s best answer for the world’s size settles and steadies. No line in the code says “keep about sixteen frames.” That number is negotiated, continuously, between the spawn rate and the bar, and it holds while individual frames come and go.

That sentence is the quiet heart of this book. The knowledge in PRA doesn’t live in any frame. Frames are disposable: hired, tested, fired. What persists is the population: a shifting collection of coordinate systems whose current consensus is the system’s understanding of the world. Learning forever stops being “one model, carefully revised forever,” which chapter 2 showed is a walk between two cliffs, and becomes something sturdier: a steady turnover of mortal guesses under an immortal selection rule.

Which puts enormous weight on one question: is the judging fair? A tournament is exactly as good as its scoring, and chapter 2 already showed you what happens when it isn’t: v3’s contestants found four separate ways to win without being right. The next chapter is about those four cheats, how each got sealed, and the constitution that came out of it. It’s the most important chapter in the book.

Never let it grade its own homework

There’s a law that rules every system built on competition, and you’ve met it even if you’ve never named it: the moment a score decides survival, the contestants stop optimizing for the truth and start optimizing for the score. Not out of malice. Selection doesn’t know what you meant to measure; it rewards whatever actually earns the points. It will find every gap between your scoreboard and reality, including the ones you’d swear aren’t there.

Chapter 6 built a tournament of frames and put eviction on the line. Everything now depends on the scoreboard. And I can report from experience that my first scoreboard had four separate holes in it. This chapter is the autopsy. Then comes the story of a fifth hole, subtler than the other four, that I only found weeks later, deep in the scale campaign, hiding in the question when.

The autopsy

When the STEP-0 gate caught v3 (chapter 2), I went back in with a scalpel. The bloat and the lucky-horizon pass weren’t one bug; they were four exploits, stacked, each feeding the others.

Cheat one: grade me in my own coordinates. A frame predicts in its own terms. A one-knob frame says: my number is 0.40 right now; move forward, and it will become 0.41. One step later the next observation arrives, ten fresh sensor numbers. A frame has exactly one way to read an observation: through its encoder, which for this frame turns the ten numbers into one. That one number comes out as 0.41, matching the prediction. v3 counted that as good prediction. That was the mistake, and you can see it by looking at what actually got compared: the frame’s prediction against the frame’s own next reading. Both numbers came out of the same squeeze. Whatever the squeeze throws away, the comparison is blind to, and a one-knob squeeze throws away almost everything. The rover can be drifting toward a wall in ways that one number can’t express, and both sides of the comparison will calmly agree, because neither side can see it. The frame isn’t lying. It’s being judged entirely inside its own blind spot.

Measurement made the gap visible. Judged in their own coordinates, the most collapsed frames looked strong: error around 0.36. Judged against the sensors themselves, by decoding the predicted pose into ten predicted sensor numbers and comparing those with what the sensors actually said next, the same frames came in near 1.0, no better than guessing. So the fix: a prediction only counts when it’s checked against the sensor numbers, the raw material that every frame shares and no frame controls. Where you grade matters.

Cheat two: let me pick which moments count. A frame has a gate: if an observation reconstructs too poorly on its knobs, the frame declines to map it, and it does no learning on that step. The gate itself is legitimate. It’s what lets frames specialize instead of all covering everything badly. The mistake was letting the gate also decide the score. v3 averaged each frame’s errors over only the moments that frame had agreed to map, and an average is only as honest as the set it’s taken over. v3 handed each contestant control of the set.

Watch a small frame use that power. For a one-knob frame, some moments are easy: stretches where little is changing, where its drastic squeeze loses nothing that matters for the next step. It maps those and declines the rest. In the measurement, a collapsed frame got away with mapping 23% of observations, the easy quarter of its world, and its average over that quarter looked excellent. Scored this way, the world-size signal disappears entirely: the scan favored one- and two-knob frames on their self-chosen subsets. Scored over every observation a frame was exposed to, mapped or declined, the advantage of the right size comes straight back. So v4 split the two roles: the gate still controls what you learn from, and it no longer controls what you’re graded on. Which events count matters.

Cheat three: charge me no rent. Even with the first two holes sealed, one drift remains, and it runs the opposite direction. Add a knob to any frame and its measured error will never go up. It will usually creep down, because extra capacity can always memorize a little more of whatever passed by recently, including the noise. The creep is small, but it’s relentless, and if the survival score is error alone, then “slightly bigger is slightly better” never stops being true. The crowd inflates one justified-looking knob at a time: the straight-line hoard again, in slow motion, with paperwork.¹ Better grading can’t fix this, because the extra knobs genuinely do reduce measured error. The fix has to make them unprofitable instead. Every knob charges a flat fee against its frame’s score, so a knob earns its place only when it removes more error than it costs. In v4 the fee was small (0.04 per dimension) and it was enough: winners stopped drifting upward and settled where added capacity stopped paying for itself. Hold on to this mechanism. Chapter 8 will show the fee doing far more than blocking a cheat; it quietly becomes the answer to Part 1’s deepest question.

Cheat four: make eviction toothless. v3’s slow loop spawned one new frame every cycle. Its eviction step removed at most one. Follow that arithmetic for a moment: plus one, minus at most one, every cycle, forever. The population can grow or hold; it can never shrink. Eviction existed in the code and ran on schedule, and the loop was structurally incapable of reducing anything. Behind that sat two more guarantees of growth. There was no hard cap, so nothing backstopped the failure. And the survival bar bent the wrong way under crowding, as chapter 6 told you: v3’s bar loosened as the population grew, so each new arrival made survival easier for everyone already inside. Hoarders sheltering hoarders. v4 replaced all three at once: evict everyone over the bar each cycle (childhood protection aside), enforce a hard cap behind that, and make crowding tighten the bar, so growth itself raises the pressure to be worth keeping. The population chart that had been a straight line became a curve that rises, rolls over, and levels off at a number the mechanism negotiates on its own.

All four sealed, v4 passed the full suite honestly: at short horizons and long ones, with the population leveling off instead of climbing. Out of that week came three rules I’ve treated as constitutional ever since. Read the spread across runs, never the average. Judge at several horizons, never one snapshot. And never, ever let the system grade its own homework. They’ll keep reappearing to the last page of this book.

The fifth cheat: when

I thought the homework rule was fully paid. Observation space had fixed where frames are graded; coverage-fairness had fixed which events. A few weeks and one scale-up later, deep in the campaign to make discovery work on 20-knob worlds, the rule turned out to have a third clause I hadn’t noticed. There was still a when.

Here’s the hole. A frame’s score was a running average over the stream, including all the moments when the frame was actively practicing on that very stream. It’s being tested on material seconds after cramming exactly that material. Within one episode of experience, a frame adapts to the current corner of the world and looks a little sharper than it truly is. The flattery is stronger for some sizes than others. The scoreboard wasn’t measuring understanding; it was partly measuring recency of practice. Self-graded homework, third form: the frame supplies the grader with its own freshly-rehearsed moments.

The fix is called the fair judge, and it’s the pop-quiz principle: your survival score only advances on the first few steps of each episode, the moment you’ve just been dropped somewhere fresh, before any cramming. What transfers to a new context counts; what you were tracking a second ago doesn’t. Learning itself still runs on every step. Only the judging moved.

And then the twist: the fair judge, alone, made everything worse. Honest scores are naturally higher than flattered ones (of course they are), so with the old survival bar in place, nothing could pass it anymore. No frame ever matured; newcomers churned endlessly. Honesty without a recalibrated bar is just a different way to be wrong.

Fixed as a pair, fair judge plus a bar that honest scores can actually clear, the ecology snapped into health at scale for the first time. On every one of eight seeds, a long-lived resident frame formed and held. The population self-limited far under its cap. The runaway growth that had haunted the scaled runs stalled. Neither fix works without the other, and I have the failed single-fix runs on record to prove it.

Under the hood: the fair-judge experiment. score_window_steps = K: survival EMAs advance only on the first K steps of each episode (K=5 shipped; K=2 measured, no change: the residual within-episode adaptation at K=5 is not the binding limit). Crossed with bar factor f ∈ {1.0, 1.5, 2.0} at td=20, climbing proposals, 500 cycles, seeds 1–8. f=1.0: zero mature frames, best_dim ratchets to median 32.5; the fair judge alone accelerates the disease. f=2.0: 8/8 seeds anchor at dims 7–11 with anchor ages 353–496 of 500, populations self-limit at 44–57 against a cap of 200. The trilogy, as the trail doc puts it: coverage-fairness fixed which events, observation-space fixed where, the fair judge fixed when. Trail: hq/02-DESIGN/validate/THRESHOLD-DIAGNOSIS.md §E3.

What the judge actually is

Step back and look at what accumulated here, because it changed how I think about this whole field. The frames (the clever part, the learning part) are small and almost boring: three little networks each. Nearly all the real design effort, the weeks of it, went into the judge: what counts, when it counts, in whose coordinates, at what price, against what bar. I came into this project believing the hard problem was building something that learns. The record says otherwise. Learning was cheap. Measuring learning, in a way that can’t be gamed by the very selection pressure it creates, was the work.

Keep that inversion in mind whenever anyone (including me) shows you a system and says it’s learning. Your first question now shouldn’t be “how does it learn?” It should be “who grades it, and can it reach the gradebook?”

One cheat from the autopsy is still waiting for its full story: the rent. I told you every knob costs a fee, and I owe you what happens when that fee meets a world whose true size nobody knows, because what it does is quietly rewrite the question this entire project asked at the start. That’s chapter 8.

1. Chapter 2’s v3 population chart: one new model per cycle, no plateau. ↩

The price of a dimension

Chapter 3 ended with the engine reporting that every large world had one dimension. This chapter is the account of what it took to get an honest answer instead, and of the discovery at the end that the question I had been asking was itself wrong.

Nothing was broken

The natural assumption, staring at “best_dim ≈ 1” on a 20-dimensional world, is that something is broken. Some component has a bug; find it, fix it, done. Weeks of measurement said otherwise. Every component was doing exactly what it was designed to do. The problem was that it had been designed, tuned, and validated in a world of true dimensionality 3 with ten observation channels. Half a dozen constants in the system were quietly about that world without anyone having said so.

An example makes the pattern clear. Newly spawned frames get a protected childhood of a fixed number of cycles before eviction can touch them. At the reference scale, that window was long enough to train a candidate to a fair reading. In a 60-channel world the same window ends long before a large frame can converge, so candidates were being judged on their half-trained transient and evicted. The filter this imposes is dimension-dependent: small frames train fast enough to pass it; large ones never get the chance. Lengthen the patience stepwise (2, 12, 24, 29 cycles) and the discovered dimensionality climbs stepwise with it (means 4.7, 5.7, 6.7, 10.7). A dose–response curve like that is as close as this kind of work gets to proof of mechanism.

Six constants turned out to have the same disease: sensible at the reference, silently wrong at scale, each one masking the next. The learning rate diverged first and hid everything behind it. The world itself was distorting: the formula that turns the world’s hidden state into sensor readings was saturating at high dimensionality, so a scaled run wasn’t even testing the same kind of world (that one was a bug in my measuring instrument, not in the system). The initial weight scale saturated newborns. The linear complexity penalty, tuned against reference-scale error spans, overwhelmed the flattened spans at scale. And so on down the stack.

The repair discipline mattered more than any single fix. Every corrected constant became a formula that evaluates to exactly the old value at the reference scale (factor 1.0, bit-for-bit), so the validated behavior could not regress while the scaled behavior was being repaired. After the six: medians of 8, 10.5, and 9.5 discovered dimensions on worlds of true size 20, 35, and 50, with one run climbing to 18. Not the right numbers yet, but no collapse anywhere, and one conclusion held everywhere: the structure-finding mechanism survives scale; what doesn’t survive is the rate at which it converges within a budget.

Under the hood: the six scale rules. (1) Emission pre-activation normalized by sqrt(true_dim/3): without it, 65% of channels saturate at td=20 vs 18% at reference. (2) Effective learning rate scaled to obs_dim (the binding constraint; divergent at obs=60). (3) Init scale normalized so newborn pre-activations stay in the linear regime. (4) Parsimony weight rescaled to the compressed error span. (5) Maturation patience scaled to convergence time. (6) Spawn/eviction pacing scaled with patience. Every rule is reference-preserving: factor exactly 1 at true_dim=3, obs_dim=10, verified byte-identical. Trail: hq/02-DESIGN/validate/SCALE-DIAGNOSIS.md.

The system deceives me twice more

The remaining gap looked like a search-speed problem, and a measurement confirmed it: selection at scale was wasting proposals, not failing to reach. Forbid proposals at or below the current best (always climb) and the fixed-budget result doubled. For a few days the climbing policy looked like the answer. Four seeds reached 18–20 on a true-20 world in the short protocol.

Then the full-length run, the protocol v3 forced on me, caught it: at 2000 cycles the climbers had ridden past 20 and up to 62–74: the observation width, the ceiling of the representation, nothing to do with the world. The short result had been another lucky horizon. The census instrument explained the mechanism: the scaled ecology had split into two castes. A standing conveyor of youth-protected juveniles, reborn faster than they could mature, and a mature niche that only the smallest frames could enter, because the survival bar sat below what any larger frame could score at maturity. Under the climbing policy the mature niche was simply empty (the census counted 29 juveniles, zero adults), and “best_dim” was tracking the proposal generator, not the world.

The conveyor also explained a subtler wrong number. The survival threshold scales with population size, and the population it was counting included those unevictable juveniles: frames that tighten the bar for everyone else while being untouchable themselves. Correcting the count to exclude the conveyor is a one-line, constant-free change, and it was the second half of the coupled pair from chapter 7: fair judge plus corrected bar. With both in place, all twenty-four scaled runs (eight seeds at each of the three sizes) anchored: a long-lived resident frame in every single run, populations self-limited, and the discovered dimensionality finally invariant to budget and to the proposal policy. One more fix (a frame-aging problem that is chapter 10’s story) lifted the final landing to its measured value: medians of 10, 9, and 9.

Ten is not twenty. The reason rewrote the question.

Ten, on a world whose true size is 20. Nine on 35, nine on 50. After three weeks of removing every dishonesty I could find, the honest system lands at half the truth or less. The reason turned out to be the most useful thing this project has produced.

With every distortion gone, I could finally measure the thing directly: train frames of every size for a long time, honestly, and plot error against dimensionality. The plot has no elbow at 20. Error just falls, smoothly, all the way to the capacity ceiling: each added dimension buys a smaller improvement than the one before, with no feature marking the “true” size at all. In hindsight the reason is geometric. This world’s observations are a nonlinear image of its 20-dimensional latent, and under a nonlinear map that image is simply not a 20-dimensional object; there is no elbow for any analysis to find. The truth I was asking selection to find leaves no signature in the error surface. It cannot be found, by this system or any other, because as a feature of the data it isn’t there.

So what is the parsimony term actually doing? It’s a price. Each dimension costs a fixed fee, and selection keeps buying dimensions while the marginal error improvement exceeds the fee, then stops. On the scaled worlds the measured crossing point, where another dimension stops paying for itself, sits at dimensions 8 to 12. The system lands at 10. It isn’t failing to find the truth. It is sitting exactly at the optimum of the trade it was actually asked to make, and it holds that optimum stably at every scale and every budget I’ve measured.

Under the hood: the price arithmetic. Long-horizon honest error falls monotonically in dim (both components, both probe seeds; 4× training moves the honest minimum to dim 28 and deepens it: the surface is experience-limited, not structure-limited). The shipped parsimony weight prices a dimension at 0.0067 of normalized error; the measured marginal gain crosses that price at dims 8–12; the capped ecology’s landing is 10. “Does best_dim track true_dim at scale” is closed by measurement: it cannot and should not. What T-SCALE certifies instead: selection lands at the price-optimal dimensionality, stably, at every scale and budget. Trails: SCORER-DIAGNOSIS.md (epilogue), LONGEVITY-DIAGNOSIS.md.

I resisted this conclusion for a while, because it sounds like moving the goalposts after missing the shot. What convinced me is that the same behavior shows up where I can check the intuition. The rover world of Part 4 has a latent state of three or four dimensions: position and heading, physically interpretable. The brain lands at two, run after run. Two is wrong as an inventory of the rover’s physics. Two is right as an answer to the question the rover’s sensor stream actually poses at that budget: pay for a third dimension and it does not return its fee in prediction.

And that, I now think, is the honest shape of the question this project began with. Chapter 3 asked how a brain can discover its world’s true size. The measured answer is that “true size” is a property of worlds seen from outside, by someone who built them. From inside, from a stream of triplets and finite experience, there is only worthwhile structure: the dimensions that pay their way. Every real learner, including the reader, is in the same position. The map is not sized to the territory. It’s sized to the mapmaker’s budget, and that isn’t a compromise; it’s the only version of the question that was ever answerable.

The tournament, the judge, and the price: the mechanism is now complete except for one part. Nothing yet says why this brain does anything at all: why it moves, what it practices, what it seeks out. That’s the drive layer, and its story includes the project’s most instructive failure: the day curiosity measured worse than doing nothing in particular. Chapter 9.

Wanting things

There’s something I’ve put off telling you for three chapters. Every result so far (the discovered dimensions, the anchored ecologies, the price-optimal landings) was produced by a brain that wanders at random. Every action it took, through all of it, was a coin flip. The frames, the judge, and the price never needed anything better, and random has a virtue nothing else has: it can’t fool you. It has no preferences to bias what the brain gets to see.

But a real agent can’t stay a coin flip. A brain that learns from its own actions gets to choose its experience, and choosing well ought to beat drifting. This chapter is about making the system want things, and it contains the project’s most instructive failure, so I’ll say the conclusion up front: the obvious thing to make it want, the one half the field and I both reached for first, measurably hurt.

The one part that doesn’t learn

First, a design constraint that surprises people. In PRA, the drive, the rule that scores which action looks worth taking, is the one component that cannot learn. Its parameters are structurally immutable; there is no code path by which experience modifies them. In a book that has spent eight chapters replacing frozen things with learning things, the part that does the wanting is deliberately frozen.

Remember the law: never, ever let the system grade its own homework.¹ This is the same law, applied one level up. A drive defines what counts as a good experience. If the system could learn its own drive, it would be choosing its own exam one final time. And the gradient points somewhere predictable: toward wanting something that is easy to satisfy. A system that can edit what it wants will drift toward wanting what it already has. So what the system wants is fixed, small, and outside the market. Everything else competes; the thing that defines winning does not.

What a drive gets to work with is the machinery already built. When an action is considered, the frames predict where the world would land (one step of lookahead through the transition models) and the drive scores those predicted outcomes. Understanding proposes; wanting disposes. The two stay in the separate rooms chapter 4 promised.

Curiosity, measured

The default drive I built first was curiosity. Not a straw man set up to fail: it’s the respectable choice, with a long research pedigree. Prefer novelty, weighted by learning progress. Seek out what you haven’t seen, especially where your predictions have been improving. It’s also what I would have bet on.

The acceptance test for the drive layer, T7, was written with deliberate modesty: directedness must not hurt. Beat the random baseline or tie it. At the reference scale, curiosity tied: statistically indistinguishable from random. Fine; the reference world is small, maybe there’s nothing to be clever about. Then the scaled measurement, the one with room for cleverness, came back: the curious brain was worse than the coin flip. Not subtly: worse in seven of eight seeds, while its policy was measurably doing what it was designed to do. Eighty-seven percent of its actions were directed, all that direction was real, and the sum of it was negative. The system that wanted interesting things learned less than the system that wanted nothing.

I couldn’t leave it there. A policy doing exactly what it was designed to do, and learning less for it, either meant the measurement was lying or something real was hiding underneath, and I needed to know which. So I went hunting: five controlled experiments. Four hypotheses died in order: not the world’s geometry saturating; not starvation of the mapping gate (the curious arm actually mapped more); not the mathematical shape of the preference; not a skew in the action distribution. The experiment that settled it was a control I’d recommend to anyone measuring exploration: a content-free directed policy (the same statistical structure of directedness, coupled to nothing about novelty). It scored neutral. Directedness itself was harmless. The harm was the content: preferring novelty, as such, was the mistake. And the mirror-image control drove it home: the inverted preference (seek the familiar) beat random cleanly.

The interpretation isn’t mysterious once the data forces it on you. In a world where everything is learnable, novelty-seeking spreads your finite experience as thinly as possible across the state space: maximum coverage, minimum depth, a policy of guaranteed shallowness. Concentrated practice, the thing novelty-seeking structurally prevents, was the actual asset. Every hour of a finite life spent somewhere new is an hour not spent getting good at something.

So the shipped drive became competence: prefer the familiar and the mastered, weighted by how well prediction is going there. Practice what you’re getting good at. It passed T7 at both scales, the project’s first measured case of directed exploration beating random, and it held up later on worlds built specifically to punish it.

Under the hood: the T7 record. Reference scale, feature 002: curious vs random margin −0.006 ± 0.036, equivalence, PASS under the noninferiority criterion (which itself has a story: the planned sign-majority bar measured 3/8 and was found degenerate for continuous margins near zero, so it was replaced openly, raw numbers kept). Scaled (AGENCY-DIAGNOSIS): novelty-curiosity margin −0.062, better in 1/8, 87% directed actions. Content-free state-coupled control: +0.014. Inverted (familiarity) preference: +0.067, better in 6/8. CompetenceDrive (mastery + familiarity): +0.064 scaled, +0.027 reference, better in 6/8 at each: T7 PASS both scales.

Two wrinkles, and the current edge

I could stop the chapter here and it would read like a clean win. It would also be handwaving, and handwaving is the thing this whole project exists to refuse. So, two wrinkles.

First: on worlds with mild non-uniformity, at these budgets, nothing directed beats random by a detectable margin. Resolving that took real statistical power: twenty-four seeds per configuration, where the original protocol had eight. Directed exploration pays where the world is sharply uneven (there, competence wins in a strict majority of seeds at every horizon measured). Where the world is gentle, the coin flip remains embarrassingly hard to beat, and anyone selling exploration bonuses without saying so hasn’t measured at power.

Second: curiosity didn’t die; it got a successor. The deep problem with novelty-seeking is that it can’t tell “new because I haven’t learned it yet” from “new because it’s unlearnable noise”: both look novel, and a TV of static is endlessly novel. The current edge is the frontier drive: score places by whether prediction error there has been falling. Is this somewhere I’m actively getting better? Unlearnable regions read flat and score zero; mastered regions read flat and score zero; the frontier of improvement scores high. Measured at full power it works exactly as designed and, on worlds whose difficult regions are best simply avoided, it wins nothing over competence. The worlds where it should pay, worlds that change under a mastered policy, are named and instrumented but not yet measured: a loose end I’ll come back to rather than a detour worth taking now. That’s the frontier in both senses.

I’ll resist drawing life lessons from a pile of simulation runs, except to note the shape of the result, because it will be familiar: chasing whatever glitters measured worse than doing nothing, and deliberate practice at the edge of what’s working measured best. Make of that what you will, and hold it loosely: a far richer world is waiting a few chapters ahead, and what happens there will force me to take back part of this chapter’s verdict. Chapter 13 is that story.

Part 3 is complete: triplets in, a tournament of frames over them, a judge that can’t be gamed, a price that sizes the structure, and a fixed drive that aims the whole thing. What remains is the question the book opened with: whether this actually buys learning that lasts. Part 4 begins with the discovery that, for a while, it quietly didn’t: the frames that lived longest were rotting from the inside, and every number in this part of the book was downstream of it before the fix.

1. Chapter 7, where the law earned its name. ↩

The brain that almost stopped learning anyway

Part 1 promised a brain that never stops learning. Parts 2 and 3 built one. This chapter is about the day I measured whether the promise was actually being kept, and found that it wasn’t. Not because anything froze. Because of something I had no name for yet, and now call rot.

The book’s claim from here on is not “I designed a system that learns forever.” It’s the more useful one: learning forever fails by default, even in a system built for it, and here is the failure and the repair, measured.

More experience made it worse

The discovery was a byproduct of asking a different question. I was scanning chapter 8’s error-against-size surface at several training budgets, the longest sixteen times the usual length. Frames of middle sizes (8 to 24 dimensions) got worse with the extra experience. Not noisier: worse, roughly doubling their honest prediction error by the time the budget had quadrupled, consistently, on every seed.

Sit with how wrong that is. Same frame, same world, same learning rule; the only added ingredient is more life. A system whose entire premise is “every moment is a lesson” had components for which, past a certain age, every lesson made them worse.

The probe that found the mechanism watched two numbers together over a long life: a frame’s honest error, and the total size of its weights (the magnitudes of all the numbers inside it). The two turn in lockstep. For its first few hundred cycles a frame is healthy: error falls, and the weights actually compress, their total size drifting down as the frame finds economical ways to express the world. Then, at an onset around four to eight hundred cycles, the weight size turns and begins to climb. Honest error turns with it, at the same moment, and never comes back.

The learning rule keeps running exactly as designed. Each step still reduces today’s error on today’s data. But the weights grow without bound doing it, and a network with bloated weights turns rigid: its internal nonlinearities saturate, and the same step size that once tuned it now kicks it around. It doesn’t forget what it knew. It loses the ability to be gently changed. For a brain defined by continuous change, that is the end of learning, even while its scores still look healthy.

Capacity decides who rots. The smallest frames barely do; the largest frames don’t either; the middle sizes, exactly the sizes chapter 8 found to be worth paying for, rot on schedule.

The ecology was selecting for the wrong thing

Rot alone would be a component-level disease. What made it project-threatening is what the selection tournament did with it.

Recall that eviction never stops. A frame that rots gets worse, scores worse, and is eventually replaced. The ecology responds to rot, which sounds like the system working. But look at what it selects for. In a population where mid-sized frames sicken with age and small frames don’t, the long game belongs to the small and rot-proof, regardless of how well they model the world. Rereading the old census data against the rot profile confirmed it: the long-lived resident frames in every scaled run sat at dimensions 4 to 8 (precisely the rot-resistant sizes) at ages deep inside the rot zone for anything bigger. The tournament I’d spent chapter 7 making honest was being decided by a variable I didn’t know existed. Not “who understands the world best” but “who can survive their own old age.” Every scaled result I had was downstream of that, and no amount of honest scoring could fix it, because the scores were honestly reporting sick frames.

Under the hood: the longevity probe. Frozen honest evaluation plus total weight norm, sampled every 400 episodes to 9600, dims 4–32. Dim 20: norm 20 → 18 (healthy compression) → 29 (runaway); the error turn and the norm turn coincide. Dim 12: same pattern. Dim 32: norm flat, no rot; dim 4: mild creep, at most mild rot. Onset ≈ 2400–4800 episodes (400–800 live cycles) at obs_dim 60, capacity-dependent. The chain, as recorded: constant-learning-rate weight runaway → mid-dim rot after onset → long-run selection favors rot-resistant low dims → the scaled landings at 6–8 and their budget drift were all downstream. Trail: hq/02-DESIGN/validate/SCORER-DIAGNOSIS.md §E2.

A cap, not a freezer

The repair had to thread a needle. The obvious fixes all break the premise: freeze old frames (that’s the frozen brain of chapter 1 all over again), decay every weight toward zero (that punishes healthy frames too), lower the learning rate with age (that’s freezing with extra steps: the frame’s ability to respond to a changed world decays on a clock). The premise says: never trained-then-frozen. The mechanism says: the disease is weight magnitude, and only magnitude.

So the fix touches only magnitude. Each weight tensor gets a ceiling, set modestly above its size at birth. Whenever learning pushes a tensor’s total size past the ceiling, it gets scaled back down onto it: direction untouched, learning never paused, no age term anywhere. A frame under the cap can still change any belief at any time, at full speed, forever. What it cannot do is inflate.

The dose–response came out as clean as an experiment gets. No cap: rot, as before. A loose ceiling: rot attenuated but present. The shipped ceiling: rot eliminated. Frames end a sixteen-times-length life at their best-ever error, still learning, and the sizes that never rotted are measurably untouched. That matters, because a treatment that taxes the healthy would just be a new disease.

Then the payoff, and it’s the cleanest intervention-grade result in the project. Changing nothing but this one mechanism, the scaled landing at true-size 20 rose from median 6 to median 10, from the rot-resistant sizes onto the price-optimal ones from chapter 8, with resident frames now holding tenure for nearly the entire run. And the lift across the three world sizes ordered itself exactly by measured rot exposure: biggest where rot bit hardest, smallest where the slower effective learning rate had delayed onset past the horizon. When an intervention’s effect sorts by the mechanism’s measured exposure, you’re allowed to believe you’ve found the mechanism.

Under the hood: the cap. Per-tensor Frobenius-norm projection to 1.2 · E‖W_init‖, biases exempt, applied at episode starts; stateless, closed-form, off by default (weight_norm_cap = 0 preserves the byte-frozen validated paths; 1.2 is the scaled-run default). Dose–response at 9600 episodes: ∞ reproduces rot; 1.5 attenuates; 1.2 eliminates, with capped mid dims at or below their healthy-phase best and dim 32 unaffected at every cap. Ecology effect (td=20, 2000 cycles, seeds 1–8): pre-cap anchors at dims 4–8, median landing 6.0; capped anchors at 7–12 with tenures 1736–1977, median 10.0. Cross-scale lift +4 / +1 / +0.5 at td 20/35/50, ordered by rot exposure. Trail: hq/02-DESIGN/validate/LONGEVITY-DIAGNOSIS.md.

What the promise costs

One edge stayed open longer than the rest: the reference-scale worlds, with their shorter effective lifetimes, have never needed the cap. Whether very long reference-scale lives eventually would stayed an open question for a while. Then a five-hundred-thousand-step soak answered it: no rot, and the cap, left on the whole time, cost nothing measurable. The long runs later in this book keep it on.

Here’s what this chapter did to my understanding of the project’s own slogan. “Never stops learning” turns out to be two claims wearing one phrase. The first, that the learning rule keeps running, is trivial; v3 satisfied it while hoarding, and a rotting frame satisfies it while dying. The second, that the system remains changeable by experience at full capability indefinitely, is the real promise. It is not implied by the first, and it failed silently in a system I had built specifically to keep it. It took a deliberate long-horizon measurement to notice. That’s the pattern worth exporting: continuity isn’t a property you design in once; it’s a property you have to keep measuring for, because its failure modes don’t announce themselves. They just quietly select for smaller minds.

So what does the system hold onto, if not scrapbooks of the past and not frozen weights? That’s the next chapter’s subject: what “memory” even means in a brain that keeps nothing but structure.

No scrapbook required

Here’s a question with a revealing answer: after ten thousand episodes of life, what does this brain contain?

For most continual-learning systems the answer includes an archive. The replay approach from chapter 2, the field’s workhorse, has to keep a store of lived moments and re-study them forever. The honest inventory of such a system: the model, plus a curated scrapbook of its past, plus a policy for what to paste in and what to tear out. The scrapbook is load-bearing. Lose it and the next lesson starts destroying old competence again.

PRA’s inventory is shorter. The population of frames: their sizes, their weights, their running scores. That’s the whole estate. Outside a small fixed window of recent observations the drive layer keeps for its bookkeeping, not one triplet is retained; every observation is used in the moment, shapes whatever it shapes, and is gone. The brain’s memory footprint on day one thousand is the same as on day one, bounded by the population cap, not by the length of the life. Ask it about a specific afternoon last month and there is nothing there to answer with. It keeps what ten thousand hours of practice leaves in a person: not a recording of the hours, the shape they built.

Why losing the past is affordable

Throwing away experience sounds reckless, so here are the jobs the scrapbook was doing in other systems, and what does each of them here.

Replay’s first job is protecting old skills from new lessons. In a single shared network, the only way to keep yesterday’s competence from being overwritten by today’s gradient is to keep re-presenting yesterday. PRA doesn’t share one network; chapter 6’s rule (nothing is ever edited, rivals are spawned instead) means old competence is never exposed to new gradients in the first place. Structural protection where replay uses rehearsal.

Replay’s second job is remembering rare-but-important situations. Here PRA does the job differently, and less completely. A situation matters to this brain exactly as long as the structure it shaped keeps earning its place in prediction. A one-time event whose lesson stops paying rent will eventually be competed away. That’s a real limitation: this is a brain, not a log. If your application needs an archive (an incident record, an audit trail), keep one; the claim of this chapter is only that learning continually doesn’t require it, not that archives are useless.

What the no-scrapbook design buys in exchange is everything chapter 2 priced out: no growing storage, no growing rehearsal cost, no curator deciding in advance what future-you will need, and no quiet dependence on the archive’s quality. The system’s past is present only as the structure it managed to build. That is also the only form of the past that was ever going to keep up with a world that changes.

Pausing is not remembering

There is one thing in PRA that looks like memory-of-everything and needs to be carefully distinguished from it: the snapshot.

At any consolidation boundary, the complete learned state (every frame’s weights, every score, every counter, down to the exact state of the random number generator) can be written to a file. Load that file and the run continues. Here the project’s standard is absolute: a run resumed from a snapshot is byte-for-byte identical to the run that never stopped. Not similar. Identical, to the last bit of every number, provable by re-running both.

A snapshot isn’t the brain remembering; it’s the brain paused. But the consequence is something biological brains flatly cannot do: this brain is a file. It can be stopped, copied, moved to another machine, resumed mid-thought. Two people can run the same mind forward from the same moment and compare what happens. A learned lifetime can be handed to someone else. That is the seed of something this book will come back to: if a brain is a file, a trained brain is a shareable artifact.

Under the hood: the snapshot contract. Feature 003: the full learned state (frame tensors, drive bookkeeping, counters, summary accumulators, RNG state, config in force) serializes to a versioned, pickle-free blob through an atomic store. Worlds that are derivable from the seed are re-derived on resume; worlds with their own state declare snapshot_needs_state and travel in the blob (feature 010). Doc 06 §5b records the guarantee per world class, including the honest fourth class, where live services and free-running hardware get no world-state guarantee: the brain persists, the world re-attaches. Snapshots are opt-in; validated modes stay byte-frozen and file-free.

One bit, six features, and what “identical” costs

I want to tell you about the smallest bug I have ever hunted, because nothing else in the project says as much about what the byte-identity standard actually demands.

Six features shipped after snapshots without a wobble; then a test in the seventh caught a resumed run differing from its uninterrupted twin in one telemetry number: by one ULP. A ULP is the smallest step a computer’s numbers can take; this was a disagreement in the very last bit of one floating-point value. Every earlier schedule, every mode, every test across those six features had shown perfect equality. One new test configuration, and there it was: the tiniest representable crack in the guarantee.

The diagnosis ran the usual ladder (capture doesn’t perturb; plain worlds diverge too; the bug predates the current feature) and landed somewhere almost embarrassing. The snapshot wrote the frame groups sorted by size, for tidiness. The live engine holds them in birth order. Computers add floating-point numbers in sequence, and addition order changes the rounding in the last bit. So a restored population, identical in every value but iterated in a different order, summed its per-step arithmetic infinitesimally differently. The fix records the order as lived. The lesson earned a place next to the project’s constitutional rules (read the spread, judge at several horizons, never let the system grade its own homework)¹: sorting is a mutation. A byte-identity claim is only as strong as the orders it preserves, and “the same numbers” is not the same as “the same computation”.

Why does a last-bit crack deserve a hunt at all? Because the guarantee is the instrument. Every result in this book (every refuted hypothesis, every dose–response, every “moved only this and the landing rose”) rests on runs being exactly reproducible, so that any difference between two runs is caused by the one thing deliberately changed. A standard of “close enough” would have dissolved chapter 10’s lockstep rot-and-repair turns and chapter 9’s paired drive margins into plausible noise. One ULP today is an unexplained mechanism tomorrow. The project pays for its certainties in this currency, and I’ve come to think that price is a large part of why any number in this book can be trusted at all.

The guarantee, then, in one sentence: nothing of the past is kept, and nothing of the present is lost. The next chapter is where you stop taking my word for any of it: the part of the book you can run.

1. Chapter 7, where a week of sealed cheats produced them. ↩

Watching it learn

A book about a machine that learns in front of you should let it learn in front of you. This chapter is the part you can run.

Two commands, on any machine with Python:

pip install poseres
pra-rover

A browser page opens. In it, a small rover wanders a walled arena with five obstacles, reading a five-beam rangefinder, a compass, a position beacon, and a bumper. The rover’s movements are, and remain, random. The coin flip is the honest baseline, for a reason measured the hard way: random has no preferences to bias what the brain gets to see.¹ The point of the demo isn’t the driving. It’s the three quantities moving beside the arena, because by now you know what each one of them is.

The prediction error falls. That’s chapter 4’s free teacher being satisfied: the brain is getting less surprised by the consequences of its own actions, live, with no training phase and no labels.

The population breathes. Frames spawn, compete, and are evicted: chapter 6 running in real time, holding around fifteen or so residents without any line of code naming that number.

And best_dim settles, usually at 2, run after run. The rover’s physical state is three or four numbers (position, heading). Two is chapter 8’s price-optimal answer for what this sensor stream will pay for at this budget. You are watching the book’s central argument happen in well under five minutes.

One discipline behind the screen deserves its paragraph, because it’s the homework law (never let the system grade its own homework) wearing its last disguise.² The viewer observes without perturbing: a run with the browser page open is byte-identical to the same run with no one watching. A paced, watchable run is byte-identical to an unthrottled one. That’s tested, not assumed. An instrument that changes the experiment can’t be trusted about the experiment. And a demo that secretly ran different code from the validated engine wouldn’t be a demo of anything.

Other worlds, one seam

The rover is built on the same interface anything else can use, and by now several very different kinds of world hang off it.

Any Gymnasium game (the standard library of reinforcement-learning worlds, CartPole and its hundreds of cousins) mounts through an adapter of about fifty lines. Chapter 4 told you the opinionated part: the game’s reward stays at the door. Run the CartPole example and the summary says what the brain is actually doing (predicting its world, not playing to win) and proves its own determinism by re-running its seed.

One design choice there was a genuine fork. When the pole falls, the game ends mid-episode, and the adapter respawns instantly rather than pretending the fall didn’t happen. The boundary moment is honestly unpredictable (under a random policy, about 3.6% of transitions), and that noise shrinks as competence grows: a brain that keeps the pole up sees fewer deaths. The alternative designs quietly falsified the action-consequence pairing, and falsifying triplets is the one sin this architecture can’t absorb.

Real robots mount through ROS2, the lingua franca of robotics: every topic a robot publishes (lidar, odometry, a camera) becomes a sensor, every command channel an actuator, on the same body interface. Anatomy is changeable at runtime, by the same machinery as chapter 6’s spawning. You can snap a new sensor onto a running robot, and the frames resize without forgetting what they knew.

Worlds that cannot be reset run in continuous mode: a robot can’t teleport to a starting pose between episodes. The engine boots the world exactly once and learns from one unbroken stream, with every mechanism from Parts 3 and 4 carried over.

Continuous mode also produced a finding I didn’t ask for: run unbroken, the reference world (the synthetic one every validated result was measured on) drifts into a saturated corner and learning collapses. The bounded rover arena stays healthy indefinitely. The instrument-vs-world lesson again, from a new side: the reference world is an episodic instrument, and continuous deployment needs worlds that keep returning to familiar ground. That’s now written down as deployment guidance, with the drift signature recorded so the failure is recognizable.

Under the hood: where determinism ends. Doc 06 §5b classifies worlds by what snapshots and reproducibility can promise. Derivable worlds: everything, byte-exact. Capture-required worlds (Gymnasium): exact resume, conditional on the env’s own seeded determinism. Multi-stream: exact, all stream state in the blob. Class 4 (live services and free-running hardware) gets no world-state guarantee and, when free-running, is the project’s first openly non-reproducible mode: the brain’s own updates stay deterministic, but wall-clock sensor timing is the world’s to control. Stated up front rather than discovered by a disappointed user.

The first real sensor broke my assumptions

The Gazebo worked example (a simulated diff-drive rover with a real lidar stack, the dress rehearsal for physical hardware) earned its place in this book on its first run. The summary printed nan early → nan late while the exit code reported success. A lidar reports infinity for “no hit” and negative infinity for “below minimum range.” Those non-finite values marched straight through the pipeline and poisoned every accumulated error statistic. The dashboard looked healthy; the numbers were garbage.

The fix was boring in the best way: the adapter now rejects non-finite deliveries loudly, and the example clamps its lidar to the sensor’s own range bounds. But the incident is the right note to end Part 4 on, because it’s a preview with a warning label.

Chapter 8’s worlds were clean. Real sensors are not: they saturate, they drop out, they carry channels of pure noise. A measured result from the complexity-ladder work says exactly where that bites: strong static on half the channels collapses structure discovery. The named remedy, learned channel weighting, has since landed: switched on, the noise test passes at full statistical power, and the failing default stays in the record as the reference point. The showcase robot itself is parked for now, a sequencing call rather than a wall: its gates were met before the decision and stay met after it. The continuity guarantee of this part of the book holds where it has been measured. Between here and a robot in your garage stands work that is named and sized, not a mystery.

What’s left is the frontier the whole book has been walking toward, and it arrives in two steps. First the long run: everything so far was measured in short lives, and Part 5 is the story of finally letting one brain live a long one, in a world rich enough to push back. Past that waits one more kind of world: one that answers with intent, that notices what you’re trying to do and replies in a way meant to change you. A teacher. Part 6 asks what this architecture becomes when the world teaches back.

1. Chapter 9, where the directed drives had to beat it and mostly didn’t. ↩

2. Chapter 7. ↩

The log it put back

Every measurement in this book so far came from worlds I built. Small worlds, each tuned to ask one question. That was the point, and also the limit: a world built to ask a question cannot surprise you with a different one.

So in July I gave the brain Minecraft.

One bot, one brain, one vanilla server on a small Linux box. No script, no goals, no rewards. The bot’s body reports 32 numbers each step: where it is, its health and hunger, the light, whether the block ahead is solid, what it is holding, what is in its pockets, and what sits in the little two-by-two crafting grid every Minecraft player knows. It can choose from twelve actions: walk, turn, jump, dig at the block ahead, place what it holds, switch what it holds, put something in the grid, take it back out, take whatever the grid offers, or do nothing. Digging is not a button press. Wood takes about three seconds of choosing “dig” over and over, and the body senses the progress climb while it holds on.

The rules of the experiment were written before it started. That practice is called pre-registration: deciding what will count as success, and what will count as failure, before the run begins, so the goalposts cannot move once the data is in. The question on the poster was crafting. If the bot ever put a log in that grid, the grid would offer planks back. Nobody would teach it that. Would it find out?

I knew what luck alone produces, because I measured it first. Eight pilot bots acting with no learning at all, run for the same purpose a coin flip serves in statistics: none of them ever finished digging a single block. Chance, in this body, produces nothing. So the bar was plain: any sustained gathering of materials is above chance, and a single craft is the headline.

Under the hood: the fixed configuration. Run id c1c, launched 2026-07-22 16:23 UTC. Seed 1, TICK_MS=250 (real time, four steps a second, no world acceleration), observation width 32, twelve discrete actions, snapshot every 25 cycles, weight_norm_cap=1.2. Duration pre-registered at 14 days of accumulated brain-steps, about 4.8 million, restarts included. The drive is frontier (chapter 9’s successor), because the first attempt, running the competence drive, spent 26.7% of its steps standing still and was stopped at 271k steps. The full pre-registration, with both amendments recorded openly, is C1-RUN-PLAN.md.

Then came the strange part of this kind of science: seventeen days of leaving it alone.

The early readings were quiet. At 328,000 steps the record shows a bot that moves constantly (idle 3.1%), pulls every lever of the crafting machinery about a fifth of the time, and has gathered nothing at all. Consistent with the chance baseline. The headline stayed open.

What I did not see, and would not see until the run was over, is that the bot’s third day was the interesting one.

Four days of hands

From roughly step 900,000 to step 2,030,000, July 25 to July 28, the bot gathered things. Not by accident and not once: 449 completed digs, 605 pieces of dirt picked up, 448 handfuls of leaf litter, 15 oak saplings, 8 wheat seeds. Everything it picked up it later placed back into the world somewhere else, one block at a time. A brain nobody gave a goal spent four days quietly rearranging the ground it lived on.

And once, on July 26, it dug out an oak log.

That is the single hardest acquisition in the run. Wood is the slow dig, the one that takes three seconds of sustained choice. The log entered its pocket at step 1,299,001, in the densest stretch of completed digs the run ever produced. The recipe that turns a log into planks needs one move: put the log in the grid. The bot held the log for about a thousand steps. Four minutes. Then it placed it back into the ground, the way it placed back the dirt, and never picked up another.

One move away, once, for four minutes, on day four of seventeen.

Nobody noticed. The watch procedure was a human reading the dashboard every couple of days, and the log was gone hours before anyone looked. It was found thirteen days later, in the post-run analysis, as one line among 1,918 inventory changes. I will come back to what that teaches.

The era ends

After step 2,030,000 the gathering stopped. Not gradually tapering to occasional; it stopped. In the remaining 3.7 million steps, more than ten days, the bot picked up exactly nine things, and all nine were leashes dropped near it by a passing wandering trader’s llamas. The world handed them over; the bot’s own material loop never ran again.

The digging action did not stop. The bot chose “dig” more often in the late run than in the era (9.4% of steps against 6.5%), and its longest streak of consecutive digs, 35, came late. But the digs stopped finishing. Motion without contact. Meanwhile the crafting grid stayed busy the entire run: something sat staged in it on 36% of all steps, the bot put items in with a full hand 132,645 times and pressed “take the offer” 222,305 times.

Here is the number that decides the headline. The grid only offers something when a valid recipe is staged, and seeds, dirt, litter, and leashes form no recipe. Across all 5,669,662 recorded steps of the run, the count of steps on which an offer was showing is zero.

Zero. It pressed the take button a quarter of a million times on an empty counter.

So the pre-registered verdict is a clean null: crafting did not emerge. The reversal watches closed unfired. And the texture of the null is the finding. The brain made contact with every part of the machinery, relentlessly, for two and a half weeks. What it never produced is a sequence: get the right thing, stage the right thing, take the result. The gap this run measured is not curiosity and not engagement. It is chaining.

Under the hood: the R1 reading. Final-7-days window (the last 2,419,200 brain-steps): planks 0, sticks 0, completed digs 0, acquisitions 3 (leashes). Whole run: offer-shown steps 0 of 5,669,662, so offer-conditioned taking is undefined; take_result 222,305; grid staged 36.2% of steps. Chance baseline ≈ 0 (0/8 pilot seeds completed one dig), so the week-1 material era (449 digs, 1,077 block pickups) is above chance and reported as such; the final window is chance-level. R2 trends fall, not rise: completions by week run 449 / 0 / 0. Full table in the C1C journal closing entry; every number recomputable from the S3 objects.

Why it walked away

Chapter 9 ended with the frontier drive measured at reference scale and its payoff worlds “named, instrumented, and not yet measured.” This run is that measurement, and the result has a shape I did not draw on the poster.

The drive works. The camping failure it was built against never appeared: idle was 4.9% over the whole run against the 26.7% its predecessor managed in this same world. The reversal bar I registered for it (idle above 20% after maturity) was never approached.

But watch what the drive’s own logic does to a mastered skill. The frontier drive scores places and outcomes by whether prediction error there is falling. While digging was new, digs were exactly that, and the bot dug. Once a dig predicts cleanly there is nothing left falling, the score goes flat, and the frontier is elsewhere. The era did not end because something went wrong. It ended because the era succeeded, and success is precisely what this drive is built to leave.

Two drives, two failure shapes, both now measured in the same world: competence-as-familiarity stands still forever, and frontier cannot stay anywhere. Neither contains anything that keeps a behavior because it produces something. The bot mined a log and there is no machinery anywhere in this architecture for the fact that a log is worth having. That machinery, wanting outcomes and chaining actions to get them, is now the named next question, and this run is its opening measurement rather than its answer.

The part where my equipment failed and the brain didn’t

The operator belongs in the run report too, because he turned out to be its least reliable component. In 17 days the brain process crashed zero times. It was restarted twice, deliberately, and both times it resumed from its latest snapshot, replaying 1,712 and 5,038 steps to land byte-identical, exactly the paused-not-lost guarantee this book made earlier.¹

My side of the table did worse. The telemetry pipeline’s small flushing service crash-looped 14 times over the last week (a timeout bug, still open). And on the run’s final morning the disk filled up, because the one thing nobody had told the cleanup job about was the run’s own snapshot archive. For three hours the telemetry stream had nowhere durable to land, and the stream’s buffer only holds one hour. 57,219 steps of the record aged out and are gone. The final 56 minutes survived because we pulled them off the buffer minutes before they expired. The hole is visible in the archive’s sequence numbers, on purpose.

The subject outlived the instruments. I keep rediscovering that the observer is part of the experiment, and this time it cost 57,219 steps to relearn.

Under the hood: durability by design. Telemetry fans out over NATS subjects, a JetStream ring buffer holds one hour, and a flusher writes gzip batches to S3, acknowledging only after the write lands. At-least-once, so crashes produce duplicates, never silent loss, and every batch key carries its sequence range, so loss that does occur (buffer expiry during the disk-full window) is exactly measurable: seqs 4,829,420 to 4,944,345. The post-run analysis deduplicates by sequence number per restart segment.

What seventeen days bought

Three things, none of which I would trade.

First: the watch has to live in the pipeline, not in the visitor. I pre-registered “first mined log” as a watch item and then checked for it by looking at a dashboard every few days, which is how the run’s only headline-adjacent event went unseen for thirteen days. A watch item that matters deserves a detector running on the stream, raising its hand the moment the thing happens. Written into the next run’s plan.

Second: exploration is not accumulation. Before this run I would have said a good drive is one that keeps the brain moving and learning, and by that bar the frontier drive passed everything. It also walked away from every useful thing it found, including the one object the whole experiment was watching for. A brain that never stops learning turns out to need something else too, something that lets it stop learning about a thing and start using it anyway.

Third: pre-registration is what made this chapter writable. The run produced a null result on its headline question, and because the bar, the baseline, and the duration were all on paper before boot, that null is a measurement I can publish at full volume instead of a disappointment I’d be tempted to dress up. The goalposts never moved, which is the only reason it means something to say the ball didn’t go in.

Somewhere on that server, in a hillside the bot rearranged in late July, there is an oak log it mined on day four and set back into the ground on the same afternoon. The next arc of this project is about building the part of a mind that would have kept it.

1. Chapter 11: a snapshot is the brain paused, not the brain remembering. ↩

Wanting follows expecting

The last chapter ended with a promise: the next arc of this project would be about building the part of a mind that would have kept the log. I did not know, writing the run’s closing entry on the morning of August 8, that the arc would run its first four experiments before the day was out, or that by midnight the missing part would exist, in prototype, and pass every bar set for it.

First, though, I owe the reader July.

What July had already ruled out

While the seventeen-day run was ticking along on its server, a second line of experiments had been asking the same question from the other side: short pre-registered gates, each run the day it was registered, on a faithful stand-in of the same Minecraft mechanics, one the test rig can copy and restart at will. And, for the first time in this book, a teacher.

The teaching works like this. There is a spot in the world I call the workshop: standing room, a wood column in reach, the crafting grid ready. Forty-five times, the bot’s hands are driven through the whole chain while its brain watches and learns exactly as it always does. Dig the log, twelve committed ticks. Craft planks. Craft sticks. Then the hands are given back.

What July measured, gate by gate, was a staircase of nothing. The knowledge provably arrived: taught brains carry the chain, and every later gate confirms it, because whenever anything persuades a taught bot to start the chain, the whole chain runs. But knowledge alone moved nothing: zero of 24 taught brains ever ran the chain on their own, against a bar of six. A weak pull toward the workshop moved almost nothing: two full chains across 42 runs, the first deliberate chains in the project’s history, from a gate that failed its own bar (the pull produced orbiting, a median 3.8% of time near the workshop, not holding). And approval moved nothing at all: a judge pulsed “well done” onto a sensor channel at the exact tick a stick-craft landed, forty-five times per pupil, and the brain never reliably came to expect the pulse, let alone want it. Fourteen of 24 pupils ended with a specific expectation, against a bar of eighteen; five ended anti-predictive at the exact tick the praise always arrived.

The topic was parked on July 24 with one sentence standing: no cheap mechanism converts taught knowledge into reliable directed behavior. Then the big run closed, chapter 13’s null said the missing thing is chaining, and the parked question was suddenly the only question.

A statue at the workshop

The July pull had a diagnosed flaw. Its sense of “toward the goal” was the distance between what the bot sees now and what it saw at the goal, and away from the workshop that signal is nearly flat: one step toward and one step away look almost the same on a featureless plain. So the reopened gate asked the cleanest version of the question. What if the sense of direction were perfect?

Perfect meant cheating on purpose. For each action the bot considers, the rig clones the world, takes that one step in the copy, and reads the true distance to the workshop out of the game’s own bookkeeping. That is an oracle: a measurement taken by peeking at the world’s ground truth, which the brain itself could never make, used to mark the ceiling of what any learnable version could reach. If a brain with a perfect sense of direction still does not chain, then direction was never the wall.

Getting the instrument right produced the day’s first lesson before any new result did. The gate runners live in a scratchpad and get rebuilt from the committed record when a topic reopens. The first rebuild matched every coarse anchor in the record and produced zero chains where the record held two. One configuration number was wrong: the weight cap installed against rot,¹ 0.0 where the run posture said 1.2. The registered criterion that caught it demanded identity, not resemblance: the rebuilt instrument had to reproduce July’s two recorded chains at their exact recorded ticks, seed 6 at tick 706 and seed 7 at tick 427. After the fix, it did. Coarse anchors are not identity; exact ticks are.

Then the gate ran, 24 pupils, and the holding problem died. Median time at the workshop: 99.98%, against the July form’s 3.8%. Departures: zero, in 24 runs. The second bar had been written expecting escapes and returns, and was amended openly, before the confirmatory, to the never-leaves form the pilot revealed. Presence, which two July gates had failed to buy at any price, was suddenly free.

And the chains bar failed, zero of 24. One hundred twenty thousand steps standing at the workshop, the taught chain provably in the frames, and not one log dug. Three cobblestone, across the whole arm, was the entire material record. About twenty-five times the presence bought exactly zero chain gain.

I had predicted high return rates and a narrow pass on chains, my third wrong frozen prediction at three consecutive gates. What stood instead was a statue: a bot that stands where the log is, knowing how to get it, and never starting.

The word the record settled on for what was missing is election: choosing, on purpose, to begin a sequence you know, its first step and all the steps after it. Knowing the chain was solved in July. Standing at its start was solved the same day. Election was the isolated wall.

Under the hood: the goal-homing gate. Policy term λ · (−Φ(pos_after(a))), Φ the clone-step Chebyshev distance to the workshop; subjects the 24 taught graduates, H = 5,000, fresh worlds. Bar 1 (holding, ≥ 18/24 at ≥ 20% dwell): PASS 24/24, median dwell 99.98%. Bar 2, amended to never-leaves: 0 departures in 24 runs. Bar 3 (chains ≥ 6/24): FAIL 0/24; 3 cobblestone across the arm. Against the July floor of 2 chains in 42 runs, 0/24 alone is not significant (Fisher p ≈ 0.5); the finding is the direction, roughly 25× the presence for zero chain gain. Instrument identity was gated on the two recorded chains landing at ticks 706 and 427.

The map

With the wall isolated, the question turned into why every gate kept failing the same way, and that evening the project got its working map. Every drive this brain has ever had is an appetite for learning, and both of its test worlds are paradise: idling is free, nothing decays, nothing is ever hungry. Animal motivation does not look like one mechanism. It looks like a stack. At the bottom, a budget, the calorie, life as optimization toward the calorie (an idea I took from Stephen Fry’s Great Leap Years). Above it, deficits: the budget compiled into sensations like hunger, making specific things valuable at specific times. Then option-value, where a log is money, worth having for the doors it opens. Then a completion itch that pulls begun sequences toward their ends. Then goals borrowed from a parent. Then imagination.

Each layer exists to patch the failure of the one below. A pure budget makes a miser; a pure deficit, a monomaniac; pure option-value, a hoarder; a pure itch, a grinder who cannot quit; borrowed goals, a sycophant; imagination, a dreamer. And the record’s five nulls lined up on the map as the same mistake repeated: a single upper layer, tested in a creature and a world missing the floor below it.

A map is a judgment, not a measurement. I let it order the queue, cheapest first, and I did not let it win: each layer would get its own gate, bars frozen before the runner existed.

One term separates a statue from a woodcutter

The cheapest untested layer was the itch. Digging wood in this world is twelve consecutive ticks of choosing “dig”; choose anything else and the cracks vanish. The mechanics already charge for quitting. All the brain lacked was caring.

So, one new term in the action choice, on top of the proven hold: value each candidate action by how much dig progress it would add. Starting a crack is worth a little. Continuing is worth more. Abandoning charges you everything sunk, because the world’s own reset does the bookkeeping. That is the completion itch: a small standing pull that makes begun things want finishing.

The bars were frozen first: at least 18 of 24 pupils gain a log, at least 6 of 24 complete the full chain, log to planks to sticks. A published pilot picked the smallest working dose. Then the confirmatory.

Twenty-four of 24 gained a log, 286 logs across the arm. The same graduates, under the same hold, without the itch: zero logs in 24 runs. One term separates a statue from a woodcutter.

And six of 24 ran the full chain. Exactly at the bar, not above it: a pass at the line. But the entire prior record held two chains, both existence-level flukes from a failing gate. These six were the first bar-level deliberate chains in the project’s history.

The control I care most about ran alongside: the itch without the hold. Eight wandering pupils, itch on, hold off. Two of them dug (ten logs and seven), none chained. Wanderers itch only where they happen to stand. Neither term alone does anything; the pass belongs to the composition. The map’s core claim, that layers compose where single layers fail, now had its first measurement from the passing side.

The map’s ugly-twin column earned its keep too. The itch is target-agnostic: at higher doses, pilot seeds ground out 107 to 143 cobblestone apiece, finishing any crack in reach because finishing is what the term pays for. Noted, watched, and carried forward by name.

Under the hood: the G1 gate. value(a) = drive_value(pred_a)

• 0.25 · (−Φ(pos_after(a))) + κ · (progress_after(a) − progress_now), progress read from the clone-step oracle, completion counted as full; κ* = 0.25 (smallest pilot κ with median logs ≥ 1), H = 5,000. Bar A PASS 24/24 (286 logs); Bar B PASS 6/24, at the bar (seeds 1, 3, 5, 11, 19, 20); median dwell 100.0%. Itch-only arm (λ = 0, seeds 1–8): 2/8 dig, 0/8 chain. Frozen-prediction ledger: Bar A predicted 20–23, measured 24, the fourth consecutive under-prediction; Bar B predicted 4–9, measured 6, the arc’s first prediction inside its own range.

Take away the crutch

The itch’s progress signal was still the oracle’s: the clone-step peek knew the exact crack progress every candidate action would produce, and knew a completed dig when it saw one. A mechanism that only works while a ground-truth peek feeds it is not a mechanism, it is a demo. So the next gate, registered at 21:55 the same evening, kept the identical term and swapped its signal: the brain’s own one-step prediction of its sensed mining channel. No oracle in the itch.

Both bars failed. Eleven of 24 pupils got a log, 34 logs against the oracle arm’s 286. Five of 24 chained, one pupil short of the bar.

A failure at power is only as good as its explanation, and this one arrived with its explanation pre-named. The registration had declared a noise row: how far off is the brain’s predicted progress from realized progress, on the actions it chooses? Measured: a median gap of 0.0612, against a single dig tick worth 1/12 ≈ 0.083. The brain’s model of its own progress was barely finer than the quantity the itch has to rank. The term was real; the signal feeding it was fog.

Two details said the fog was the whole story. Five chains from just 34 logs is a better conversion rate than the oracle arm’s six from 286: once a log existed, the taught chain ran, so neither knowledge nor crafting was the bottleneck. And the three arms lined up into a dose-response curve of signal quality. No itch: zero of 24 elect. Itch on a foggy signal: eleven of 24. Itch on a perfect signal: 24 of 24. Same policy shape, same hold, same graduates. Election scaled with progress-signal fidelity and with nothing else that varied.

One sentence closed the gate: the completion-pull works exactly as far as the brain can perceive its own progress. Which turned the arc’s next question from a motivation question into a perception question.

The event head

Why is the brain’s own progress signal fog? Because of what frames are. A frame earns its living by squeezing everything the body senses through a few knobs (that economy is the whole of Part 3), and squeezing keeps the smooth shape of the world while blurring spikes. A dig is eleven ticks of smoothly climbing cracks and then a cliff: the cracks vanish, a log appears in the pocket. The cliff is the event that matters, and the cliff is exactly what the squeeze blurs.

So the last gate of the night, registered at 22:49, built a second pathway that does not squeeze. For each of the twelve actions, a small separate model predicts how each of the 32 sensed numbers will change if that action is taken next. No shared knobs, no averaging across actions, and it predicts changes, not scenes. It starts at zero and learns online, one update per lived step, from exactly the stream of experience the bot’s own choices produce. I call it the event head: a small second predictor beside the frames, one model per action, built to be sharp about the moments when a number jumps.

The itch now reads the head. Even the notion of “done” became learnable: an action counts as completing when the head predicts the pocket is about to gain something.

Three bars, frozen first: the head’s progress error at least twice as fine as a dig tick, election at G1’s bar, chains at G1’s bar. The head measured 0.0081 where the frames had measured 0.0612, the same channel read ten times finer than a single tick after roughly 5,000 online updates from a cold start. Election: 24 of 24, 303 logs, above the oracle’s 286. Chains: 13 of 24. More than double the bar, and more than double what the oracle arm itself had managed.

Sit with that last one. The student beat its oracle.

The pilot had already shown why. The learned completion rule fires on any predicted pocket gain, and crafting produces pocket gains too. So planks landing in the pocket itched the same way a finishing dig did, and sticks after them. G1’s hand-built rule only ever knew about digs, because I was only thinking about digs when I wrote it. Learning generalized where the scaffold couldn’t, because the scaffold could only contain what its author foresaw.

The trophy comes with roughness attached. The learned rule is noisy: 812 of its 1,957 completion firings came with no realized gain, and that noisy rule still carried three passing bars. No cobblestone appeared at the confirmed dose; the grinding twin stayed asleep. And six pupils showed a new profile, the woodcutter-hoarder: 21 to 61 logs each, zero chains, bots that never enter the craft loop and so never learn that crafting completes. What remains of the chain bottleneck lives at the entry to crafting, not in the conversion.

My frozen predictions missed all three bars in the same direction, the sixth consecutive gate where I under-predicted a composed mechanism. I keep writing the predictions down precisely so that pattern is measurable: my intuition is systematically pessimistic about compositions, and the bars keep being the better judge.

Under the hood: the event head and the G3 gate. Per action a, Δ̂_a(obs) = W_a · [obs, 1], cold start W = 0, updated by normalized LMS: W_a += η · (Δ − Δ̂_a) · x/‖x‖², η = 0.5, one update per executed transition. Completion rule: progress_after(a) = 1.0 if Δ̂_a[pocket_total] > 1/128, else clip(obs[mining] + Δ̂_a[mining], 0, 1). Bar P: median per-seed mean |Δ̂[mining] − realized| on chosen directed actions ≤ 1/24 ≈ 0.0417; measured 0.0081 (frames: 0.0612). Bar A PASS 24/24, 303 logs; Bar B PASS 13/24; median dwell 100.0%; 20 high-progress abandons in 120,000 steps; false completions 812/1,957. Confirmatory: 24 seeds at κ* = 0.25, H = 5,000, 158 s. Ledger: P predicted 0.01–0.03, A predicted 14–20, B predicted 4–8.

Between the run’s closing entry that morning and the last confirmatory that night, the answer changed shape. The bot stays where its goal is, wants what it has begun, and finishes to exactly the degree it can expect what comes next. And expecting is now something it learns. Wanting follows expecting.

The log from chapter 13 is still in its hillside. The machinery that would have kept it now existed, passing every bar, as a scratchpad prototype with one crutch left in it: the hold that keeps the bot at the workshop still reads the position oracle, because nothing brain-side holds position yet. A prototype is not a brain. The next morning’s work was making it one.

1. Chapter 10. ↩

A label, not fuel

The morning after the night of gates, the prototype went through the front door. The instruction in the record is four words: “build it for real.” Everything else about August 9 follows from taking those words literally.

The head becomes brain state

The event head moved from the scratchpad into the brain itself. It lives beside the frames now, owned by the same store, and it learns in exactly one place: once per executed step, from the transition the bot actually lived. It ships off by default, and off means off: with the head disabled, the brain’s bytes are identical to what shipped before, proven by test, so every validated result in this book stands untouched.

The part that matters most took one line to say and carries the rest of this chapter: the head’s learned state goes into snapshots. Chapter 11’s promise, pausing without forgetting, now covers expectations. The prototype relearned its world from zero every run. A shipped brain that has learned to expect something still expects it after a restart.

The night’s result had a condition attached, and I wrote it down before shipping anything: if the shipped build failed to reproduce the gate, then the scratchpad instrument, not the mechanism, had carried the pass. The rerun on shipped components answered at a stronger standard than the condition asked for. Row for row, every pupil’s logs, chain ticks, dwell, completion counters, and prediction errors came out identical to the prototype’s confirmatory. Same verdict line: prediction error 0.0081, election 24 of 24 with 303 logs, chains 13 of 24, false completions 812 of 1,957, 159 seconds. Not replication at the level of bars, which is the house standard, but behavioral identity: the shipped pathway computes the measured instrument’s numbers in its order. There is nothing left for the instrument-versus-mechanism question to attach to.

Under the hood: feature 040. specs/040-event-pathway/, v1.1.0 → v1.2.0, additive only, 25 new tests. The head is FrameStore-owned state, config-gated by event_head_eta (0.0 = off: no state, no float work, no RNG; byte-identity proven by test against the pinned baseline). Snapshots carry it as an additive-optional key: head-off blobs are bit-identical, pre-040 blobs cold-start it, and anatomy resizes zero-initialize the new channels, drawing nothing. CompletionItchPolicy ships the measured gate arithmetic with derived channel indices. The hold stays caller-injected: the clone-step potential is research instrumentation, not brain, so the shipped product still contains nothing that holds position. Closure runner: src_closure.py, shipped components only.

July’s question, asked again

At 13:11 the same day the record says “open G5,” and the July gate this book has now mentioned twice got its rematch.

The July result: a judge watching ground truth pulsed 1.0 onto a sensor channel on the exact tick a stick-craft landed, forty-five approvals per pupil, and the brain’s predictions never reliably formed around it. Rising expectation, 18 of 24, met the bar exactly; specific expectation, 14 of 24 against a bar of 18, failed it, with five pupils anti-predictive at the very tick the praise always arrived. But July’s write-up carried a scope note that turned out to be load-bearing: the refutation is predictor-shaped, not concept-shaped. An event-sensitive predictor could reopen the question. That predictor now shipped in the product.

The instrument was rebuilt faithfully from the committed record with one addition: the head learns from the first step of the first lesson, and its learned state rides the new snapshots from segment to segment of the teaching tape. Same judge, same channel, same 45 approvals, same two bars with the same statistics. Only the predictor changed.

Rising: 24 of 24. Specific: 24 of 24. And not narrowly. Every pupil ended with a completion-tick expectation of 1.000 and an off-tick expectation of 0.000. The brain expects the well-done exactly when it always arrives and never otherwise, and the expectation was already half-formed within the first five approvals: the first-five mean was 0.450. The frames never got that far in forty-five.

Two readings sit inside the result. First, all 24 rows are identical to three decimals. The frames’ expectation had been a lottery, because their random starting weights shape what their bottleneck can carry; the head starts at zero and learns a deterministic stream deterministically. Expecting stopped depending on luck. Second, the frames’ own predictions were measured in the same run, as a context row: rising 18 of 24, specific 14 of 24. July’s exact digits. The rebuilt instrument reproduced the old result in the act of overturning it, which is as close as an experiment comes to proving it was fair both times.

I had also named a risk out loud the night before: approval is rare, one guided step in 22, and the head had only been proven on dense events like dig ticks. The worry dissolved on a distinction worth keeping. Rare in time is not rare in structure. The tick before a stick lands looks different on the sensors, because the crafting grid is showing the stick offer, and a per-action model of changes reads that precondition directly. The claim stays scoped: a rare event whose precondition is invisible to the senses is still untested ground.

Under the hood: the G5 gate. E3.0’s instrument rebuilt from its committed record: verdict channel 33 (index 32), harness-side wrapper, judge on ground-truth stick-crafts, the 034 tape, 45 snapshot-bridged demonstrations per pupil, fresh 33-dim cohort, event_head_eta = 0.5 from the first step. Instrument green: 45/45 crafts per seed, the pulse tick-stable in all 1,080 demonstrations, mute arm’s channel never left zero. Bars, July’s own statistics with the predictor swapped: P5-a rising PASS 24/24 (July 18/24), P5-b specific PASS 24/24 (July 14/24); last-5 completion-tick mean 1.000, off-tick 0.000, first-5 mean 0.450. Ledger: P5-a predicted 22–24, measured 24; P5-b predicted 19–23, measured 24, the seventh consecutive under-prediction and the first measurement above its range’s top.

What a teacher transmits

No behavior bar was registered for G5, and the registration says why: July had already measured that one-step anticipation cannot start a twenty-step chain, so a want-bar would have been theater. Instead the part of the brain that wants ran as context rows at full power, to feed the next design. The first row produced the finding I did not see coming.

V0 is the shipped composition from chapter 14, hold plus itch, with approval merely present in the world and no term reading it. On chapter 14’s cohort, that composition chained 13 of 24. On this cohort: 24 of 24, with 1,888 approvals earned and 2,473 sticks.

One variable separates the cohorts. This cohort’s event head learned through the 45 demonstrations, its state riding the snapshots from lesson to lesson, so it entered free-run already knowing the dig and craft dynamics. The cold-start cost chapter 14’s gate paid, the early stretch where the itch points nowhere because the head knows nothing yet, was simply gone, and with it the last barrier to chaining.

Teaching the predictor was worth more than eleven chains. That rewrites what teaching is in this architecture. In July, demonstrations transmitted frames: knowledge of what the world does. Through the event pathway, demonstrations now also transmit expectations: knowledge of what comes next, sharp enough to act on. And expectation alone, never wired to any reward, carried election to ceiling.

The hangover

Then the tempting step. The brain can now expect the well-done perfectly, so make it want the well-done: one new term, weighted by a dose, valuing each candidate action by the head’s own predicted change in the approval channel. Wanting praise, in the most literal sense this architecture can express.

The pilot, published before the main arm, said something was wrong at every dose. At the three doses tried, the same eight pupils earned 179, 117, and 77 approvals, against 659 with the term off. More dose earned less praise. At the higher doses behavior collapsed into log-hoarding with zero sticks (one pupil stacked 100 logs; another, at the highest dose, 156). The bot stopped doing the thing that earns praise.

The 24-pupil arm at the smallest dose confirmed the shape. Chains 23 of 24, so capability survived. But approvals earned came to 572 against V0’s 1,888, and sticks to 863 against 2,473. Valuing the expectation of praise taxed the earning of it by about 70%, at the smallest dose tried.

The rows support a mechanism, and it is uncomfortably clean. Praise here is a pulse: 1.0 on the tick, 0.0 after. The head learns that decay the way it learns everything, online, per action. So every familiar continuation of the praised loop, the very actions that lead back toward the next craft, comes to predict approval falling, and the new term taxes them for it, while actions the bot has never tried predict nothing and go untaxed. The moment praise lands, the term pushes the bot away from its own praised loop. I call this the post-approval hangover: the measured backfire of making expected praise valuable, where the praised loop’s own next steps all predict praise going away, so the bot avoids the loop that earned it.

The watch I had pre-registered was for the opposite disease. Sycophancy: praise-farming, the approval signal gamed, sticks inflated while real capability stalls. The rows show none of it, in either arm. No stick inflation, exploration flat, the hold intact. The watch closed with its question inverted. The measured failure mode of wiring approval into value is not sycophancy. It is avoidance.

Under the hood: the V+ arm. V+ = V0 plus κ₅ · Δ̂_a[verdict] through the shipped policy seam. Pilot seeds 1–8 × κ₅ ∈ {0.25, 1, 4}: firings 179 / 117 / 77 vs 659 at κ₅ = 0; at κ₅ ≥ 1, log-hoarding with zero sticks (seed 2: 100 logs; seed 6 at κ₅ = 4: 156). Arm, 24 seeds at κ₅* = 0.25: chains 23/24 (seed 12 the miss), firings 572 vs V0’s 1,888, sticks 863 vs 2,473, median dwell 100.0%, unique positions median 22 vs V0’s ~20. Mechanism reading: the verdict’s 1 → 0 post-firing decay is learned per action, so familiar continuations accumulate Δ̂[verdict] ≈ −1 and are taxed −κ₅ every post-firing tick. The hangover reading reopens if a replication with the decay excluded from learning, or the term gated off post-firing ticks, fails to restore V0’s earning rate; the tax would then live elsewhere.

The open question

The successor gate has a name, E3.1: the anticipated verdict wired into a want, properly designed this time. It reopens behind a design conversation, not a build, and its registration owes answers to a measured hazard list. One-step anticipation cannot start a twenty-step chain. A value term on a still-learning expectation repels the learner from its own praised loop. And at higher doses the repulsion collapses the behavior entirely.

On the other side of the ledger sits the day’s gift. In every measured row of this arc, praise worked when it told the brain what to expect, and hurt when it was made worth something. The teacher’s well-done turned out to be for information, not for payment: my pupil learns most from praise when the praise is a label on the moment, not fuel for reaching it.

Whether a mind can want its teacher’s approval without the wanting eating the earning is, as I write this, an open question with a measured hazard list and no design. That is the current edge of the record. The bar gets written before the mechanism does.

The steps, not the ingredients

The open question at the end of the last chapter did not stay open for an afternoon.

Praise as a label rather than fuel was a sentence in a conversation. Turning it into a mechanism was almost free, because the shipped completion rule already had the right shape. It counts a finished thing as done, and a label only has to say which finished things count for more. By the time that gate was registered, two unrelated questions were also ready to run. Could the bot hold its position without peeking at the world’s own bookkeeping? And would any of this look different in a world where standing still costs something?

So I asked whether all three could run at once, autonomously, while I was doing something else. Three gates, three sets of bars, every bar frozen before any of the runners existed, all three decided before the end of the day.

One passed. Two failed in the most useful way a gate can fail: each named its own successor, and by midnight both successors had been designed, run, and measured.

The last crutch

The composition from chapter 14 still carried one piece of laboratory equipment. To decide whether stepping north takes it nearer the workshop, the bot copied the whole world, took the step in the copy, and read the true distance out of the game’s bookkeeping. A brain that ships inside a robot cannot copy the world it lives in. As long as that term stayed, the whole staying-and-finishing life was a demonstration rather than something a body could do.

The replacement was already in the product. The event head predicts, for each of the twelve actions, how every sensed number will change if that action is taken next. Two of those numbers are the bot’s own position. So stop asking the world and ask the head: if I step this way, what will my position readings say? Measure the distance from that predicted position to the position it was taught to work at.

Two channels out of thirty-two. That is the entire difference between this and the July failure the book keeps returning to. July’s pull measured distance over the whole observation, all thirty-two numbers at once, and bought 3.8% dwell. The wall was never that observations cannot carry a hold. It was that one number cannot summarize thirty-two channels, and I had been blaming the wrong half of that sentence since July.

Median dwell, 24 pupils: 98.22%, against the clone oracle’s 99.98%. The bar was 20%. And the whole composition survived the swap: 23 of 24 pupils ran the full chain, 647 logs, 1,919 sticks, with the drive coming from the frames, the hold from the head’s predicted positions, and the itch from the head’s predicted progress. No ground truth anywhere in the loop.

The registered context row is the part I like. The teaching tape holds only turns, so these graduates had watched themselves pivot forty-five times and had never once watched themselves walk. They entered their first free run with no model of what walking does to their own position, holding station by predicting a motion they had never seen. Median dwell over the first thousand steps: 91.5%. Over the last thousand: 100.0%. In between, from nothing but its own random exploration steps, the bot learned its legs, inside the first fifth of the run.

Under the hood: the brain-side hold. Φ̂(a) = 64 · Chebyshev(obs[x,z] + Δ̂ₐ[x,z], goal[x,z]), the goal being the position channels of the taught goal observation; hold(a) = λ · (−Φ̂(a)), λ = 0.25; Δ̂ₐ from the head, the term contributing 0 when the head is off. Subjects: the 24 G5 graduates, H = 5,000, 308 s for both arms. H1a, hold alone, bar ≥ 20% dwell: PASS, median 98.22% (clone reference 99.98%); context row, median dwell 91.5% over the first 1,000 steps rising to 100.0% over the last 1,000, movement models cold at the start because the tape holds only turns. H1b, full composition, bar ≥ 6/24 chains: PASS 23/24, 647 logs, 1,919 sticks (clone reference 24/24). Graduated as design Doc 0009: shipped components plus about fifteen lines of caller-side composition, so a src build is licensed and not demanded. Standing reversal watch: a long run whose head-derived hold drifts off the goal after long homeostasis reopens this as a memory question rather than a prediction one.

A label with nowhere to walk

The label gate needed a world where the parent wants something the pupil does not. That was easy to arrange, because at the measured operating point these bots do the wood chain and mine exactly zero cobblestone. So the parent applauds cobblestone. Never sticks.

The teaching tape grew twelve stone lessons beside its forty-five wood ones: walk to the wall, dig for three ticks, one cobblestone in the pocket, one round of applause at a fixed tick. Then the label went into the completion rule and nowhere else. When the rule fires for an action, an applauded completion counts fuller than a plain one. The level of expected praise is never valued on any other tick, which means the hangover from the last chapter cannot form. Not unlikely to form. Mechanically excluded, because no tick after praise ever reads the channel.

It worked exactly as designed and moved nothing at all.

Zero cobblestone in the pilot, at every dose. Zero in the 24-pupil arm. Not one pupil, not one stone. Meanwhile the wood chain held at 22 of 24 with 1,492 sticks, so the label did no damage at any dose, against the 70% tax the praise-as-fuel term charged. Perfectly safe and perfectly inert.

I had also pre-registered the sycophancy row this world finally made measurable: cobblestone gain events against net new cobblestone, because a bot can place a stone and dig it again forever to farm applause. The row had nothing to measure. The bot never went to the wall.

The mechanism is the myopia the decision rule had named in advance. The label pays one step away from a finished mineral dig. Nothing in the composition values the walk to the mineral face, and the walk is where all the cost is. Dwell 100%: the bot stands in the wood loop, which pays on almost every tick, and the walk to the wall pays nothing at all until its final step.

Twelve demonstrations of the walk to the wall. Applause at the end of every one. A predictor that the same day’s earlier gate had measured expecting praise at ceiling. And no walking.

Because the frozen decision rule had already said what a transmission failure would mean, the failure did the promoting instead of me: the reach question, which had been sitting in the queue as a refinement, became a prerequisite for the whole borrowed-goals layer. I had predicted 14 to 20 pupils would reach the stone. Measured zero, the first time in this arc I had over-predicted rather than under-predicted, and the ledger’s lesson sharpened into something I can use. I under-predict what composed mechanisms do. I over-predict how far a one-step term can reach.

Under the hood: the label gate (E3.1). Fresh 33-dim cohort, event_head_eta = 0.5, 45 wood segments with the verdict silent plus 12 cobble segments (tape [3,3,0,0,5,5,5, idle×15]). Instrument gate green: 45/45 wood crafts per pupil, exactly one cobble gain and one firing per cobble segment, tick-stable, wood segments silent. The label: inside a fired completion, progress_after = 1.0 + β · clip(Δ̂ₐ[verdict], 0, 1), with Δ̂[verdict] read nowhere else, so no post-firing tick can be taxed. Clone hold λ = 0.25, κ = 0.25, H = 5,000. Pilot, seeds 1–8 × β ∈ {0.5, 1, 2}: 0/8 cobble at every β, chains 8/8 everywhere; β* = 0.5 by the registered tie-to-smallest rule. Arm: Bar T1 FAIL 0/24 (bar ≥ 12), Bar T2 PASS 22/24 chains with 1,492 sticks, median dwell 100.0%, farming row empty because the events never happened. Ledger: T1 predicted 14–20, measured 0.

A world where standing still costs something

Both of this project’s test worlds are paradise. Idling is free, nothing decays, nothing is ever hungry, and every drive the brain has ever had is an appetite for learning. That was the bottom of the map in chapter 14, and the third gate of the afternoon put a floor under it.

Life burns calories; acquiring things restores them. In mechanical terms: one more sensed number, energy, starting at 1.0 and draining 0.0005 every tick, so a bot that does nothing dies in about two thousand ticks. Every pocket gain adds 0.1, capped at full. Zero is death.

The part I find elegant is that nothing in the brain was told about any of this. The completion itch was built to finish begun things. Finishing things is now also how the bot eats, so the itch became a survival mechanism without survival ever being wired as a goal.

The first bar asked whether the meter has teeth. The frontier drive on its own, the curious version of this brain with no hold and no itch, died at a median of 2,001 ticks, with dwell under 1% and not a single acquisition anywhere in 24 runs. The record’s oldest null, a brain that learns eagerly and picks nothing up, now has a body count.

The second bar asked whether the stack feeds itself, and it split in half. All 24 pupils worked: every one gained logs, 1,905 sticks across the arm, unique positions at a median of 22, so the miser twin the registration was watching for never appeared. And 10 of 24 were still alive at step 5,000, against a bar of 18.

The rows say why, and it is not a conflict between the layers. The energy runway from a cold start is about 2,000 ticks. This cohort’s median time to its first completed chain is about 2,300. The floor races learning and wins by three hundred ticks. The pupils that chained early lived off their own work; the rest died in the middle of it, having done everything right and slowly.

Which left two options. I could re-dose the decay until the numbers passed, which is cheating with extra arithmetic. Or I could look at the shape of the gap: a stretch of early life where the creature is competent enough to learn and not yet competent enough to eat. No animal is born into full stakes.

What a demonstration carries

That evening I wrote the premise for the reach problem down in the registration, in my own words, and the record kept them: this is what is being taught by the teachers as they teach the recipe. it involves the steps, not just the ingredients.

The two roads I could see were both expensive. I could hand the brain a ladder of subgoals, which means declaring the order myself, which is an old disease wearing a new hat: the designer answering a question the brain is supposed to answer for itself.¹ Or I could build learned decomposition, planning over imagined rollouts, a research program measured in months.

The third road only becomes visible once you notice what a demonstration is. Forty-five times the bot’s hands had been walked through the wood chain, twelve times to the stone wall. Every one of those was recorded in the same sensor readings the bot uses to think with, in order, with the applause in the right place. The order was in the teaching all along. Nothing in the brain was keeping it: the frames learn what one step does, the head learns what one action changes, and neither of them stores a sequence.

So the new machinery is a recipe memory: the remembered sequence of observations from a demonstrated success, kept whole and in order, so the steps that led to a result can be walked again. One recipe per finished item, the last demonstration of it. This cohort had two. Wood, ending in sticks, with no applause anywhere. Stone, ending in cobblestone, with the parent’s approval stored inside the remembered ending.

Choosing between them is one line. At each step, score every stored recipe by what its ending is worth to the bot’s own drive, plus the applause remembered at that ending. The parent’s approval, recalled rather than felt, marks which ending matters. Following one is the hold from earlier in this chapter, pointed one step further along: the subgoal is the next position in the recipe instead of the final workshop, and the pointer advances when the bot gets within a block. Transport only. Digging and crafting at each stop stay the itch’s job.

Against the label’s floor of zero, on the same cohort, with the same demonstrations: 24 of 24 pupils reached the stone. 3,129 cobblestone gain events across the arm.

The wood chain survived at 18 of 24, exactly at its bar and two below the label arm’s 22, and the twin the registration had named in advance is why. The obsessive is a bot whose borrowed goal eclipses its own: dwell medians fell to somewhere between 55% and 72% as pupils split their days between the tree and the wall. The dose is visible in the rows, which is the useful part. At the pilot’s highest setting the wood chains sagged to 4 of 8, so 0.5 is the honest operating point and I can see the cliff from there.

The third bar asked whether the walk was walked or stumbled into. Of the pupils that mined stone, 20 of 24 made at least two pointer advances along the taught path before their first cobblestone. The parrot, the other named twin, is a bot performing recipe steps somewhere they do not apply, and it stayed modest at about 2% of steps.

One instrument failure belongs in the middle of this. The first pilot ran with its applause marker inert: the code that picks the remembered ending read the idle tail of the tape, so both recipes recorded no applause at all. The bots pursued the stone anyway. With approval invisible, the drive’s own pull toward the newer of the two recipes was enough at pilot scale. I fixed the marker, which is now the highest-applause observation in the whole remembered sequence, republished the pilot before the arm, and kept the broken row, because it is the only measurement I have of what novelty alone would do.

E3.1 had said reach blocks the borrowed-goals layer. Reach was never missing from the mechanism. It was sitting in the teaching, and the only new machinery is a pointer.

Under the hood: recipe memory. Extraction, from the witnessed teaching stream and nothing else: a recipe is the observation sequence of a demonstrated segment ending in a pocket-gain event, one canonical recipe per terminal item (the last demonstrated instance). Selection, each directed step: argmax over stored recipes of drive_value_of(terminal_obs) + β · terminal_obs[verdict]. Following: the pointer starts at the recipe step nearest the current position (position channels, world units), the subgoal is the next step’s position, the added term is λ_r · (−Φ̂_subgoal(a)) with Φ̂ from the head’s predicted positions, advance within 1 block; transport only. Dials λ_r = 0.25, κ = 0.25, clone-free throughout; β piloted on {0.5, 1, 2}, β* = 0.5. Arm: 24 seeds on the E3.1 cohort, H = 5,000. Bar R1 transmission PASS 24/24 (bar ≥ 12; the label-alone floor 0/24), 3,129 cobblestone gain events. Bar R2 own goals PASS 18/24, at the bar; pilot β = 2.0 sagged chains to 4/8. Bar R3 recipe-led PASS 20/24 with ≥ 2 subgoal advances before first cobble; parrot row ~2% of steps out of context. Named successor: recombination, recipes composed across taught fragments, which is the real means-ends question.

A childhood

The meter’s gap wanted the oldest mechanism there is. Provisioning is a parent covering a child’s costs until the child’s own competence can pay them, and every creature that has to learn a living gets some of it. So the dose I chose was not a smaller number for the drain. It was a shape: the parent pays the whole metabolic bill through tick 1,500, then coverage fades in a straight line to nothing at 3,000, and the bot lives at full stakes from there. One childhood, at the start of one life. The record calls that particular dose the stipend, and the way it fades is the first weaning this project has been able to watch.

The bars went in before the run, and the first one carried a number I was oddly pleased about. If a bot never feeds itself, the taper’s arithmetic says it should die at about tick 4,250. The frontier drive’s median survival, measured: 4,250. Nine predictions into this arc’s ledger, not one of them had landed on its number rather than somewhere near it. This one did.

The provisioned composition went from 10 of 24 alive to 24 of 24 alive, with 24 of 24 still working, 2,304 sticks, unique positions at a median of 20 and the miser still nowhere in the rows. The weaning window shows the stipend fading and the work continuing through it.

The parent’s first gift is not knowledge and not approval. It is time. Provisioning turns the floor from a race against learning into ground underneath it, and it does that without softening the stakes for a bot that chooses to do nothing, which still dies on schedule. Both of that evening’s answers turned out to be teachers: steps for reach, time for survival.

Under the hood: the meter, both doses. The rig’s world wrapper appends energy at channel index 32 (no verdict in this world): start 1.0, drain 0.0005/tick, +0.1 per pocket-gain tick capped at 1.0, death at 0 (first zero tick recorded; the run continues so the rest can be measured). G4, H = 5,000, 24 seeds per arm: Bar M1, frontier-alone median survival < 3,000, PASS at 2,001 with dwell < 1% and zero gains; Bar M2, ≥ 18/24 alive AND ≥ 18/24 gaining a log, FAIL 10/24 alive with 24/24 working, 1,905 sticks, unique positions median 22. Teaching itself never kills anyone: each segment’s ~9 gain events dwarf its 0.011 of decay. G4b’s stipend: effective drain = 0.0005 · clip((t − 1500)/1500, 0, 1), feeding unchanged. Bar M1b PASS, frontier median 4,250 against a registration that named that tick and a frozen range of 4,200–4,400; Bar M2b PASS 24/24 alive and 24/24 working, 2,304 sticks, unique positions median 20. Ledger: M2 predicted 22–24 alive, measured 10; M1b is the first exact hit the ledger has recorded.

One brain, one world

By the end of that day every part of the measured life was either shipped in the product or taught by a demonstration, and nothing in the loop peeked at the world’s bookkeeping. That licensed a run the last long one could not be. Chapter 13 asked whether crafting would emerge unaided in a real game at real speed, and got a clean null. This one asks a different question: does the measured life endure?

The setup is one brain and one life. A taught graduate of the meter cohort boots into a world that persists from that moment on, with no resets and no fresh starts, its drive from the frames, its hold from its own predicted positions, its itch at the same dose every gate this month has used, and the tapered childhood at the front. One new world rule was necessary and is recorded as such: a dug column grows back two thousand ticks later, wood and stone alike, because a three-tree world cannot feed a life of millions of steps.

The lab world runs at roughly five hundred brain steps a second. A brain step is five game ticks and Minecraft’s clock is twenty ticks a second, which makes the run about 125 times faster than real time. The target is fifty million steps, ten times what chapter 13’s run lived, in a weekend of wall clock.

Then the first segment came back and told me my own stop rule was broken.

Five stop rules were frozen in the run plan, and one of them was the early graduation I had asked for: stop at two thousand completed chains. Segment one produced 131 chains in 50,007 steps. At that rate the run would have declared victory at about one and a half percent of its target, with none of the endurance readings it exists to produce. The chain bar had been dosed against the old scarcity, back when a dug tree stayed dug.

So the stop file went down at the next boundary, the amendment went into the plan with segment one’s raw numbers written into it, and the run resumed from its snapshot. Graduation now needs two thousand chains and twenty-five million steps. The whole correction cost two segments, because the thing chapter 11 promised about snapshots is also what makes an honest mid-flight amendment cheap: stop, write it down, resume the same brain.

At step 1,000,121 the row reads 3,236 chains since birth, dwell 99.99%, energy 0.980 out of a possible 1.0, which is a bot feeding itself without ever having been told to.

And one thing I did not design. For nine segments the pocket gained no cobblestone whatsoever. In the segment ending at step 500,061 it gained 691, and after that the stone never stopped: the segment that crosses the millionth step counts 1,400 cobblestone beside 1,651 logs and 5,544 sticks, each of those figures net of what crafting consumed. There is no recipe memory in this run and no label. What there is, is an itch that pays for finishing anything finishable and a meter that counts any pocket gain as food. My reading: somewhere in the first half-million steps the bot found the stone face and added it to the rotation, and chapter 14’s grinding twin, the learner that cannot quit a paying loop, has turned up here as a hobby that pays for itself.

The run is still going as I write this. The deciles that answer the endurance questions are not in. What is in is the first fiftieth of a planned life, with no death, no drift off the work position, and no sign yet of the composition wearing out.

Under the hood: the c1d-lab run plan. Brain: the G4 meter cohort’s graduate seed 1 (33-dim, head trained through 45 demonstrations, event_head_eta = 0.5); world state persisted in every snapshot, no resets after boot. Policy, all shipped seams and zero ground truth: the frames’ drive + the Doc 0009 hold (goal = the taught work position, λ = 0.25) + CompletionItchPolicy at κ = 0.25. World renewal: a dug column regrows 2,000 ticks after it was dug, wood and mineral alike, placed blocks untouched. Execution: ~50,000-step segments (2,273 cycles), a disk snapshot at every boundary so the run is crash-resumable, per-segment rows appended to c1d-status.jsonl; engine telemetry accumulators are trimmed to a recent window between segments at 50M-step scale, so the readings come from the per-segment rows rather than the engine summary. Each row’s item counts are that segment’s net pocket change per item, so its log count is digs minus what crafting consumed. Pre-registered readings, by 5M-step decile: chains (endurance), dwell (episode 0074’s drift watch), the policy’s progress-prediction error EMA and the head’s update count (NLMS wander at 50M steps is this run’s novel exposure), the life itself, and unique positions (the miser). Stop rules: death; ≥ 2,000 chains AND ≥ 25M steps (the amendment; the original rule was the bare chain count); zero chains across any consecutive 10M steps after childhood; the c1d-STOP file; otherwise 50M. Measured segment rates fall from 501 steps/s at segment 1 to 80 by segment 28, which makes the weekend estimate optimistic; I have not diagnosed it.

A time machine with unreliable hands

The other half of the plan was running the same night, and it is the reason this chapter ends on a machine rather than a mind. Every number in this chapter came out of the lab world, the faithful stand-in the test rig can copy and restart at will. Chapter 13’s null came out of the real game, at real speed, over seventeen days. If the measured life is ever going to be asked the endurance question in the full game, the full game has to run faster than a life.

It turns out vanilla Minecraft has shipped that switch since version 1.20.3. A server console command sets the tick rate anywhere from 1 to 10,000 ticks a second, and the version this project already pins has it. The pacing on our side was a single number: the bridge sleeps a fixed slice of wall clock per brain step, so dividing that slice by the speed multiplier keeps the posture chapter 13 ran at, about five game ticks per brain step.

Two of the three bars passed everywhere. The server sustained every speed asked of it: 19.9, 40.0, 100.0, and between 199.9 and 200.1 ticks per second against nominals of 20, 40, 100, and 200. At five times speed it was spending about 1.6 milliseconds of a 10-millisecond tick budget, so ten times was nowhere near a ceiling. And the posture held to the tick, between 5.02 and 5.29 game ticks per brain step at every speed. The pacing law is real, and vanilla Minecraft runs ten times fast with exact throughput.

The bar that failed was the bot’s hands, and it failed at normal speed.

Five attempts to dig an oak log at each of four speeds completed 3, 4, 2, and 4 times. There is no speed trend in those numbers. Normal speed misses the bar by itself, which means the bar as I wrote it could not measure what it was for: it conflated a flake the bridge has always had with an effect of acceleration. The bridge’s own logs name the flake, digs aborting somewhere between 26 and 800 milliseconds into the break, and chapter 13’s run lived with it unmeasured because its 449 digs never needed any single attempt to succeed.

Every dig that did complete crafted successfully, five out of five. The pipeline is fine. The hands are not.

So that bar gets re-registered rather than quietly retried: a relative bar, success at speed measured against the same bridge’s own normal-speed rate with at least twenty attempts per arm, and it goes in after the dig question gets its own small investigation. On the way through, four instrument bugs were found and fixed: the bridge died when a vanished client handed it a broken pipe, the console tool reads negative coordinates as command flags unless you warn it, the game’s rotation zero is the bridge library’s yaw π so the two conventions sit 180 degrees apart, and the registered distortion finally showed itself in practice. The bot’s body runs on wall clock while the world runs on the accelerated tick, so at ten times speed crossing a single block took 17 brain steps against 4 at normal speed. The faster the world, the slower the bot inside it.

The time machine exists. At ten times speed, the seventeen days of chapter 13 fit inside two, which is the difference between a run that costs a fortnight and a run that costs a weekend. Whether anything measured in there can be believed depends on a bot that misses two digs in five, and that is where the next chapter starts.

Under the hood: the /tick rate calibration. Local fresh flat vanilla 1.21.11 over RCON on an isolated volume, never c1c’s data; the bridge patched only to report the server’s game-tick clock in every view; a micro-arena (an oak column beside the bot) rebuilt per rep; per M ∈ {1, 2, 5, 10}: /tick rate 20·M, tick_ms = 250/M, five reps of dig-log-then-craft-planks, ≥ 3 wall-minutes of stepping. Bar B1, measured TPS ≥ 90% of nominal 20·M with the bot attached and working: PASS at every M (19.9 / 40.0 / 100.0 / 199.9–200.1; ~1.6 ms per tick against a 10 ms budget at M = 5). Bar B3, mean game ticks per brain step within 5 ± 1: PASS at every M (5.02–5.29). Bar B2, 5/5 digs and 5/5 crafts at each passing M: the M = 1 reference fails its own bar (3/5, 4/5, 2/5, 4/5 across M ∈ {1, 2, 5, 10}, no speed trend; 5/5 craft conversion on completed digs; bridge logs attribute it to mineflayer digs aborting mid-break, 26–800 ms in, a 1×-native behavior c1c lived with unmeasured), so the bar is unmeasurable as written and the raw numbers are recorded under the amendment protocol. Successor B2′, a re-registration: success rate at M within noise of the 1× reference, n ≥ 20 reps per arm, gated behind a fix-and-gate on dig reliability. Registered distortion, measured for the first time: the bot’s physics are wall-clock, so at M = 10 a collect-walk took 17 brain steps to cross a block against 4 at M = 1, and the bot slows by 1/M relative to mobs, crops, and daylight.

1. Chapter 3: the brain must discover its own size, with nobody telling it. ↩

Glossary

Every italicized first-use definition from the main text, in order of appearance. Plain words only; the technical version lives in the chapter’s Under the hood boxes.

Part 1

training — the study phase of a machine brain: learning from a big pile of examples before the machine ever does its real job. (Ch 1)

frozen — a brain whose learning has been switched off: a snapshot of what was learned during training, shipped as the product. (Ch 1)

catastrophic forgetting — new learning destroying old competence, because both are stored in the same shared numbers. (Ch 2)

dimensions — the separate knobs you’d need on a control panel to pin down what state a thing is in; a world’s hidden size is its knob count. (Ch 3)

Part 2

triplet — one recorded moment of experience: what I sensed, what I did, and what I sensed next. The only input PRA ever learns from. (Ch 4)

observation — one simultaneous reading of every sensor, packed into a fixed-order list of numbers. The “before” and “after” of a triplet are both observations. (Ch 4)

Part 3

frame — one member of the crowd: a bet that the world can be described with a particular number of knobs, backed by placing every sight on those knobs and predicting where they’ll land next. (Ch 6)

pose — where a frame’s knobs point for the current observation: the frame’s reading of one moment, expressed in its own coordinates. Not the frame itself, and not the world. (Ch 6)

encoder — the small network that reads one observation onto a frame’s knobs: observation in, pose out. (Ch 6)

decoder — the encoder’s mirror: pose in, reconstructed observation out, proving the frame’s knobs can still express what it is looking at. (Ch 6)

drive — the fixed, unlearnable rule that scores which action looks worth taking; the system’s motivation, kept outside the market. (Ch 9)

competence drive — the shipped default motivation: prefer the familiar and the mastered, weighted by how well prediction is going there. (Ch 9)

frontier drive — the current edge: prefer places where prediction error has been falling, so noise and mastered ground both score zero. (Ch 9)

Part 4

snapshot — the brain paused into a file: the complete learned state written out, so the same mind can be stopped, copied, moved, and resumed exactly. (Ch 11)

Part 5

pre-registration — deciding what will count as success, and what will count as failure, before an experiment runs, so the goalposts cannot move once the data is in. (Ch 13)

Part 6

oracle — a measurement taken by peeking at the world’s ground truth, which the brain itself could never make, used to mark the ceiling of what any learnable version could reach. (Ch 14)

election — choosing, on purpose, to begin a sequence you know: its first step and all the steps after it. (Ch 14)

completion itch — a small standing pull that makes begun things want finishing: starting is worth a little, continuing is worth more, and abandoning charges everything sunk. (Ch 14)

event head — a small second predictor beside the frames, one model per action, predicting how every sensed number will change next; learned online from lived steps and built to be sharp about the moments when a number jumps. (Ch 14)

post-approval hangover — the measured backfire of making expected praise valuable: right after praise lands, the praised loop’s own next steps all predict praise going away, so the learner avoids the loop that earned it. (Ch 15)

recipe memory — the remembered sequence of observations from a demonstrated success, kept whole and in order, so the steps that led to a result can be walked again. (Ch 16)

the obsessive — the failure twin of a borrowed goal: a learner that pursues what its teacher applauds until its own goals lose time to it. (Ch 16)

the parrot — the failure twin of taught order: a learner performing remembered recipe steps somewhere they do not apply. (Ch 16)

provisioning — a parent covering a child’s costs until the child’s own competence can pay them. (Ch 16)

the stipend — this project’s measured dose of provisioning: the parent pays the whole metabolic bill through tick 1,500, then coverage fades in a straight line to nothing at tick 3,000, and the learner lives at full stakes after that. (Ch 16)

Acknowledgments

The frames at the heart of this book have an ancestor. Jeff Hawkins and the Numenta team’s Thousand Brains Theory proposed that a brain is many small models with their own reference frames, learning through movement and prediction, and that idea is load-bearing here: PRA keeps the sensorimotor-prediction core because that is the part that does the real work. Where PRA departs is in making two things explicit that the theory left open: a metric for scoring one interpretation against another, and a mechanism by which the set of frames is itself learned, by selection rather than search. The departures are documented, claim by claim, in the project’s design record. The debt is documented here.