Toward Uncertainty

What GABAR doesn't do, why that matters, and where the natural next chapter takes the same warehouse.

If you read Posts 1-4 in order, you watched a tractable warehouse-delivery instance (4 zones, 1 package, solved in milliseconds by a classical planner) grow into ones that overwhelm classical search — and, in the paper's experiments, instances 8× larger than anything in training, with 100+ objects, solved in seconds by GABAR while the baselines collapse. The transition was smooth because we assumed one thing: the robot can see everything.

That's an unusual assumption. Most domains people actually want robots to operate in — warehouses included — don't grant that view. This epilogue is about what changes when you remove it, and what doesn't.

What GABAR does well, and where it stops

The pitch of Posts 1-4 was specific. With three architectural choices — action-centric graph, action ranking instead of value learning, conditional decoding of grounded actions — a GNN trained on small classical planning instances generalizes to instances 8× larger. That's a real result, and it's why GABAR is the series' anchor.

But the result lives entirely in the fully observable setting. The graph representation in Post 3 encodes known object positions and known predicate truth values. Action ranking in Post 2 assumes you can enumerate exactly which actions are available right now — which requires knowing the state. The whole stack collapses gracefully when state is uncertain… into something that needs a different framework.

Three things break:

Where does this go?

Two directions, both being actively pursued.

Direction 1: abstract the problem until a principled solver can handle it.

Pick a hierarchical decomposition. Object-oriented beliefs. Reason at the level of "where does each object roughly belong" rather than "what is the joint distribution over all positions." A POMDP solver like POMCP can then handle the smaller abstract problem, with grounded execution at the leaves. This is the strategy of HOO-POMDP, an earlier paper from our group.

Direction 2: keep the problem big and learn to navigate the belief space.

Apply the GABAR recipe to belief states. Same idea: state as a graph, action ranking as the target, GNN as the engine. But now the graph encodes a belief over states — with node features capturing uncertainty, and edge weights capturing probabilistic relations. Train on small POMDP instances; deploy on large ones. This is GammaZero, the partially-observable cousin of GABAR. It is, in some sense, what this series was building toward all along.

Three further questions you might be asking

Does this generalize beyond classical planning?

The recipe — "represent the state relationally, learn to rank what to do over the relational structure" — is more general than the planning setting. It shows up in chemistry, theorem proving, and combinatorial optimization. What's specific to classical planning is the PDDL framing of action schemas, which gives the GNN a particularly clean set of nodes to attend to. In domains without explicit action schemas, you have to choose what plays the role of the action-schema nodes. That choice is consequential.

What about value functions, really?

Post 2 made the case against value functions for generalization. That argument applies most forcefully when problem sizes differ between train and test. When sizes are fixed (chess, Atari, MuJoCo), value functions remain the right target. AlphaZero is right; GABAR doesn't argue with it. The argument is specifically about the planning generalization problem, where the input size varies.

Is "small → large transfer" really the right framing?

Possibly not, in the long run. The framing assumes the small problems contain enough signal to learn from. For domains where small instances are structurally different from large ones (some game playing, some real robotics), this is too optimistic. The future probably involves a mix of small-to-large transfer (where it works), curriculum learning (where small is a stepping stone but not the only signal), and offline RL (where there is no small-to-large at all). GABAR is the right baseline for the small-to-large story; it is not the right baseline for the others.

The take-away in one paragraph

You can train a graph neural network on solved instances of a classical planning problem, rank the actions available in each state, and deploy the network on instances orders of magnitude larger than what you trained on. The price of admission is a specific recipe: action ranking, action-centric graph, conditional decoding. None of these is novel in isolation. The combination, anchored on classical-planning structure, is what makes it work. The next chapter is the same recipe in a world where the robot can't see everything.