A real mind doesn’t choose one act — it chooses a path through a branching, uncertain future. That raises a new problem, and its solution is the most elegant thing in Part II: the explore/exploit balance falls out of the engine you already built, for free.
Five doors; the plain line runs straight through — take whichever fit: ▶ Picture it, ✎ Try it (commit before the reveal), ✓ Check it yourself, ▸ Go deeper, ⬡ See it in UNI. Runs locally — no account, no network — adapts to light and dark; honours reduced motion.
The one fence that never moves — and in Part II it is stricter. “Policy,” “explore,” “exploit,” “expected free energy” are functional quantities: a model scoring sequences of its own actions. For you we use felt words — a gardener weighing a week, a hiker in fog. For UNI we use functional ones. Neither is curiosity, caution, or choice-as-experienced. Part I’s perception half rests on the sealed Gate F0 arithmetic, but Part II’s policy machinery — expected free energy over paths — is not yet built or sealed in the organism; it needs its own lab-team verdict. So the math here is standard active inference, but every claim about the organism is “built to,” never “does” — held open until the build proves it.
No peeking. A gardener decides what to do with a struggling plant over the coming week — water more, move it to light, check for a pest, wait and watch.
Reconstruct the keystone and the two-part score from Modules 11–12 before you check. Commit in your own words first.
If both came back — one engine, two directions; risk and ambiguity — here’s what changes when the future stops being one step.
One action was easy to score: imagine its ending, measure the gap to what you want. But a path is a chain — water it, then move it to the window, then decide about the pest — and at every link the world can answer more than one way, each answer opening a different set of next steps. The futures fan out into a tree that widens at every level.
With a single choice, you pick the best action and you’re done. But down a path, your first move isn’t just for its own payoff — it changes what you’ll know for the second move, which changes the third. So you can’t score an early action in isolation: its value includes what it reveals for everything after it. You have to plan while expecting to learn — knowing the future-you will know things present-you doesn’t.
And the tree is merciless. Even a handful of options over a handful of steps branches into more complete paths than you could ever check one by one. That’s the wall again, back in a new costume: you cannot evaluate every future, any more than you could finish the evidence sum back in Module 2.
Scoring a path reopens the oldest dilemma in all of decision-making: do I take the sure thing I already know (exploit), or the uncertain thing that might be better and will teach me either way (explore)? Every field bolts on a separate rule to trade these off. You don’t need one — you already built the balance in Module 11, because expected free energy already has both halves.
One agent, choosing between the familiar rewarding option and the unfamiliar informative one. There is NO explore/exploit dial — the only control is the agent's UNCERTAINTY about which is best. Move it and watch the min-G agent switch by itself, as the two halves of G (risk, ambiguity) trade dominance. A reveal of the auto-balance, not an animated curve.
So how does a mind act when it can’t evaluate the whole tree and the future keeps teaching it? It does the only thing that works: it looks a little way ahead, acts, and then re-plans — rebuilding the plan each cycle from whatever the last action just revealed. The plan is never a finished script run blind; it is remade every moment on fresher information.
The engine of behaviour is now whole: a mind scores paths through a branching future by expected free energy (risk + ambiguity), which auto-balances explore and exploit, and it acts by a living loop — plan, act, learn, re-plan — because it can never see the whole tree.
Twice now you’ve used the shape of G = risk + ambiguity without ever writing it down and computing it. That’s the last thing to make solid: Module 14 puts the actual expression on the page and lets you compute both terms by hand, on the same two-cause world you’ve carried since Part I — so the engine stops being a story and becomes a number you can check.