A Richer Map Can Make the Planner Slower

TL;DR for operators

A robot can perceive more of its environment than its planner should necessarily receive. In the experiments summarized here, adding task-irrelevant objects to structured scene representations increases the burden on classical planners and can leave harder problems unsolved. The proposed response is not a new end-to-end planner. It is a learned relevance layer that decides which objects and relations should survive into the planning problem.

For an embodied product already using symbolic planning, this suggests a modular optimization target: reduce the state presented to the planner rather than immediately replacing the planner itself. The reported gains, however, come from simulated household and structured planning domains, with relevance labels partly derived from successful planner traces. Deployment in changing physical environments remains untested.

More perception can create more planning work

Suppose a household robot maintains a detailed representation of a room: furniture, containers, tools, appliances, movable objects, and the relations among them. That completeness is valuable for perception. It does not follow that every represented entity is valuable for every plan.

The paper reports that task-irrelevant objects in dense structured scene representations substantially increase classical planning cost, with difficult instances sometimes remaining unsolved.¹ Some planning runs reach the order of hundreds of seconds. The operational friction is straightforward: a richer world model can enlarge the symbolic state space even when most of its additional content contributes nothing to the current goal.

That separates two engineering objectives that are easy to conflate. Perception benefits from representing the environment accurately and broadly. Planning benefits from receiving enough state to solve the current task without carrying unnecessary combinatorial burden.

The relevant representation is a 3D scene graph: a structured world model in which objects are nodes and relationships among them are represented explicitly. The paper asks how much of such a graph should be passed downstream when the robot has one particular task to execute.

SGPlan makes representation size a planning problem

The first contribution is SGPlan, a benchmark constructed from an extended ALFRED-based household simulator. It converts structured household rearrangement problems into PDDL, allowing classical planning systems to be compared over seven compositional task categories.

That benchmark serves a specific purpose. It creates a controlled interface between an embodied environment and symbolic planning, so the cost of large scene-derived problem instances can be observed rather than discussed abstractly.

The thesis compares planners including Fast Forward, Fast Downward, and DiNo using task completion, planning time, and plan length. Fast Downward records the strongest completion performance on most reported task types, while Fast Forward remains competitive. More consequential for the paper’s later argument is the sensitivity analysis: as extraneous object content increases, planning becomes harder and slower.

This is main mechanism evidence, not merely an implementation benchmark. By varying how much irrelevant graph content reaches the planner, the experiments test whether representation size itself contributes to downstream search difficulty.

The result shifts the engineering question from “Which planner is fastest?” toward “What problem representation should any planner be asked to search?”

The learned model decides what reaches the planner

The second contribution inserts a task-conditioned graph model before symbolic planning.

The model is trained to estimate object importance using the current task together with relations in the scene graph. Supervision comes from successful classical-planner solution traces: objects appearing in those solutions are used to help identify what matters for comparable tasks.

The target is a sufficient object set—a compact subset that retains what the planner needs while excluding objects unlikely to contribute to a solution.

A graph attention network supports this selection by learning how much neighboring objects and their relations should influence each object’s representation. The important architectural point is where this learning occurs. The GNN does not generate the final action plan. It filters the representation first; a classical planner still performs the symbolic search afterward.

That modularity gives the approach a different operational profile from replacing a planning stack with an end-to-end learned policy. A system can preserve the planner, its domain model, and its planning interface while changing the volume and composition of state supplied to it.

The reported pruning experiments show that task-conditioned object selection can reduce planner search burden and planning time while maintaining or improving task completion relative to using the unpruned representation. This is not evidence that smaller graphs are intrinsically better. Remove an object that is actually needed and the planning problem can become unsolvable. The optimization target is sufficient state, not minimum state.

Spatial relations help decide what is relevant

The paper also tests richer edge information, including relative spatial attributes such as distance or position. These experiments are best interpreted as a representation test supporting the pruning mechanism rather than as a separate planning result.

Adding spatial edge attributes improves the learned model’s ability to capture task-relevant relations in the tested domains. That makes intuitive technical sense without requiring an appeal to raw graph size: whether an object matters may depend not only on its category but also on where it is relative to other objects involved in the task.

For an engineering team, this suggests that relevance filtering should not be reduced to object classification. The selection layer may need relational and geometric context to distinguish an object that merely exists in the environment from one whose location makes it operationally necessary.

The business case is a smaller planning input, not a different planner

The paper directly shows a computational pattern in simulated planning domains. Cognaptus would translate that into three deployment decisions:

The affected user is a robotics or embodied-system team maintaining a rich semantic map while facing planner latency or compute constraints. The relevant decision is whether the entire representation should be instantiated into each planning problem. The approach becomes attractive when planning cost grows materially with state size and when task context can reliably identify a sufficient subset.

On resource-constrained edge hardware, that could lower planning latency and compute demand without forcing a redesign of the planner. The paper does not provide production cost figures, hardware benchmarks, or real-world latency measurements, so any ROI estimate would require system-specific validation.

Planner-derived supervision creates a dependency

The same modular design introduces an important boundary. Object-importance labels are derived from successful classical-planner traces. The learned selector therefore inherits information from problems the supervising planner can solve and from the particular objects that appear in its solutions.

That is a credible route to generating relevance supervision, but it is not an independent ground truth for all valid plans. Alternative solution paths could rely on different objects, and failures of the supervising planner may leave parts of the task distribution weakly represented.

The evaluation is also centered on simulated household and structured planning domains. Stochastic environments, dynamic agents, changing scene graphs during execution, and physical-robot deployment remain outside the reported evidence.

The appropriate conclusion is therefore architectural rather than universal: before spending more compute searching a richer world model, test whether the planner needs that entire world model in the first place. SGPlan and the pruning experiments show that representation selection can materially change planning difficulty. Whether the same mechanism remains reliable once the world starts moving is the next engineering question.

Cognaptus: Automate the Present, Incubate the Future.