Learning for Planning

A four-part series (plus epilogue) on how graph neural networks let learned policies generalize from small, solvable training instances to problems 8× larger — without ever retraining.

Why this series exists

Classical planning — the framework underneath everything from Fast-Downward to LAMA — is sound, complete, and optimal. It is also exponentially hard. Every domain-independent planner hits a wall as problem size grows. The wall is not a bug; it is a theorem.

For two decades, the natural fix has been to train a value function on solved instances and use it to guide search on harder ones. The fix mostly hasn't worked. Values learned for small problems don't transfer to large ones, because the input representation itself depends on the problem size.

This series walks through why that's the wrong recipe and what to do instead: frame the planning state as a graph, rank actions instead of states, and let a graph neural network ingest variable-size problems with the same weights. The series anchors on GABAR, our NeurIPS 2025 paper, which puts the recipe together and shows generalization to instances 8× the size of anything seen during training.

One unifying example. All four posts use the same toy domain — a robot delivering packages between zones in a warehouse. Each post returns to it, scaled differently. Post 1 animates the jump from 4 zones and 1 package (solvable in milliseconds by a classical planner) to 16 zones and 3 packages (the start of the exponential wall). By Post 4 the same recipe is solving instances 8× larger than anything it trained on — 100+ objects — while the learned baselines and LLMs collapse.

The roadmap

Four parts + an epilogue, one paper, one running example

The Scaling Problem the problem + framing

Why classical planners hit an exponential wall, with an animated 4-zone vs 16-zone warehouse. Then introduces the two design axes — what to learn (heuristics, value functions, ranking) and how to represent state (graph encoding choices) — that organize every paper in the rest of the series.

What to Learn — A Survey of Learning Objectives survey: axis 1

Full survey of Axis 1. Three families: heuristic learning (ASNets, STRIPS-HGN, GOOSE), value-function learning (GPL, expressive variants), and ranking (RankSVM, Chrestien et al., GBFS-rank, GRAPL). Each paper gets concrete coverage: what they did, what they showed, what they couldn't do.

Your Planning State Is a Graph survey: axis 2

Full survey of Axis 2, opening with an interactive 5-stage graph-construction walkthrough. Three sub-decisions: lifted vs grounded encoding (the GOOSE debate), action representation (implicit vs alternating layers vs explicit nodes vs hypergraph), and parameter construction (independent vs sequential decoding). Comparison table across the literature.

GABAR — You Don't Need to Rank All States. Just Rank the Actions in Front of You. paper deep-dive

The full GABAR architecture. Action-centric graph + GNN encoder + GRU decoder for conditional decoding of grounded actions. Interactive demo of the greedy execution loop on the running warehouse. Ablations, results across 8 IPC domains, and what the experiments actually tell us about which design choices matter.

Epilogue — Toward Uncertainty looking forward

What GABAR can't do, what's coming, and the natural next chapter: partial observability. The sibling series picks up the same warehouse but with the robot's view fogged out. A short bridge to Planning Under Uncertainty.

Who this is for

The classical planning reader

You know PDDL, A*, and heuristic search. You've watched the field flirt with learning for decades. This series tells you why it finally clicks — and where you should still be skeptical.

The ML reader

You know GNNs, transformers, attention. You don't know why action ranking and graph representations matter specifically for planning. Post 2 and Post 3 are for you. Post 4 is the experiment.

The robotics reader

You want long-horizon plans that scale to real-world manipulation problems. Read all four. The epilogue is the bridge to partial observability, which is where most of your real problems actually live.

Reading paths

Linear (recommended for first read): 01 → 02 → 03 → 04 → Epilogue. About 90 minutes total, including time spent on the interactive visualizations.
Paper-first: Skip straight to 04 (GABAR) for the paper deep-dive. The "Where GABAR sits in the literature" note near the top of that post points back to Posts 1-3 if you need the setup.
Concept tour: Just Posts 1 and 4. The scaling problem (Post 1) and the paper that solves it (Post 4). Posts 2 and 3 are supporting material.

What you won't find here

No PDDL tutorial. If you need one, posts 2-3 of Planning in the Era of LLMs cover that.
No deep-RL primer. The series treats Q-learning, policy gradients, and AlphaZero as known reference points but doesn't re-teach them.
No reinforcement-learning angle. GABAR learns from a planner's demonstrations, not from environment rewards. The interplay between RL and classical planning is left for another day.