Plan-Based Generation Approach

• Plan-based generation is a methodology that separates the planning stage from the realization stage to improve output structure and factuality.
• It employs domain-specific representations like alignment plans, content skeletons, and graph structures to enhance quality across various tasks.
• The approach delivers state-of-the-art results in text, code, robotics, and design, while presenting challenges in computational efficiency and hyperparameter tuning.

A plan-based generation approach denotes a class of methods in machine learning and artificial intelligence in which generation (of text, code, images, plans, or structured outputs) is explicitly decomposed into two or more stages: first, a plan or high-level structure is constructed, and then an output is produced conditioned on this plan. This separation facilitates controllability, coherence, interpretability, and often factuality or faithfulness in the target domain. Plan-based generation underpins advances in neural sequence modeling, data-to-text, code generation, retrieval-augmented systems, autonomous multi-agent planning, and complex document production, with domain-specific adaptations across text, CAD, robotics, and more (Dutil et al., 2017, Moryossef et al., 2019, Su et al., 2021, Jhamtani et al., 2020, Redis et al., 2024, Huot et al., 2023, Yoo et al., 2024, Parmar et al., 22 Feb 2025, You et al., 2023, Hsu et al., 23 Mar 2025, Wu et al., 26 Feb 2025, Abe et al., 2 Apr 2025, Yin et al., 12 Jun 2025, Wang et al., 19 Aug 2025, Lyu et al., 2024, Zhang et al., 2024, Kochar et al., 12 Jan 2026, Godbole et al., 2024).

1. Core Principles and Theoretical Foundations

Plan-based generation is grounded in the notion that separating planning from realization yields advantages in controllability, interpretability, and quality. In natural language generation, this paradigm is inspired by cognitive models of writing (e.g., Flower & Hayes’s Planning→Drafting→Reviewing loop, and Scardamalia & Bereiter’s Knowledge Transforming) (Wu et al., 26 Feb 2025), operationalizing the abstraction of content and structure prior to low-level realization. In data-to-text and code generation, planning typically specifies what content to include, ordering, and functional dependencies, shifting realization to a factual and grammatical mapping of this plan to the target domain (Su et al., 2021, Moryossef et al., 2019, Yoo et al., 2024).

Probabilistically, plan-based generation often factorizes as: $$P(\text{Output} \mid \text{Input}) = \sum_{p} P(\text{Plan}=p\mid \text{Input}) \; P(\text{Output} \mid p, \text{Input}),$$ where the latent or explicit plan $p$ mediates between structured input and output (Moryossef et al., 2019, You et al., 2023).

2. Plan Representations and Mechanisms

Plan representations are domain-dependent but always encode high-level structure:

• Alignment Plans: In alignment-based seq2seq models (e.g., Plan, Attend, Generate), the plan consists of a matrix of predicted attention distributions (alignment-plan matrix) for several future steps, along with a commitment vector indicating when to update or follow the plan (Dutil et al., 2017).
• Content Skeletons: In data-to-text (e.g., PlanGen), plans are ordered lists of which facts/slots to mention and in what sequence, often using CRF-based models to select and order keys or predicates (Su et al., 2021).
• Tree or Graph Structures: Narrative and complex reasoning tasks frequently use hierarchical plans such as labeled trees or skill graphs (e.g., mind-map style trees in EIPE-text for narrative, Petri nets in LLM+process mining for robotics) (You et al., 2023, Redis et al., 2024).
• Autoregressive Plans: In autoregressive architectural design (FPDS), the plan is a sequence of room vectors, each encoding type, position, and dimensions, generated one at a time in an LLM-like loop (Yin et al., 12 Jun 2025).
• Algorithmic Pseudocode: For code generation, plans are language-agnostic pseudocode sequences or outlines capturing the solution’s algorithm (Yoo et al., 2024, Zhang et al., 2024).
• Plan Tokens: In iterative LLM generation (RPG, grounded QA), plans are short tokens summarizing the next intent or subtopic, guiding retrieval and answer stages (Lyu et al., 2024, Godbole et al., 2024).

3. Planning Algorithms and Integration Paradigms

Plan-based generation approaches are instantiated via a variety of modeling and algorithmic strategies:

• Encoder–Decoder with Planning Module: Architecture such as PAG interpose a planning module between decoder hidden states and the attention mechanism, maintaining and shifting alignment plans, with planning horizon and commitment policies trained with auxiliary losses (Dutil et al., 2017).
• Pipeline with Explicit Planner & Realizer: Modern data-to-text and RAG systems adopt strict two-stage pipelines (planner then realizer), with learnable or heuristic planners generating plans which are then realized by a fine-tuned neural generator (Su et al., 2021, Moryossef et al., 2019, Lyu et al., 2024). RL-based fine-tuning can be applied to jointly optimize for plan adherence (Su et al., 2021).
• Latent or Semi-Latent Plan Induction: Variational latent variable models induce anchor- or keyword-based plans in an unsupervised fashion during generation, optimizing for mutual informativeness and diversity (Jhamtani et al., 2020).
• Iterative/Hierarchical Interleaving: Hierarchical generation alternates plan-item (section, segment) and realization, possibly with QA-guided refinement (EIPE-text) or step-by-step plan→retrieve→answer cycles (RPG, grounded QA) (You et al., 2023, Lyu et al., 2024, Godbole et al., 2024).
• Multi-Agent and Control Frameworks: PlanGEN and robotics pipelines operationalize planning as a multi-agent process: constraint, verification, and selection agents collaborate to iteratively verify and adapt plans, selecting between exploration and exploitation based on task complexity (Parmar et al., 22 Feb 2025, Abe et al., 2 Apr 2025).
• Retrieval in Plan-Space: Retrieval-augmented code and text generation can operate by matching on plans (e.g., pseudocode in retrieval pools) instead of surface form, leveraging plan-level semantic similarity for robust selection of examples and evidence (Yoo et al., 2024, Godbole et al., 2024).
• Diffusion and Autoregressive in Vector Space: Plan-driven diffusion models (DiffPlanner) generate structured architectural layouts directly in vector space, iteratively aligning the sampling trajectory with design intent through an auxiliary alignment loss (Wang et al., 19 Aug 2025).

4. Empirical Outcomes and Benchmark Performance

Plan-based generation yields pronounced improvements in both downstream accuracy and output quality across domains, as demonstrated by authoritative benchmarks:

• Data-to-text (ToTTo, WebNLG): PlanGen and plan-based pipelines yield state-of-the-art BLEU, METEOR, and structural faithfulness metrics versus end-to-end methods, with notable gains in ordering control, diversity, and reduction of hallucinated facts (Su et al., 2021, Moryossef et al., 2019).
• Long-form and Narrative Text: Plan-based paradigms (LongEval, EIPE-text) systematically outperform direct, end-to-end generation on content-following, coherence, length control, and redundancy (≈20-point overall gains, >70 points in length alignment, reduced repetition) (Wu et al., 26 Feb 2025, You et al., 2023).
• Code Generation: Plan-based retrieval (PERC), pair-programming frameworks (PairCoder), and multi-step planning-refinement loops yield 2–5 point improvements in pass@1 on HumanEval, MultiPL-E, and CodeContest, especially for low-resource languages (Yoo et al., 2024, Zhang et al., 2024).
• Knowledge-Intensive QA: Iterative retrieve–plan–generate pipelines (RPG, analysis of plan-based retrieval) increase factual attribution (Auto-AIS up to 90%), ROUGE, and relevance, outperforming one-shot RAG (Lyu et al., 2024, Godbole et al., 2024).
• Architectural Layout and Robotics: Vector-autoregressive (FPDS) and plan-driven diffusion (DiffPlanner) models surpass prior raster or end-to-end approaches on FID, SSIM, adjacency correctness, expert plausibility ratings, and enable user control not available in black-box generative models (Yin et al., 12 Jun 2025, Wang et al., 19 Aug 2025).
• RL-driven Hardware Verification: Separating test-plan drafting from testbench realization and applying plan mutation in RL (GRPO-SMu) more than doubles verification pass rates (from ≈15% to 33%) and increases detection of RTL mutants (Kochar et al., 12 Jan 2026).

5. Design Tradeoffs and Limitations

Plan-based approaches introduce architectural benefits—improved faithfulness, transparency, and flexibly—but also practical tradeoffs:

• Computational Overhead: Planning increases runtime due to multi-stage or iterative decoding, though neural planners significantly accelerate plan search over prior exhaustive methods (Moryossef et al., 2019, Su et al., 2021).
• Hyperparameters and Tuning: Design choices such as planning horizons (PAG), plan granularity, and commitment penalties require task-specific tuning. Straight-through gradient estimators for discrete plan updates can be numerically sensitive (Dutil et al., 2017).
• Plan Representation Limits: Some tasks (e.g., strongly non-monotonic generation) can challenge alignment-plan models; hierarchical or plan-tree representations may be less effective with poorly segmented source material (Dutil et al., 2017, You et al., 2023).
• Annotation and Extraction: High-quality plan construction (e.g., tree or QA plans for narrative) often requires synthetic labeling or elaborate heuristics, and generalization to out-of-distribution plans may be limited (You et al., 2023, Jhamtani et al., 2020, Huot et al., 2023).
• Interactivity and User Control: While user-editable plans (Text-Blueprint) support transparency and customization, interactive integration increases system complexity and places more demands on UI design and back-end synchronization (Huot et al., 2023).

6. Extensions, Applications, and Future Directions

Research continues to advance plan-based generation along several dimensions:

• Adaptive Planning Horizons: Expanding static planning horizons with input- or context-adaptive policies for non-uniform alignment planning (Dutil et al., 2017).
• Integration with Retrieval and RAG: Plan-based queries for evidence retrieval, per-plan step document selection, and cross-modality planning for knowledge-intensive and underrepresented domains (Yoo et al., 2024, Godbole et al., 2024, Lyu et al., 2024).
• Process Mining and Skill Learning: Compositional skill acquisition, parallelization, and interpretability via process-mining models (Petri nets) and conformance checking (Redis et al., 2024).
• Architecture and Design Automation: Direct vector-based and plan-driven diffusion for floor-plan and layout synthesis, with alignment to iterative design workflows and user-controllability (Yin et al., 12 Jun 2025, Wang et al., 19 Aug 2025).
• Complex Planning and Multi-Agent Reasoning: PlanGEN and LLM-mediated dynamic agent graph generation scale to instance complexity, enable constraint-guided selection among diverse inference-time algorithms, and provide a model-agnostic scaffold for complex tasks (Parmar et al., 22 Feb 2025, Abe et al., 2 Apr 2025).
• Human-in-the-Loop and Interactive Editing: Interface-enabled plan modification and iterative generation produce outputs aligned with specific user requirements and domain constraints (Huot et al., 2023).

Plan-based generation thus constitutes a foundational and general paradigm for controllable, high-quality, and interpretable machine generation, with applications spanning text, code, structured documents, planning, design automation, and beyond.