Post 7 ended on a deliberately tight note: HALO works, beats its teacher across 12 PDDL domains at ~2 orders of magnitude lower cost, the series argument round-trips back to Post 1, thanks for reading. This epilogue picks up where that ended. It's the place to put everything the paper points at without resolving — limitations of the supervised approach, the meta-learning lens the work invites, and the open frontier questions that the broader agentic-planning community is now circling.
The structure here is loose by design. Post 7 had to be tight because it was making a paper argument. This piece is a survey of open directions, organised into four passes: what the current paper can't do; the meta-learning frame that re-reads the result; the open challenges the community names as the frontier; and the specific research threads — RLVR, online learning, tree search, RLHF parallels, hybrid Paradigm 1+2 — that the next few years are likely to chase.
Three Ceilings HALO Doesn't Break
HALO beats frontier prompted orchestrators on success rate at ~45× lower cost than GPT-5-mini and 15–20× lower cost than the already-cheap Gemini-3-Flash — but the win is bounded in three concrete ways. Each ceiling is a candidate for the next paper.
Where HALO Stops Improving
Three ceilings. The per-decision teacher ceiling motivates RLVR (next section). The verifier ceiling motivates smarter timeout handling and inference-time search. The action-space ceiling motivates expanding the agent pool — adding agents for numeric repair, durative re-encoding, axiom handling — which is mechanically straightforward but unsexy.
Two of these are research problems; one is engineering. The per-decision teacher ceiling and the verifier ceiling need new methods. The action-space ceiling needs an engineering investment to write the missing repair agents — and the supervised pipeline drops in unchanged once those agents exist.
The Meta-Learning Frame
Step back from the specific paper. What was actually accomplished?
The orchestrator wasn't taught a plan. It wasn't taught a heuristic. It wasn't taught a policy over PDDL actions. It was taught how to plan the planning process — when to call the syntax fixer, when to call the predicate generaliser, when to fall through to the deterministic plan-repair operators. That's meta-planning, and the trained model is meta-learning it from verifier-accepted trajectories.
The vocabulary matters because it reframes the contribution. "We trained a small classifier on 12k examples" is a true description but undersells the story. "We learned an orchestration policy for a PDDL planning pipeline from outcome-filtered demonstrations" is the same fact restated as meta-learning for planning — and that framing opens up the comparison surface to a much wider literature.
From "What to Plan" to "How to Plan"
Learn what to plan
- GABAR: which PDDL action next, given state
- LMPLAN: which Python policy given a problem
- Corrêa: which heuristic for this domain
- Classical planners: which node to expand next
Learn how to plan
- This paper: which repair agent next, given pipeline state
- Future: which heuristic to generate, given domain
- Future: which decomposition strategy, given a spec
- Future: when to ask the user vs guess
Object-level planning chooses actions inside a fixed framework. Meta-level planning chooses the framework's own moves. The same supervised-from-verifier-acceptance recipe applies at both levels — and once it works at one level, it usually works at the level above.
Three things start to look obvious from this angle.
The recipe is layer-agnostic. The same "LLM proposes, verifier filters, student imitates" pattern that Post 7 used at the orchestrator layer also drives Corrêa's heuristic-generation pipeline (LLM writes Python, planner success rates filter), Silver's policy-distillation (LLM writes domain-independent policies, examples filter), and GABAR's action ranking (planner provides labels). All four are instances of the same meta-learning template applied at different layers of the planning stack.
The next layers up are inviting. One layer above the orchestrator is the method selector — given a new problem, should the system reach for LLM-Modulo, generate a heuristic, train a policy, or just call the orchestrator? The same supervised-from-acceptance pipeline works there too, provided you log enough method-selection trajectories with the right outcome signal. The hardware exists. The training data does not, yet.
Compositional structure shows up at the meta level. An orchestrator that's seen "syntax error → AgentSyntaxPDDL" and "hallucinated predicate → AgentHallucinations" should generalise to "syntax error plus hallucinated predicate → AgentSyntaxPDDL then AgentHallucinations." The current model does this implicitly because Layer 2 sees the full state. A more explicit compositional structure (hierarchical policy, options, skill libraries) is one of the natural follow-ups.
The meta-learning frame isn't decoration. It tells you which adjacent papers in the broader ML literature actually apply to the problem (DAgger, behaviour cloning, offline RL, learning-to-search) and which don't (most "agent tuning" papers, which operate in open action spaces without verifiers). It also tells you which adjacent problems are next — method selection, decomposition strategy, when-to-ask-the-user — that the same recipe should attack.
Open Challenges the Community is Circling
Beyond the three ceilings, four challenges show up repeatedly across recent papers — Gestrin's NL2Plan failure analysis, La Malfa's per-domain breakdowns, the cross-domain generalisation results in Post 7. None has a settled answer.
Four Open Challenges
Compositional generalisation
A system that's seen Blocksworld and Logistics independently should solve a problem that combines block-stacking and logistics. Current systems struggle because PDDL generation and orchestration are still pattern-matching over training distributions, not compositional reasoning over primitives.
Implicit constraint extraction
"The robot can't carry two items" implies a gripper-empty predicate and a precondition on pick. "Aisle 3 is one-way" implies asymmetric connectivity. Extracting these from natural language requires world knowledge, not just text parsing. NL2Plan misses them silently; agentic PDDL asks the user.
Multi-domain transfer
Hold-out experiments in Post 7 show ~8 pp drops on unseen domains. The framework is robust to NL paraphrase and object renaming, but a genuinely new domain — new types, new predicate signatures — pushes the orchestrator off-distribution. Closing this gap is what makes the system actually domain-general rather than benchmark-general.
Scaling to real-world complexity
Benchmarks top out at ~100 objects, ~20-action plans. Real-world planning — manufacturing schedules, multi-robot coordination, complex logistics — runs orders of magnitude larger. The orchestrator is the cheap part of scaling; the planner and validator are the bottleneck. Hierarchical decomposition is the obvious next step.
Four named challenges that HALO alone doesn't solve. Each is its own thread in the broader research programme.
None of these is unique to PDDL. Compositional generalisation is the ML community's deepest open problem; implicit-constraint extraction is the same gap that haunts requirements engineering; multi-domain transfer is meta-learning's central question; scaling to real-world complexity is what the planning community itself has been chipping away at for fifty years. HALO inherits all four challenges — it doesn't create them and it doesn't solve them.
Five Research Threads the Next Few Years Will Chase
The threads below are not predictions, they're the directions the supervised orchestrator paper visibly opens. Each one is what comes next if the recipe holds up.
Where the Research Goes from Here
RLVR
Reinforcement learning with the verifier as a verifiable reward
HALO is the natural initialiser. PPO against per-step verifier signals (LEA / StV / AQM moving down) breaks the per-decision teacher ceiling — the model can now exceed GPT-5-mini's strategic patterns on individual decisions, not just on terminal success. The verifier signal is denser than binary trajectory accept, so credit assignment is easier than vanilla sparse-reward RL. The dense-reward credit assignment story from Post 7's diagram applies, made cheap by the supervised initialiser.
RLHF parallel
What the planning community has that the chat community wishes it had
RLHF trains on noisy preferences from human annotators; the reward model has to be learned. Here the reward is the validator: deterministic, sound, and free. The community has been arguing about whether verifiable rewards are the right successor to RLHF; agentic planning is the cleanest setting where they unambiguously are. Whatever methodology emerges for verifiable-reward RL — process reward models, dense step-level signals, hybrid offline-online schemes — will show up here first.
Online loop
Self-improving orchestrators via deployment telemetry
Every deployed pipeline produces a stream of new verifier-accepted trajectories. Periodically retraining on the freshest accepted set lets the orchestrator adapt to domain drift cheaply — a luxury a prompted frontier-LLM orchestrator does not have. Infrastructure is straightforward: log every decision, mark the verifier-accepted ones, retrain weekly. The interesting question is regret and stability: how to retrain without forgetting prior domains.
Tree search
Search at orchestration time, not just at plan time
The trained policy plus the verifier admits MCTS, beam, or best-first over agent sequences. Each expansion is a cheap forward pass on the orchestrator; the verifier provides a hard pruning signal. This trades extra orchestration calls for accuracy on long-horizon problems where a single greedy trajectory falls short — and rejoins the planning community's tree-search heritage to the LLM agent literature on its own terms.
Method selector
Meta-orchestration: choose the method, not just the agent
One level above the orchestrator is the method selector. Given a new problem, should the system reach for LLM-Modulo, generate a heuristic with Corrêa's pipeline, train a policy with LMPLAN, write Python with Thought of Search, or just call this paper's orchestrator? Each method is itself a verifiable pipeline. The same supervised-from-acceptance recipe trains the chooser — if you log enough method-selection trajectories with the right outcome signal.
Five research threads, all flowing out of the same paper. Threads 1 and 2 are about pushing past the teacher. Thread 3 is about distribution shift. Thread 4 is about long-horizon problems. Thread 5 is meta-meta-planning — the natural next layer up.
The Hybrid Future: Paradigm 1 and Paradigm 2 Converge
Post 1 set up two paradigms. Posts 4–5 made Paradigm 1 (PDDL given) work. Posts 6–7 made Paradigm 2 (only natural language) work on familiar domains. The natural endpoint is hybrid — and it's already visible.
Where the Two Paradigms Meet
NL → PDDL
NL2Plan / Agentic PDDL formalise the user's task into a draft PDDL pair.Refine to validity
Hybrid policy iterates 21 repair agents until the validator accepts the PDDL and a plan.Solve and verify
LLM-Modulo / LLM heuristics / LMPLAN policies — pick the right Paradigm 1 method per domain.The hybrid pipeline: Paradigm 2 generates the formal model from English, HALO validates and refines it, Paradigm 1 methods solve it. Each box is its own active research area; HALO is the glue that makes them composable.
The interesting consequence is that the seven posts of this series stop reading as a chronological progression and start reading as a stack. Posts 2–3 are the foundation layer (PDDL, classical planners). Posts 4–5 are the integration layer (LLMs + planners under Paradigm 1). Post 6 is the front-end layer (NL → PDDL). Post 7 is the coordination layer (HALO). The future hybrid system uses all four layers simultaneously, with HALO deciding which Paradigm-1 method to dispatch based on the domain it just helped Paradigm-2 formalise.
None of this is hypothetical. NL2Plan + Fast Downward already runs as a pipeline; LLM-Modulo wraps Fast Downward in a verifier-checked loop; HALO was designed specifically to sit between an NL2Plan-style front-end and a Paradigm-1 back-end. The components exist. What's missing is the meta-orchestrator that decides, given the domain, which combination to use — and that's Thread 5 from the previous section.
Broader Implications Beyond Planning
The deepest pattern in this series is layer-agnostic: LLM proposes, formal tool verifies, disagreement becomes supervision. PDDL planning is the cleanest instance because the verifier is the most rigorous, but the recipe applies wherever a multi-agent system has a downstream check it already trusts.
- Software engineering agents. Code review pipelines have test suites, linters, type checkers, and security scanners as verifiers. Merge-accepted PR trajectories are the training data; the orchestrator chooses which agent (writer / reviewer / tester / refactorer) to call next.
- CI/CD coordination. The build is the verifier. Pipeline-accepted runs are training data; the orchestrator chooses which step (compile / test / deploy / rollback) given the current pipeline state.
- Compliance and policy agents. Policy engines and rule systems are the verifier. Compliance-accepted trajectories are training data; the orchestrator chooses which sub-policy applies (verify identity / check eligibility / calculate refund / escalate).
- Scientific workflow orchestration. Experiment validators (statistical tests, replication checks, peer review) are the verifier. Replicated-result trajectories are training data; the orchestrator chooses which analysis step (preprocess / fit / test / report) given partial results.
In each case the structural prerequisites are the same as Post 7: a discrete agent pool, a verifiable terminal check, trajectory logs, and a state representation that fits in a small model's context. Wherever those four conditions hold, the supervised orchestrator template applies — and the cost reduction transfers along with the recipe.
Agentic frameworks built around formal verifiers admit a structural simplification: the orchestrator can be small, local, and learned. PDDL is just the most rigorous setting where this is provable today. As verifiable rewards become the central organising principle of post-RLHF LLM training, this template will show up in many more domains. The compiler is just the most natural verifier — it isn't the only one.
Closing
Post 7 closed the canonical seven-post series with HALO. This epilogue is what didn't fit in. The three ceilings name where HALO stops improving; the meta-learning frame names what was actually accomplished; the four open challenges name where the broader community is stuck; the five research threads name what comes next; the hybrid future names where Paradigm 1 and Paradigm 2 converge; the broader implications name what this template means outside planning.
Each of these is a candidate for its own paper, its own blog post, its own thesis chapter. The series ended at Post 7 because the canonical seven-post argument was complete. The research, obviously, hasn't.
Thanks again for reading.
References
- Mangannavar, R., Coalson, Z., Dugar, P., & Tadepalli, P. (2026). Training the Orchestrator: A Supervised Approach to End-to-End PDDL Planning with LLM Agents. Oregon State University. Under review (introduces HALO).
- La Malfa, E. et al. (2025). End-to-end LLM-driven PDDL planning with a multi-agent refinement framework. arXiv:2512.09629.
- Gestrin, M., Zuo, N., Stein, M., & Kambhampati, S. (2024). NL2Plan: Robust LLM-Driven Planning from Minimal Text. arXiv:2405.04215.
- Mangannavar, V. et al. (2025). GABAR: GNN-based Action Ranking for Planning. NeurIPS 2025.
- Corrêa, A. et al. (2025). LLM-Generated Heuristics. NeurIPS 2025. arXiv:2503.18809.
- Chen, R. et al. (2025). LMPLAN: Language Models as Planning Policies. RLC 2025. arXiv:2508.18507.
- Kambhampati, S., Valmeekam, V., & Stechly, K. (2024). LLM-Modulo. ICML 2024. arXiv:2402.01817.
- Schulman, J. et al. (2017). Proximal Policy Optimization Algorithms. arXiv:1707.06347.
- Christiano, P. et al. (2017). Deep RL from Human Preferences. NeurIPS 2017. (RLHF.)
- Ouyang, L. et al. (2022). Training language models to follow instructions with human feedback. NeurIPS 2022. (InstructGPT.)
- Lightman, H. et al. (2023). Let's Verify Step by Step. arXiv:2305.20050. (Process reward models.)
- Ross, S., Gordon, G., & Bagnell, D. (2011). A Reduction of Imitation Learning to Online Learning. AISTATS 2011. (DAgger.)
- Silver, T. et al. (2024). Generalized Planning via LLM-Generated Policies. AAAI 2024.
- Katz, M., Kokel, H., & Muise, C. (2025). Planning in the Era of Language Models. NeurIPS 2025 Tutorial.