Plan2Evolve: LLM-Enhanced Robotic Planning

• Plan2Evolve is an LLM self-evolving framework that generates and refines symbolic planning domains for robotic task planning using automated domain validation and chain-of-thought alignment.
• It combines PDDL-based symbolic planning with natural language reasoning to bridge correctness and model generalization, reducing inference costs and boosting success rates.
• Its self-evolution loop repairs planning errors through diagnostic feedback, enabling improved cross-task generalization and practical deployment in real-world robotic scenarios.

Plan2Evolve is an LLM self-evolving framework for robotic task planning in which a base model generates planning domains, uses those domains to produce symbolic problem–plan pairs through a symbolic planner, converts the resulting symbolic traces into extended chain-of-thought trajectories, and is then fine-tuned on the resulting corpus to obtain a planning-enhanced model with improved planning success, stronger cross-task generalization, and reduced inference costs (Huang et al., 25 Sep 2025). Its central premise is that automatically generated planning domains should be treated not only as search utilities but also as scalable engines for verifiable reasoning supervision.

1. Conceptual framing

Plan2Evolve addresses a specific weakness of LLM-based robotic planning: long-horizon tasks expose stochastic outputs, error accumulation over long horizons, and failures in action feasibility verification, state tracking, and dependency verification. The framework treats this as a supervision bottleneck rather than only an inference bottleneck. In general LLM reasoning, large gains have come from chain-of-thought supervision, but in robotics such data are expensive because step-by-step traces must remain aligned with executable task structure. Plan2Evolve replaces manual trace construction with a self-evolving loop in which the model helps generate its own symbolic world model and then learns from verified trajectories induced by that model (Huang et al., 25 Sep 2025).

A useful distinction is that Plan2Evolve does not merely ask an LLM to emit plans directly. It first induces a symbolic planning substrate in PDDL, then uses symbolic search to produce valid problem–plan pairs, and only afterward translates those verified traces into natural-language reasoning. This makes the framework neither pure symbolic planning nor pure language-only reasoning. It is a hybrid in which symbolic planning supplies correctness and the LLM supplies abstraction, explanation, and downstream generalization.

The framework’s notion of “self-evolution” is therefore specific. The same base model $\mathcal{M}_0$ is used for planning domain generation, symbolic-to-natural-language conversion, and subsequent supervised fine-tuning. A plausible implication is that the main object of improvement is not a single generated plan at inference time, but the model’s planning prior after post-training.

2. Symbolic formulation and domain induction

Plan2Evolve uses PDDL as its symbolic representation. A planning domain is formalized as

$\mathcal{D} = (\mathcal{P}, \mathcal{A}),$

where $\mathcal{P}$ is a set of predicates and $\mathcal{A}$ is a set of actions. With object set

$\mathcal{O}=\{o_1,\dots,o_n\},$

each predicate $p \in \mathcal{P}$ is a Boolean classifier

$p(o_1,\dots,o_i) \to \{0,1\},$

the ground atom set is

$$\mathcal{G}=\{\,p(o_1,\dots,o_k)\mid p\in\mathcal{P},~o_i\in\mathcal{O}\,\},$$

and a symbolic state is

$\mathcal{X}\subseteq\mathcal{G}.$

Each action is

$a = \langle \mathrm{PRE},~\mathrm{EFF}\rangle,$

with execution inducing

$\mathcal{D} = (\mathcal{P}, \mathcal{A}),$0

A planning problem is then

$\mathcal{D} = (\mathcal{P}, \mathcal{A}),$1

These definitions are the formal backbone of the framework (Huang et al., 25 Sep 2025).

Domain generation begins from input $\mathcal{D} = (\mathcal{P}, \mathcal{A}),$2, specified in the appendix as a demonstration trajectory with a short task description, following Huang et al. (2025). The model first produces a domain skeleton $\mathcal{D} = (\mathcal{P}, \mathcal{A}),$3. That skeleton is then validated by solving sampled planning problems. If solver failures occur, planner error traces are converted into diagnostic prompts and fed back to the model for repair through a feedback function

$\mathcal{D} = (\mathcal{P}, \mathcal{A}),$4

The paper also reports a hill-climbing redundancy-pruning step that removes unnecessary predicates and actions, yielding a final validated domain $\mathcal{D} = (\mathcal{P}, \mathcal{A}),$5 (Huang et al., 25 Sep 2025).

This repair loop is important because Plan2Evolve assumes that a model may be able to generate a usable symbolic abstraction even when it is not yet a strong direct planner. The domain becomes a structured generator of solvable tasks, rather than only a static artifact.

3. From validated domains to aligned reasoning traces

Once $\mathcal{D} = (\mathcal{P}, \mathcal{A}),$6 is available, Plan2Evolve samples initial and goal states consistent with that domain and constructs planning problems. The symbolic solver is the Fast-Forward planner, accessed through a Python interface from Garrett et al. (2020). For each planning problem, the solver returns a plan

$\mathcal{D} = (\mathcal{P}, \mathcal{A}),$7

such that

$\mathcal{D} = (\mathcal{P}, \mathcal{A}),$8

From this, the framework extracts a symbolic transition trace

$\mathcal{D} = (\mathcal{P}, \mathcal{A}),$9

The paper states that the solver is allowed to generate optimal plans, suboptimal variants, and plans containing redundant steps or corrective steps, so the resulting supervision is not restricted to shortest-path traces (Huang et al., 25 Sep 2025).

The key alignment step is the conversion of symbolic transitions into natural-language chain-of-thought. For each transition, the model produces

$\mathcal{P}$0

and the full aligned reasoning trajectory is

$\mathcal{P}$1

The paper explicitly defines this alignment as richer than plan paraphrase. It includes plan explanation, state transition check, alternative exploration, and failure backtracking. The prompt instructs the model to explain why each action was chosen, how each action changes the state, how the evolving state satisfies preconditions and leads toward the goal, which alternative actions were applicable, and why those alternatives were not chosen (Huang et al., 25 Sep 2025).

A common misunderstanding is to read Plan2Evolve as a symbolic-data-only pipeline. The paper’s ablations argue against that interpretation. Raw symbolic traces alone provide weaker transfer than symbolic-language alignment, which suggests that symbolic correctness and language-model learnability are distinct requirements.

4. Training corpus and optimization

Each aligned training example is

$\mathcal{P}$2

and the corpus is

$\mathcal{P}$3

The final SFT set contains 5,807 examples. The appendix reports 719 from Blocks World Align, 3,048 from Blocks World Hard, and 2,038 from Blocks World Reorder, while the main experimental section describes the training tasks as Blocks World Classic, Blocks World Hard, and Blocks World Align. This suggests a naming mismatch between the main text and appendix rather than a different data-generation procedure. Solution lengths range from 0 to 60 steps (Huang et al., 25 Sep 2025).

The paper states that the problem description is dynamically paraphrased by the base model during data generation to avoid overfitting to a narrow prompt style. It also reports a held-out evaluation split at ratio 0.1, with 80, 340, and 227 examples for the respective task groups named in the appendix.

Supervised fine-tuning uses standard autoregressive language modeling over the concatenated target sequence $\mathcal{P}$4. The reported hyperparameters are learning rate $\mathcal{P}$5, 5 epochs, per-device batch size 2, gradient accumulation 2, and max generation length for CoT generation of 65,536 tokens. The base models are Qwen3-4B-Instruct-2507 and Qwen3-8B, producing P2E-4B and P2E-8B, and the teacher-student variant uses Qwen3-30B-A3B-Thinking as teacher (Huang et al., 25 Sep 2025).

Notably, the paper does not describe repeated rounds of re-generating data with the newly fine-tuned model. The implemented procedure is a generate-align-fine-tune pipeline rather than a multi-generation recursive self-training curriculum.

5. Empirical performance

Evaluation covers 1,400 test experiments across four environments and over 300 previously unseen objects and 50 furniture types. The seven reported datasets each contain 200 tasks: stack-200, unstack-200, reorder-200, align-200, prepare-experiment-200, reorganize-room-200, and machine-parts-assembly-200. Test-time prompting provides only the problem description; no extra CoT or prompting tricks are used. The main metrics are Success Rate, defined by exact goal achievement, and Progress Score, defined through state similarity between the goal and the state reached before the first invalid action (Huang et al., 25 Sep 2025).

The self-evolution results show clear gains over the corresponding base models. P2E-8B reaches overall success rate $\mathcal{P}$6 and progress score $\mathcal{P}$7, compared with $\mathcal{P}$8 and $\mathcal{P}$9 for Qwen3-8B. P2E-4B reaches $\mathcal{A}$0 and $\mathcal{A}$1, compared with $\mathcal{A}$2 and $\mathcal{A}$3 for Qwen3-4B. On BW Hard, P2E-8B improves from $\mathcal{A}$4 to $\mathcal{A}$5, and P2E-4B improves from $\mathcal{A}$6 to $\mathcal{A}$7. The unseen-task gains are also nontrivial: for example, P2E-4B improves Prepare Experiment from $\mathcal{A}$8 to $\mathcal{A}$9 and Machine Parts Assembly from $\mathcal{O}=\{o_1,\dots,o_n\},$0 to $\mathcal{O}=\{o_1,\dots,o_n\},$1 (Huang et al., 25 Sep 2025).

The teacher-student version is substantially stronger than direct response distillation. P2ETS-8B(30B) reaches overall success $\mathcal{O}=\{o_1,\dots,o_n\},$2 and progress $\mathcal{O}=\{o_1,\dots,o_n\},$3, while Distill-8B(30B) reaches $\mathcal{O}=\{o_1,\dots,o_n\},$4 and $\mathcal{O}=\{o_1,\dots,o_n\},$5. P2ETS-4B(30B) reaches $\mathcal{O}=\{o_1,\dots,o_n\},$6 and $\mathcal{O}=\{o_1,\dots,o_n\},$7, while Distill-4B(30B) reaches $\mathcal{O}=\{o_1,\dots,o_n\},$8 and $\mathcal{O}=\{o_1,\dots,o_n\},$9. The appendix also reports Qwen3-30B itself at overall success $p \in \mathcal{P}$0 and progress $p \in \mathcal{P}$1, so the teacher-student Plan2Evolve variant does not surpass the teacher on exact success but does exceed it on progress score.

The symbolic-only ablation further clarifies the method’s mechanism. SymbOnly-4B reaches overall success $p \in \mathcal{P}$2 and progress $p \in \mathcal{P}$3, below P2E-4B at $p \in \mathcal{P}$4 and $p \in \mathcal{P}$5. The paper interprets this as evidence that raw symbolic traces provide only minimal improvement overall and that symbolic–language alignment is the more effective supervision route. Efficiency results point in the same direction: P2E-8B averages 5988 tokens versus 8631 for Qwen3-8B, and P2E-4B averages 7584 versus 8929 for Qwen3-4B. The framework also includes a proof-of-concept deployment on a UR5e robot, where P2E-4B provides high-level plans and $p \in \mathcal{P}$6 maps them to low-level spatial delta poses after fine-tuning on 200 real-world pick-and-place trajectories (Huang et al., 25 Sep 2025).

6. Relation to the broader “Plan2Evolve” landscape and limitations

The name “Plan2Evolve” now refers both to this specific self-evolution framework and to a broader planning-as-evolution perspective. Evoflux describes itself as a concrete instantiation of a “Plan2Evolve” view in which compact tool agents should treat planning as iterative construction and repair of an executable workflow under real environment constraints rather than as one-shot decoding (Bhandari et al., 10 Jun 2026). That is a different operational regime from Plan2Evolve proper: Evoflux is inference-time evolutionary repair over typed workflow graphs, whereas Plan2Evolve is post-training through domain generation and symbolic-language alignment.

Other neighboring systems expose additional interpretations of the same design space. Mind Evolution evolves natural-language plans directly at inference time through population search, recombination, migration, and reset (Lee et al., 17 Jan 2025). TodoEvolve moves one level higher and synthesizes planning architectures themselves rather than action sequences (Liu et al., 8 Feb 2026). Auto-Evolve, by contrast, iteratively constructs and refines task-level JSON reasoning structures without an explicit external verifier in the loop (Aswani et al., 2024). This suggests that “Plan2Evolve” names a family resemblance across methods that separate planning from execution and treat planning artifacts as objects that can be generated, revised, or learned from.

The limitations of Plan2Evolve are explicit. It depends on a base model capable enough to generate valid PDDL domains, which constrains applicability to small models. The quality of symbolic-language alignment is itself bounded by the model’s reasoning ability, and the framework does not directly optimize that translator. It also depends on valid symbolic domains and the FF planner, and it does not provide a large-scale embodied deployment study beyond the UR5e proof of concept. Future extensions to multimodal inputs are left open (Huang et al., 25 Sep 2025). A practical implication is that Plan2Evolve is best understood as a scalable synthetic-supervision pipeline for symbolic planning domains, not as a universal replacement for inference-time search or for fully embodied planner learning.