Paths, Not Points

Picture a food truck testing a new menu. Every day the cook tries something - a taco, a rice bowl, a sandwich - and watches what sells. Most days are a mix of hits and misses, and he adjusts from there. Then one day he lands on something that sells out in twenty minutes flat, every single time, in every neighborhood he parks in: a bacon-wrapped hot dog. So he stops testing. The tacos go. The bowls go. Within a month the whole menu, in every city, is that same hot dog with a different name chalked on the board.

Ian Goodfellow built exactly this dynamic into a pair of neural networks in 2014. One network - the generator - is the cook: it takes random noise and turns it into a handwritten digit, zero through nine. The other - the discriminator - is the customer: it looks at what came out and decides real or fake. Train the two against each other long enough and the generator should learn to produce all ten digits convincingly, the way the truck should end up with a whole working menu.

Here’s what actually happened instead. The generator found one digit the discriminator could never catch: a single, unnervingly crisp “6.” So it stopped producing anything else. Feed it any scrap of random noise you want, and it hands you back that same “6” - the hot dog with a different name on the board.

Goodfellow had a name for this, dry as anything: the Helvetica scenario - a print shop that can typeset any letterform on earth quietly decides the only font worth making, forever, is Helvetica. This is mode collapse, and it gets worse before it gets interesting. The discriminator eventually learns to reject “6” - and the generator doesn’t go back to producing the nine digits it abandoned. It lurches to producing only “8,” then only “3,”, cycling through single digits, like rock-paper-scissors played by someone who’s forgotten there are more than three moves. It’s never not collapsed - just collapsed onto something new each round. The whole set of ten digits sits there the entire time, fully within reach. The architecture can represent all of them. The trained network has simply closed off nine, and keeps no record that it did.

Here’s the part that should bother you. Each “6” looks great. Show a human a handful of samples and they see crisp, realistic digits and conclude the model works - GAN samples have passed honest visual Turing tests. The pathology is invisible at the level of a single sample. It only shows up when you ask for coverage across all ten digits, and by then nine of them are already gone. Every local check passes. Diversity dies anyway.

That failure has a precise shape, and it’s the shape of the whole post. The generator found the one output that won, and kept no record of the nine it stopped producing. It can repeat that success forever and never learn what producing it cost. The cook can tell you the hot dog sold out again. He can’t tell you what happened to the rest of the menu. A system can log a path. The harder thing - the thing it never had - is a map of what the path closed.

The bigger question.

Mode collapse is just the cleanest place to see this pattern, because you can count it: ten digits in, one digit out, nine gone missing. Most of the time the collapse isn’t so countable. It shows up in a conversation you can feel narrowing before anyone says anything wrong. In a research direction that’s gone sterile a week before the data agrees. In a model that’s gotten very good at one kind of answer and stopped surprising you. Every local move looked fine. The space closed anyway.

So here is the question I keep coming back to. How should a system choose a move when it can’t see the future, and what is it supposed to be optimizing while it does?

TLDR: This is the sequel to the geometry of surprise - that post was about the signal a system learns from, this one is about the signal it optimizes toward. Every signal we train on - scalar reward, dense reward, return distributions, bits of empowerment - is a valuation: a score of the path that got taken. I think that’s the wrong type of thing to optimize for discovery, which isn’t about the path you took but about what taking it did to the paths you didn’t. The signal should be a signed change in what’s still reachable, attributable to a move - a difference over possibility-space, not a value over the trajectory. That diagnosis is the part I’m sure of; how you’d actually write such a signal down is the part I’m still building. I call the mode we train today the recorder and the mode we’re missing the mapper, and I’m trying to build one. If you want to build it with me, or if you think I’m wrong, DM me.

What discovery actually needs.

Richard Sutton has a way of describing this that stuck with me. During training, our models vary plenty. They try things. What they can’t do well is discover, because they don’t retain the right thing from what they tried - the novelty flickers up and is lost. I think that’s right, and I think it stops one step short, because the missing capability has a name. It’s metacognition, and it’s two things, not one: a sense of whether the path you’re on is worth staying on, and a sense of whether you’re even asking the right question by being on it. Those fail differently. The first is a model that keeps grinding on a bad answer. The second is a model that gets excellent at answering a question nobody needs answered anymore, and never notices the question changed. A model that discovers has to do more than spit out candidates and keep the winners. It needs some sense of what asking this question, this way, is costing it.

So here are the two modes. The recorder files a valuation on the path it took; the mapper tracks what that move did to the paths it didn’t.

The recorder.

Take almost any training signal we use. Cross entropy scores each token against what came next, one position at a time, while preference reward scores a whole trajectory and hands back a single number. They look different, but underneath they share a type: each is a valuation - a score of the path that actually got taken. Good path or bad path, this token up, that one down. And you can dress the valuation up as far as you like, a dense reward instead of a sparse one, a distribution instead of a scalar, and the type doesn’t change. It stays a number about the realized path. What it never becomes is a map of what that path opened or closed.

That’s the recorder. It watches a trajectory play out, decides afterward whether it was good or bad, and pushes that score back onto whatever produced it. Good path, do more of that. Bad path, do less. It never asks what else was on the table.

You can feel the recorder in any LLM you use. Once a conversation commits to a path, you’re stuck on it, and if you want a real alternative you open a fresh chat. The model has no handle on the branch it took; it only has the tokens it’s producing now. Same disease as the generator, slower onset.

A lot of continual-learning work inherits this too. Trajectory bills itself as the platform for continual learning, and half the posts in my feed are some version of models that keep learning after they ship. That instinct is right - these are real systems learning from experience instead of freezing at a checkpoint. But look at what the model is actually told after each interaction, and it’s still a verdict on the path, not a map of what the path made possible. The loop got longer. The signal didn’t change shape.

Sidenote: SDPO, Stepwise Diffusion Policy Optimization, is the most refined recorder I know and a real step - instead of dropping one scalar at the end, it tracks the clean state at each denoising step and spreads dense reward along the path, so credit lands closer to where it belongs. But the path still comes out as a verdict. Good segment, bad segment, reinforce this, suppress that. What it never learns is what the move did to the space of paths.

The tutor.

Here’s the intuition I keep in my head for the thing the recorder can’t do. Sit in a tutor’s chair. A student says “yeah, I think I get it,” and you have about a second to decide what that sentence means. Maybe they do get it, maybe they half get it and want to move on before they look slow, maybe they’re lost and being polite. You can’t see inside their head and the words barely help.

Three replies sit in front of you: hand them the formal definition, ask them to explain it back, or drop the theory and walk through one concrete example. Whatever you pick, you’re not choosing a sentence - you’re choosing which student is sitting across from you next week. The thing you actually care about, whether they’re learning or quietly checking out, never shows up in any single reply. It lives across the whole arc.

A tutor running as a recorder gives the reply that looks best right now, or the one that didn’t blow up last time someone said “I think I get it.” A tutor running as a mapper asks something different of each option. Give the definition - does curiosity stay reachable, or does the room narrow? Ask them to explain it back - can they recover gracefully when it turns out they can’t? Switch to an example - does the route to real understanding stay open? A great tutor doesn’t optimize the next sentence. They optimize the student’s future ability to keep learning.

That’s the move. The rest of this post is me trying to say what it takes to put it inside a model, and being honest about how many people have already tried.

Where the strongest fixes break.

Because people have tried. There’s a whole branch of the field whose entire stance is “track what’s reachable, chase what’s different, keep your options open.” If any of it already solved this, I’d have nothing to write. So let me take the strongest versions, give each its due, and then walk it to the one place it breaks. They break in the same place.

Start with novelty search and quality-diversity. This is the discovery branch of evolutionary computation, and it’s the closest in spirit to what I want. Lehman and Stanley noticed that objective functions can be deceptive - they actively misdirect search toward dead ends - so they threw the objective out and rewarded behavioral novelty alone, and on deceptive mazes that beat objective-based search. MAP-Elites generalizes it into a whole illuminated map of high-performing-yet-different solutions. This is exactly the “retain what’s reachable” stance, done well.

But novelty is measured along axes you choose. You pick the behavior characterization, the descriptor space the archive is binned over, and that choice is the choice of a frame. You only discover what’s reachable along the dimensions you decided to measure. Pugh, Soros and Stanley show the failure cleanly: when the behavior characterization is unaligned with quality, QD “do[es] not adequately mitigate deception, rendering QD algorithms unable to discover the best-performing solutions on difficult problems.” Pick the wrong axes for a deceptive maze and the agent confidently fills its archive with novelty that doesn’t matter, generating new trajectory after new trajectory while never finding the exit. The collapse didn’t vanish. It moved up, into the hand-chosen frame. This is the snow globe from my last post, relocated to the discovery side: shake it forever, get a new configuration every time, learn nothing. Their own fix is to drive search with several behavior characterizations at once, which is itself evidence that any single chosen frame is a liability.

Next, empowerment. This one is almost the platonic “keep your options open,” and it’s reward-free, which I love. The agent maximizes how many distinguishable futures its actions can reach. The trouble is in the word “maximizes.” Empowerment is defined as the channel capacity of your actuation channel - the most distinguishable futures you can drive, collapsed to a single number in bits. “Keep your options open” already got crushed into one scalar, the exact collapse I’m complaining about. The field already knows the naive version misfires. Variational Intrinsic Control shows that open-loop empowerment, where an agent commits to an action sequence and then “blindly follows this sequence regardless of what the environment does,” underestimates badly in a stochastic world: in their dangerous grid world an agent at the wide-open center has an exponentially growing chance of being reset, so the open center scores lower than a cramped corner, producing “agents that aim to reach low-empowerment states.” The place with the most real optionality scores worst. But that’s the open-loop assumption failing, and the paper’s own contribution is the fix - closed-loop control that conditions on what the environment actually does, which handles the stochasticity. So I won’t pin my complaint on “the scalar is wrong.” Even closed-loop empowerment keeps a count of bits: it compresses which futures into how many of them. That’s the collapse I can’t use. The number still can’t tell you which doors you kept and which you lost, only how many there were.

Sidenote: even where the metric is right, it’s barely computable. High-confidence distribution-free lower bounds on mutual information require an exponential number of samples, which is why empowerment is stuck in low-dimensional spaces. So in the open-ended language setting I actually care about, where there’s no clean metric at all, it’s worse off, not better.

Last, Go-Explore, which is the most operational answer to “keep a map of what’s reachable.” It was built to fix detachment - “forgetting how to reach previously visited states” - by keeping an explicit archive of promising states and guaranteeing it can return to any of them before exploring further. First return, then explore. It works, and it cracked Montezuma’s Revenge. But the map is a bolted-on table that lives outside the policy. The agent never internalizes it; it queries an external archive keyed by a hand-designed “cell,” each observation downscaled into a discrete bucket. When two genuinely distinct, separately reachable screens downscale to the same cell, Go-Explore keeps one and silently drops the other, and it has no way to notice it lost a place, because reachability lives in a table whose resolution was fixed by hand rather than in a representation that could tell the two states apart by their consequences. The paper reaches for a separate, finer-grained cell representation for Pitfall without domain knowledge to stop distinct states from merging. The later Nature version goes further and learns the cell representation from a network rather than fixing it by hand, which partly answers this. But even a learned cell representation is a separate archive the agent queries, whose resolution is chosen to satisfy reachability - not a policy-internal sense of consequence that tells two states apart by where they lead. The cure for forgetting reachable places still depends on an encoding that can quietly conflate them. People built the map outside the model. Nobody made the model carry it.

So that’s three of the strongest fixes, and notice they fail in one place each, and it’s the same failure every time, just relocated. The collapse doesn’t disappear when you chase diversity; it relocates - into the behavior characterization, into the channel-capacity scalar, into the cell function. And none of them does the two things I think actually matter: hold the reachable set as structure rather than a magnitude, and do it in a language setting where there’s no natural metric to make any of them computable in the first place.

Not just better RL.

Before going further, the obvious objection. Haven’t I just described search, or reinforcement learning, and don’t we already know how to do both?

Take search. Isn’t this planning over a tree, the way you play chess? You might think the difference is that chess hands you the tree - fixed rules, countable branches - while in life the landscape doesn’t exist until you build it. But that’s too easy, because model-based planners already build the landscape in estimation. AlphaZero is the clean case where rules are given, MuZero learns a model and searches a tree inside it, and Dreamer learns a model and plans in imagined latent rollouts with no tree at all. So the boundary isn’t given-versus-built, and it isn’t tree-versus-no-tree. It’s what the planner plans toward. All of them plan toward a return that’s already defined, so they inherit the recorder’s limitation one level up: brilliant at finding the best path through a landscape whose worth is fixed in advance.

That’s the real RL objection too, and it’s the strong one, because RL learns from experience. This is the era of experience, and the continual-learning labs are pointed at it for good reason. RL is at its best when the game has a name: write down the reward, build the environment, sample trajectories, push toward whatever scored. That works when the thing you want can be written as a return. But discovery usually happens before the reward is obvious. It’s the moment you notice the question is wrong, or the path you’re on has gone sterile while every local reward still looks fine. RL teaches a system to climb a landscape. Discovery is noticing the landscape you’re climbing is costing you the regions you actually care about.

Sidenote: I used to lean on the way RL scales as evidence here - pretraining follows a smooth power law, while at least one careful study of RL compute for LLMs fits closer to a sigmoid, flattening once the model has solved exactly what the reward made visible and no more. I still think that reading is suggestive. But a sigmoid has at least five plausible explanations and I picked mine, so I’ll treat it as motivation, not proof.

The wrong-typed question.

Step back, and the recorder, the planners, and every fix above are answering one question: how did this path do? Cross entropy asks it of a token, preference reward of a trajectory, a value head of a state, empowerment of a position, Go-Explore of a cell. The answers differ enormously in sophistication and not at all in type. Every one is a valuation - a number, or a tidy distribution of numbers, about the path that got realized. I’ve come to think that’s the actual bug, sitting a level below all the others: for discovery, valuation is the wrong type of thing to optimize.

Discovery isn’t about the path you took. It’s about what taking it did to the paths you didn’t. The generator’s “6” was, by every valuation you could write down, an excellent output - the cost was real and invisible at once, because it lived entirely in the unrealized, in the nine digits the move quietly closed. No score of the realized thing can see a price that exists only in what got foreclosed. “Every local check passed the whole way down” is that sentence in disguise.

So the change I’m pointing at isn’t a sharper reward or a better optimizer. It’s a change in the type of the thing being optimized: not a value over the trajectory but a signed difference over possibility-space - what this move did to the field of what’s still reachable. A derivative, not a snapshot. And that’s why the idea keeps getting mistaken for things it isn’t. A value head looks prospective, but it predicts the future of the policy you already have - where you’ll drift, not what you foreclosed. Empowerment is about reachable futures, but it counts how many you have and stays silent on the change a move made in which ones. The quantity resembles value and resembles empowerment and is neither, because the operation is different: a signed change in reachability attributable to an action. The recorder logs states and their values. I want to log the effect of an action on the space of actions, and as far as I can tell that’s the move nobody is making.

Frame economy, not frame escape.

That same error has a twin one level up, and it’s the one that sank an earlier draft of this argument. I used to say discovery is about escaping the frame, and the mapper is what survives once the frame is gone. That’s not defensible, and the walk above is why. Every method I admire needs a frame to even be defined: novelty search needs a behavior characterization, empowerment needs a horizon and a notion of distinguishable futures, Go-Explore needs a cell function, reachability needs a target set. A mapper that abandons frames has nothing left to measure. The frame doesn’t go away.

So the honest version is about economy, not escape. The recorder commits to a frame silently and irreversibly. It picks the axes, fixes the reward, downscales the state, and then can never see that it did - like the generator that committed to “6” with no record that it had closed the door on every other digit. The mapper’s job is to make the option-cost of each move legible: this move kept that region open, this one shut it, this one is cheap to undo and this one isn’t. Make the cost of a frame visible and switching frames gets cheap. That’s the whole thing. The goal was never a model that lives outside frames - it’s a model that can see what its current frame is costing it and step to another one on purpose.

This is exactly what the generator couldn’t do. Producing the winning “6” was a frame commitment, and it was free at the time - every local check passed. The price only existed in the space it closed, and that price was never on its books. A mapper puts it on the books.

What “reachable” has to be.

I’ve been using “reachable” loosely, so let me tighten it, because the term carries everything and there’s a trap right next to it. If reachability meant “given a goal, can I get there,” I’d have smuggled the goal - and the reward - back in, and discovery is exactly the case where you don’t have the goal yet. The version I care about isn’t goal-conditioned. It’s how many goals stay open - did this move keep a wide neighborhood of possible successes reachable, or collapse them to one. That quantity is never absolute, and once you fix a goal family, a distance, and a horizon, it’s defined without naming any single success - which is to say it’s defined relative to a frame, and that’s fine now, because the point isn’t to escape the frame, it’s to keep the frame’s costs visible.

Two ideas hide under the word. One is where here tends to lead, the future you’d drift into given how you currently act, which needs a policy. The other is what here keeps possible, the futures you could still get to if you had to, which needs only a sense of distance and horizon, not a goal. The mapper leans on the second.

But “how many” is still a magnitude, and I just spent a section beating up empowerment for collapsing optionality to a magnitude. So whatever the right-typed signal is, it has to be more than counting - and that’s where I stop being sure.

A first guess at the object.

The diagnosis is the part I’ll defend hard. This next part - what the new-typed signal actually is, as a thing a model stores - I’m far less sure of, and I want the seam between them to show. What follows is my current best guess, and I already know where it strains. Reward-independence I’ll even give back: it isn’t mine, since empowerment is already reward-free and got there first. What’s left is the structured object itself, and the one setting where I think it has to be built.

Picture a research agent at a decision point. The recorder, at best, stores one number per move: how much stays reachable, a magnitude. The mapper would store an object instead, and here’s how I’d start. Carve outcome-space into a handful of regions - call them “the cheap measurement that distinguishes the two hypotheses,” “the expensive direct experiment,” “the pivot to a different question,” “the dead end.” For each candidate move, hold a vector over those regions - which opened, which closed, which got cheaper to reach and which got more expensive. I’d store it as that partition, a reachability weight per region, attached to the move. I’ve hand-named the regions to make the object legible; in the real setting you wouldn’t hand-carve them, you’d learn them - cluster outcome-regions in a representation space instead of naming buckets by hand.

And yes, a learned partition risks being the QD behavior-characterization trap with extra steps, where the clustering you picked quietly decides what you’re allowed to discover. That’s the place my guess strains, and I won’t pretend it doesn’t. The most I can say is that frame economy buys you something here: the object records what each move does to its own regions, so when the carving starts hiding doors, that shows up as option-cost you can read instead of as silence. Whether that’s enough is exactly what would have to be built and tested. But the thing it’s trying to capture is clear enough - ask the question a scalar literally cannot answer: which door did this move close? A magnitude can tell you optionality dropped from seven to four. It cannot tell you that the three you lost were the only routes back to a different question, while the four you kept are minor variants of the path you’re already on. Same number, opposite situations - the dangerous-grid-world failure all over again, “noise reset me” indistinguishable from “I have no options.” Structure is how I’d write the difference down.

The second part is the setting, and it’s the part of this guess I’m most willing to bet on. Every method above was built where you’re handed a metric and a horizon - control problems, navigation, grid worlds, places with a natural notion of distance. I want this in open-ended language trajectories, where the reachable set is neither enumerable nor comes with a natural metric or horizon, and the only thing you can carry is a learned feel for it. That’s the part nobody has, and it’s the part empowerment’s exponential-sample wall says you can’t get by counting. You have to learn the structure, because you can’t compute the magnitude.

Sidenote: none of these objects are new and I won’t pretend otherwise. “What my actions keep reachable” is close to empowerment; “where here tends to lead” is close to the successor representation. Structure-over-scalar isn’t new either - distributional RL predicts a whole return distribution instead of a number, and successor features predict a vector instead of one. So the residue isn’t “structure” in the abstract. It’s the change in the reachable set, kept as a per-region option-cost object a model carries across experience, in language, where there’s nothing to enumerate and no metric to compute - which is exactly what distributional RL and successor features assume you already have.

Some map is possible.

I want one existence proof, and only the weak version of it, because the strong version would be overclaiming. Your brain navigates without seeing the future, so some predictive map is buildable - that much is settled. The hippocampus looks like it encodes something closer to “where does being here take me” than “where am I,” and it replays routes offline when you’re sitting still.

Sidenote: place cells, grid cells, and hippocampal replay are the usual evidence. The successor representation is the cleanest computational story for why a place gets defined partly by the places it leads to.

The part that matters for me is that the same machinery runs on spaces that aren’t physical at all. Put someone in a scanner navigating an abstract space of morphing bird shapes - more neck, less leg - and the entorhinal cortex lights up with the same hexagonal grid code it uses for rooms. It shows up over word meanings too: navigate a space of concepts and you get grid-like and distance codes laid over it, the same coordinate system stretched across semantics. That matters because the strongest objection to the whole back half of this post is that language might have no navigable geometry at all - that “reachable” is a spatial idea I’m forcing onto a space that doesn’t have one. The brain’s answer is that it already imposes a navigable geometry on meaning. That objection is off the table.

One result gets closer to my actual object than the generic map does. When people track the changing values of options in a sequence, forming a path through a two-dimensional value space, the entorhinal grid aligns to the axis that matters most for the choice, and a network including prefrontal cortex tracks the difference in prospective value between the options - not one option’s worth, the gap between them. That’s directional and option-relative. It’s the closest thing I’ve found in biology to “which doors, not how many.”

Now the honest part, because this evidence threatens one of my bets as hard as it supports the other - and the review pulling this navigation literature together flags the catch itself. Look at what the geometry actually is in every one of those studies: two dimensions, and in most of them the two dimensions were arranged by the experimenters before the subject walked in. Its own author says it plainly - much of the evidence “relies on experimental designs in which stimuli are arranged a priori along two dimensions,” so the low-dimensional structure may “reflect the imposed experimental design instead of an intrinsic property of neural coding.” The brain’s map, in these results, is a grid over axes someone else chose - the behavior-characterization trap from a few sections up, wearing a lab coat. It’s empowerment over a fixed frame, not the frame-free object I said I wanted. And the headline mechanism makes it worse before it makes it better: the same review casts abstraction as compression, a cognitive map being a simplified model that “preserve[s] relational structure while discarding irrelevant detail.” Throwing structure away to fit a compact code is the exact move I’ve spent the post arguing against.

So here’s what the biology actually buys me, stated carefully. It proves abstract and linguistic spaces can be navigated with spatial machinery, and that the machinery can be directional and option-relative instead of a flat scalar. It does not prove anyone has built the frame-free, delta-preserving version - the map that records which doors a move closed without first being handed the axes to measure on. The brain plainly doesn’t store my specific object, the partition over outcome-regions with option-costs attached, at least not in any form anyone has read out. What it clears is the bar I set at the start: a learned sense of when a path is opening and when it’s closing, on compressed representations and a pile of evolved heuristics - avoid the edge, keep an exit, no omniscience required. What it doesn’t clear is the bar I’m reaching for. Same move as empowerment and Go-Explore: give it its due, then walk it to the one place it doesn’t reach.

What training in paths looks like.

So what would it take to train this? Today we ask: did this trajectory get reward? The mapper asks: after this move, what kinds of futures got easier, harder, newly possible, or shut off?

One concrete way to get at the signal. From an intermediate state, sample a few candidate moves, and for each one roll a handful of short futures forward, then look at what those futures are made of. One reassurance first, because this sounds like a contradiction: the branching happens only in training. At inference there’s no tree and no search. You roll out to learn the map; you don’t roll out to use it. The model carries the feel, the way the hippocampus reads a place by where it leads without walking every route first. Yes, it uses rollouts - search was never the enemy. The claim is that the model should distill the reachability map so it doesn’t have to search when it acts.

The honest hard part is scoring: deciding whether a rolled-out future is productive or a dead end is the same wall learning progress ran into, because in the moment structure and noise look alike. So I’d start with the easiest thing to measure, recoverability, as a scaffold the real signal replaces - a floor to get traction on, not the target. And I’d keep it per region from the start. After a perturbation, for each outcome-region, what fraction of short rollouts keep it reachable? Which regions got cheaper to re-enter and which got dearer? Did uncertainty get more structured or just louder? You can measure all of that without anyone labeling a future “good.” Then the head you train predicts the partition object from earlier - the vector over outcome-regions that opened, closed, got cheaper or got dearer - not a single number. This is the part that has to survive: the moment the head collapses to “how much stays reachable,” it’s a value head predicting a scalar return, which is exactly the recorder I’m trying to leave. The whole point is the type - a structure about the space, not a number about the path; the partition is just my current way of writing that down.

But I have to flag the worry that keeps me honest about recoverability, because it cuts against me. The highest-discovery moves are often the irreversible ones - the commitment that closes the safe options precisely because it opens a strange new one. A pure recoverability-maximizer is structurally conservative; it would have talked you out of the move that mattered. So recoverability is the thing I’d measure first to get traction. It points the wrong way for discovery, and I don’t want anyone mistaking it for the answer. The signal that would actually fit isn’t the magnitude of what stays recoverable but the structure of the delta - moves that close cheap, redundant regions while opening distant ones, even irreversibly. That’s the per-region object from a few sections up doing real work: net which-doors, not how-many, with a sign. I don’t have it measured, and getting from a recoverability scaffold to that signed-structure signal is the central open problem here. Where it needs to get sharper, the geometry of surprise is the other half of this bet - how a disturbance settles already carries the difference between coherent novelty and noise. This part is the question, not the answer.

A way of thinking.

One disclaimer, because it’s where you’d object. This is a proposal for a way of thinking, not a model design. You can bolt it onto an autoregressive model, a latent world model, an SDPO loop, whatever you’re already running. The change is in the question you train the model to ask. Stop asking only what state the model is in; ask what paths that state makes available, and what each move costs in paths.

The prediction I’d stake it on.

Here’s the falsifiable part, and it’s the asset I’d lean on hardest. Every current trick for putting a branch into a model is external. At inference there’s activation steering, steering vectors, memory injection - a vector a person pushes into the residual stream to force the other branch. CoCoMix goes earlier and bakes it into pretraining, predicting concepts from a sparse autoencoder and mixing those concept vectors into the hidden state. That last one is actually closer to what I want, since it tries to make the branch native rather than nudging at inference. But it still injects concepts the model is taught to absorb, not a sense of what each move keeps reachable. The mapper frame makes a sharp prediction: a model trained to track reachability will steer itself off its default continuation without any injected vector, because the branch is native.

Make it concrete, and measure it from outside the model so the test can’t grade itself. Take a context where the default continuation commits to one line - the first clean answer, the obvious framing. Define “default” as the temperature-0 greedy decode, and define optionality externally: from a continuation, have an outside rollout count how many distinct valid task completions are still reachable, or have humans label the diversity of outcomes. Either way, the yardstick lives outside the model’s own object. The baseline only branches when you push an external nudge into it - a steering vector in the residual stream. With no vector, its greedy continuation just rides the default. The prediction is that the reachability-trained model’s greedy continuation, with no injected vector and no steering, already reaches higher external coverage than the baseline’s greedy continuation, and matches what the baseline gets only after a nudge. What falsifies it: if the trained model’s greedy continuation only beats its baseline coverage when you inject a vector, exactly like the baseline, then the branch was never native, the map was never carried, and the frame is wrong. I think that’s a clean enough bet to run.

Sidenote: a good draft is usually the one that kept the interesting continuations alive instead of committing early to the first clean line. The bad branch is the sentence that quietly closed the other sentences. I notice it most in my own writing.

What you’re buying, underneath all of it, is metacognition. The mapper’s real question is never “what’s my best next move” - it’s “what is staying on this path closing off, and can I still reach the doors I’d want open.” That question is the line between generating and discovering.

Sutton’s lecture names the bottleneck between the era of experience and what he calls the age of design - what I’d call the era of discovery - and I don’t think it names the way through. I think the way through is a model that thinks in paths, one that treats a move the way a lifeguard treats a current: as something that reshapes everything that can still happen. The generator at the top of this post never got that. It found the path that won and rode it until the whole valid space was gone, every local check passing the entire way down.

Surprise has a shape. So does the future a move creates. On both ends of the loop we keep insisting the signal be a number about the path - and that, the type error and not any single fix for it, is the part I’m sure of. What the right-typed signal actually looks like, written down so a model can carry it, I’m still working out.

This is the same bet as the geometry of surprise, from the other side of the loop, and I’m trying to build a model that thinks in paths. If you want to build it with me, or if you think I’m wrong, DM me.