Pruning the Planner: When LLMs Tame the Grounding Explosion

Planning looks innocent until the planner starts listing every possible thing that could happen.

Move this object here. Move that object there. Load this package into that vehicle. Fly this aircraft between those cities. Refuel it at this level. Then do the same for every other object, location, vehicle, person, and intermediate state the model permits. Very quickly, the planner is not solving the business problem. It is drowning in its own imagination.

That drowning has a technical name: grounding. In classical planning, a domain is often written in a lifted, first-order form using PDDL. Before many planners can search for a plan, they convert the lifted description into a propositional one by instantiating possible actions and facts over concrete objects. This makes downstream search easier to implement, but it also creates the familiar combinatorial tax: as objects and action parameters grow, the number of grounded operators can explode.

The paper “Semantic Partial Grounding via LLMs” by Giuseppe Canonaco, Alberto Pozanco, and Daniel Borrajo proposes a direct intervention at precisely this point.¹ The authors introduce SPG-LLM, a method that asks an LLM to examine the PDDL domain and problem files before grounding, then remove objects, predicates, and action schemas that appear irrelevant to the goal.

This is not another “LLM replaces the planner” story. Mercifully. The planner still plans. The LLM acts as a semantic pre-processor. Its job is to make the planning task smaller before the classical machinery starts multiplying possibilities.

That distinction matters. The useful comparison is not “LLM versus planner.” It is:

• full grounding, which keeps the whole task;
• learned object-importance pruning, which predicts useful objects;
• semantic LLM pruning, which edits the task before grounding.

The paper’s contribution sits in that comparison. SPG-LLM can cut grounding time and grounded operator counts sharply. But it also loses coverage and does not provide soundness or completeness guarantees. In business language: it can make planning cheaper, but only if you do not confuse a semantic shortcut with a proof.

The real bottleneck is not planning intelligence, but task size before search begins

A classical planning problem can be described compactly. A logistics domain, for example, may define generic actions such as loading, unloading, driving, flying, and refuelling. The problem file then supplies the actual packages, vehicles, airports, cities, and goals. This lifted representation is elegant because it avoids writing every possible action manually.

The problem arrives when the planner grounds the task. A generic action schema such as load(package, truck, location) becomes many concrete actions once the objects are substituted. If there are many packages, trucks, and locations, the count grows fast. Add more parameters and richer object hierarchies, and the number of candidate grounded actions becomes less like a list and more like a small weather system.

Partial grounding tries to avoid that. Instead of grounding everything, it grounds only the portions likely to matter for solving the task. Existing approaches often use learned models to predict which operators or objects are important. That is sensible, but it usually depends on training data, planner-specific machinery, or features that do not fully exploit the semantic information already present in PDDL names, object types, action names, and goals.

SPG-LLM asks a simple question: if the problem file already says what the goal is, and the domain file already contains human-readable structure, why not use an LLM to remove the obviously irrelevant parts before grounding?

The authors use the example of a cooking domain. If the goal is to cook Tagliatelle alla Bolognese, a broad recipe-planning domain may contain seafood, roasting, dairy, chopping, boiling, and other possible ingredients or actions. Common sense says seafood and roasting are probably not central. A planner without semantic pruning may still have to consider such possibilities because they are formally present. An LLM can inspect the text and suggest pruning.

The technical trick is not that the LLM is “smart” in the abstract. The trick is that the task representation leaks meaning. Object names, type hierarchies, action labels, and goal predicates are often not arbitrary symbols. They are semantic handles. SPG-LLM grabs those handles before the grounding explosion begins.

Three ways to shrink the problem, three different risks

The paper compares SPG-LLM against two baselines: full grounding and Planning with Learned Object Importance, or PLOI. The comparison is useful because the three methods make different assumptions about where the pruning decision should happen.

This table is the article’s main map. Full grounding is safe but potentially bloated. PLOI is learned but narrower in scope. SPG-LLM is semantically flexible but heuristic.

That last word does a lot of work. SPG-LLM does not prove that the removed objects or actions are irrelevant. It asks an LLM to propose a smaller domain and problem file, then checks the output. The checks are syntactic, computational, and semantic: the reformulated PDDL must parse, a plan must be obtainable within a time bound, and the reformulation must preserve relationships such as keeping pruned predicates, actions, and objects as subsets of the original and keeping the goal equivalent.

Useful, yes. Sufficient for guarantees, no. The authors explicitly state that this validation is only a soundness proxy. A plan that solves the reformulated task may still fail to be a valid plan for the original task. This is the part where the LLM has not been promoted to a theorem prover. It has merely been given a broom and told to sweep before the expensive machinery arrives.

SPG-LLM edits the task before the planner pays the grounding bill

The method itself is deliberately simple. SPG-LLM receives the domain file, the problem file, a prompt template, and a maximum number of attempts. The LLM produces a modified domain and problem. If validation passes, the reformulated task is returned. If validation fails, the system feeds the original task, the LLM output, and the error back into the prompt for another attempt. In the reported experiments, SPG-LLM is run with $K = 1$, so the LLM gets one shot.

That choice matters. The paper is not showing a heavily engineered multi-round repair loop. It is testing whether a single semantic pruning pass can materially reduce the grounding burden.

The prompt asks the model to act as a PDDL expert and simplify the planning task according to the goal. It specifically frames pruning around removing unnecessary objects from the problem file and actions or predicates from the domain file. It also warns that goal objects and predicates cannot be removed. This is not an open-ended conversation with the LLM; it is a constrained file-transformation task.

The output is then fed to classical tools. LAMA is used to solve the resulting tasks, and VAL is used to verify generated plans against the original task. This is the right architecture for practical use: let the LLM make a semantic guess, but let symbolic machinery check execution validity. The LLM is useful because it can read meaning; the planner is useful because it does not care about the LLM’s confidence posture.

The grounding results are the strongest part of the paper

The evaluation uses seven hard-to-ground planning domains: Agricola, Blocksworld, Depots, Hiking, Satellite, TPP, and Zenotravel. For each domain, the authors evaluate 25 randomly selected tasks from a benchmark previously used for partial grounding research. The metrics are grounding time, number of grounded actions, solving time, and best plan cost found by LAMA under the time and memory limits.

The first result is straightforward: SPG-LLM usually grounds fewer actions.

In Figure 1, SPG-LLM produces fewer grounded actions than full grounding in 121 tasks, while full grounding produces fewer in 54. Against PLOI, SPG-LLM produces fewer grounded actions in 72 tasks, while PLOI is lower in 28. These figure counts are more informative than a vague statement about “efficiency,” because they show that the effect is broad rather than confined to one friendly domain.

Table 1 gives the scale. On the commonly solved tasks:

The grounding claim is therefore well supported. SPG-LLM often cuts the number of grounded actions dramatically, sometimes by orders of magnitude. That is the cleanest result in the paper.

But even here, the comparison deserves precision. SPG-LLM is consistently faster than full grounding in the table. Against PLOI, the picture is more mixed in the domains where PLOI is available. For example, Satellite reports lower average grounding time for PLOI than SPG-LLM, even though SPG-LLM grounds fewer actions on average. This does not undermine SPG-LLM’s contribution, but it does prevent a lazy headline like “LLMs always win.” They do not. They win often enough to be interesting, and they lose often enough to remain research rather than religion.

Plan quality is where the polite story becomes complicated

Grounding fewer actions is not the same as producing better plans. The paper is refreshingly clear on this point.

Coverage is the first warning. Full grounding generates valid plans for 161 out of 175 tasks within the limits. SPG-LLM does so for 139 out of 175. PLOI is evaluated on 100 tasks because of its predicate-arity limitation and succeeds on 90 of them. The authors also report that SPG-LLM produces 36 tasks out of 175 that cannot be solved to yield valid plans for the original task.

That is not a footnote. That is the deployment boundary.

The second warning is plan cost. In Figure 1, SPG-LLM has lower plan cost than full grounding in 55 tasks, while full grounding is lower in 120. Against PLOI, the comparison is almost even: SPG-LLM is lower in 52 tasks, PLOI in 48.

The domain-level results show why. In Blocksworld and Depots, SPG-LLM produces both lower-cost plans and shorter solving times. In Agricola, Satellite, and Zenotravel, plan quality is broadly similar to full grounding, though not always better. In Hiking and TPP, full grounding yields lower-cost plans, even though SPG-LLM can make solving much faster.

TPP is the clean example of the trade-off. SPG-LLM reduces grounded actions from 385k ± 199k to 17k ± 9k and grounding time from 42.0s ± 21.6 to 1.9s ± 0.9. Solving time also drops sharply, from 695.7s ± 440.8 to 27.8s ± 40.1. But plan cost rises from 623.9 ± 124.3 to 850.0 ± 168.0. If the operational goal is “get a plan quickly,” that may be acceptable. If the goal is “get the cheapest plan,” it may not be.

This is exactly the sort of distinction enterprise AI discussions often flatten. Faster is not automatically better. Smaller is not automatically smarter. A pruned planning problem can be easier because it removed irrelevant clutter. It can also be easier because it removed useful alternatives and trapped the planner inside a narrower, more expensive corridor. Elegant, in the way a locked door is elegant.

The mechanism works best when semantics align with true irrelevance

The qualitative examples in the paper explain why SPG-LLM performs unevenly across domains.

In Blocksworld, SPG-LLM often leaves problem files unchanged but removes a superfluous action schema, move-b-to-b, in 10 out of 25 tasks. That action moves one clear block onto another. The authors note that the same effect can be achieved by first moving clear blocks to the table and then moving them from the table onto clear blocks. In other words, the LLM is not merely deleting objects; it is identifying a redundant action path.

In Satellite, SPG-LLM performs better than in Depots because there are more irrelevant objects to remove. This is the “semantic slack” principle. If a domain contains many objects that are genuinely unrelated to the goal, semantic pruning has room to help. If almost everything might matter, the LLM has less safe material to cut.

Zenotravel is the most business-readable example. SPG-LLM identifies the zoom action as irrelevant because it is a faster variant of fly that consumes more fuel. It also removes passengers not involved in the goal, cuts aircraft objects from 24 to 11, and reduces fuel levels from 7 to 2 in one analyzed instance. These changes shrink the problem, but they also constrain resources. As the paper notes, fewer fuel levels and aircraft can require more refuelling or longer plans. In Zenotravel, the average grounding and solving time fall by about one order of magnitude, while average plan cost rises from 457.0 to 493.2.

That is a good trade in some settings and a bad one in others. A warehouse scheduler under disruption may prefer a quick feasible plan. A fuel-cost optimizer may not. The technique is not universally “better”; it changes the feasible planning frontier.

The experiment table should be read as evidence taxonomy, not a scoreboard

A useful way to read the paper is to separate each experimental component by purpose.

This taxonomy matters because otherwise the paper can be misread in two opposite ways.

The enthusiastic misreading is: “LLMs can now prune planners, so symbolic planning is solved.” No. SPG-LLM is incomplete, heuristic, and sometimes invalid.

The dismissive misreading is: “It loses coverage, so it is unsafe.” Also too simple. Many operational systems already accept bounded heuristics if they are surrounded by validation, fallback, and monitoring. The business question is not whether SPG-LLM is perfect. It is whether the speed-quality trade-off is useful in a controlled planning pipeline.

For business use, SPG-LLM is semantic compression before execution

The most practical interpretation is not “LLMs become planners.” It is “LLMs can compress structured planning problems before deterministic systems execute them.”

That pattern is relevant beyond academic PDDL benchmarks. Enterprise planning tasks often contain large catalogs, resource pools, process templates, routing options, compliance steps, maintenance actions, and exception-handling branches. Not every element matters for every goal. A human operations manager naturally ignores irrelevant options. Classical systems often need formal pruning rules to do the same. SPG-LLM suggests that language models can provide a semantic pruning layer when the task representation is interpretable enough.

Here is the business translation:

For Cognaptus-style automation, the architecture implied by this paper is attractive: LLM as semantic filter, planner as executor, validator as referee. The LLM proposes what can be ignored. The symbolic system checks what can actually run. The business system decides whether speed, cost, or coverage matters most.

That last decision should not be delegated to the LLM. The LLM is not the adult in the room. It is the intern with surprisingly good domain intuition and a worrying habit of sounding certain.

Deployment boundaries: keep the LLM before the planner, not above it

The paper’s limitations are not cosmetic. They define how the method should be used.

First, SPG-LLM has no formal soundness or completeness guarantee. It may remove necessary objects, predicates, or actions. The paper’s validation checks reduce obvious failure modes, but the authors explicitly describe them as a proxy. A production system should therefore treat SPG-LLM as an acceleration path. If the pruned task fails validation, fails plan validation, or produces a plan that violates business constraints, the system should fall back to full grounding or a more conservative pruning method.

Second, coverage matters. SPG-LLM reaches 139 valid tasks out of 175, compared with 161 for full grounding. That is a meaningful gap. In low-stakes scheduling, the gap may be acceptable if fallback is cheap. In safety-critical robotics, regulated logistics, financial operations, or hospital workflow planning, it is not acceptable unless the surrounding validation is much stronger.

Third, the benchmark is hard-to-ground but still controlled. The authors chose tasks challenging enough to test partial grounding, yet small enough to allow grounding and solving within resource limits using standard planners. That is a reasonable experimental choice, but it means the paper does not yet answer how SPG-LLM behaves in messy enterprise planning systems with inconsistent naming, incomplete ontologies, vague goals, or legacy process definitions written by five departments that stopped speaking to each other in 2017.

Fourth, the method depends on semantic exposure. If object and action names are meaningful, the LLM can infer relevance. If the domain is written with opaque identifiers, compressed symbols, or misleading names, the semantic advantage weakens. The method is not reading reality. It is reading the representation.

Finally, the experiment uses a specific prompt setup and model configuration. The paper reports SPG-LLM with GPT-5-2025-08-07, medium verbosity, medium reasoning effort, and one attempt. That makes the result operationally simple, but it also leaves open questions about prompt sensitivity, model variation, multi-attempt repair, and whether smaller models can achieve a similar pruning-quality curve.

The useful product pattern is a guarded pruning stack

A business implementation inspired by SPG-LLM should not be a single call to an LLM followed by applause. It should look more like this:

1. Semantic task audit Parse the domain and problem representation. Identify objects, action schemas, predicates, goals, and hard constraints.

2. LLM pruning proposal Ask the model to produce a smaller candidate task and explain, in structured form, what was removed and why.

3. Static validation Check syntax, type consistency, subset relationships, and goal preservation.

4. Planner execution Run the classical planner on the pruned task.

5. Original-task validation Validate the produced plan against the original task, not merely the pruned one.

6. Fallback policy If validation fails or plan quality is poor, rerun with conservative pruning, learned pruning, or full grounding.

7. Post-run learning Log removed elements, validation failures, plan costs, and fallback frequency. Over time, build domain-specific pruning rules or model prompts.

This stack keeps the LLM in the part of the system where it is strongest: semantic judgment under incomplete formalization. It keeps formal tools where they are strongest: checking, execution, and constraint satisfaction. The architecture is less glamorous than “agentic planning,” but it has the virtue of not depending on vibes as a control system.

What this paper changes

The paper’s core lesson is not that LLMs can solve planning. It is that they may help planning systems avoid solving the wrong oversized problem.

That is a narrower claim, and therefore a more useful one.

Full grounding pays the full combinatorial bill. PLOI learns which objects matter but has its own training and structural constraints. SPG-LLM uses the semantic information already embedded in PDDL to cut objects, predicates, and action schemas before grounding. The experiments show large reductions in grounded operators and grounding time across hard-to-ground domains, sometimes with better plan cost and solving time.

They also show the price: lower coverage, invalid reformulations, and domain-dependent plan quality. The result is not a free lunch. It is a discount coupon with terms and conditions, which is still better than most AI promises.

For enterprises building AI-assisted planning systems, the paper points toward a practical design principle: use LLMs to simplify the task, not to own the decision. Let them prune. Let planners plan. Let validators validate. Then decide, explicitly, whether the time saved is worth the alternatives removed.

That is where the business value sits: not in replacing symbolic planning, but in making symbolic planning less wasteful.

Cognaptus: Automate the Present, Incubate the Future.