---
title: Graph-then-Plan Inference Framework
url: https://www.emergentmind.com/topics/graph-then-plan-inference-framework
type: topic
---

# Graph-then-Plan Inference Framework

A graph-then-plan inference framework is a methodological paradigm in which a problem instance is first represented as a graph—encoding entities, dependencies, constraints, or relational information—before explicit planning, search, or policy generation is performed over this graph structure. This separation of abstraction (graph construction) and subsequent reasoning or planning (plan synthesis or execution) enables explicit modeling of dependencies, parallelizable scheduling, modular system design, and, in recent neural and symbolic systems, improved robustness and efficiency. The approach is now employed in LLM agent scheduling, multi-hop retrieval-augmented generation, knowledge-graph reasoning, program synthesis, robot exploration, and tool-augmented agent planning.

## 1. Formalization Across Domains

Across canonical works, the graph-then-plan formulation encompasses a two-phase pipeline:

1. **Graph Construction:** Input data (usually a complex task, structured query, environment state, or artifact) is mapped into a graph $G=(V,E)$, capturing subtask decomposition, dependencies, relational structure, or spatial/semantic zones.
2. **Planning/Reasoning:** The planning module accepts $G$ and outputs an explicit plan $P$ (set of actions, traversals, operations, or schedules), optimizing one or more objective functions subject to the graph-imposed constraints.

Key instantiations:

- **Plan-over-Graph (LLM Scheduling):** High-level textual task $T$ is decomposed by LLM into an abstracted task DAG $G=(V,E)$, where $V$ are subtasks and $E$ are precedence edges. The plan is a subgraph $P\subseteq G$ connecting sources to goals under makespan minimization, possibly regularized by cost [2502.14563].
- **Retrieval over Knowledge Graphs:** For RAG or knowledge-domain reasoning, a graph $G$ encodes typed nodes/relations; the planner synthesizes a sequence of traversal actions yielding a minimal informative subgraph for downstream answer generation (GraphRunner) [2507.08945].
- **Program Synthesis via Graph Abstraction:** Graphs representing structured abstractions (e.g., object-centric in ARC) permit constraint-based planning at the graph level, where DSL programs act as transformation sequences over $G$ [2210.09880].
- **Reasoning/Memory Graphs:** Evidence-centric chain-of-thought graphs persist agent judgments over passages, supporting feedback-driven, self-improving answer pipelines [2604.07595].
- **Physical Planning and Spatial Layouts:** Layout, occupancy, or region graphs inform policy or generation modules in robot exploration or floorplan synthesis, integrating spatial inference before planning [2509.19916, 2004.13204].

## 2. Representative Algorithms and Pipelines

The graph-then-plan paradigm admits diverse algorithmic realizations, all sharing a split between structure induction and plan generation.

### Table: Core Stages Across Exemplars

| Domain                  | Stage 1: Graph Construction                     | Stage 2: Planning/Reasoning                          |
|-------------------------|------------------------------------------------|------------------------------------------------------|
| LLM Task Scheduling     | T → G: LLM decomposes task into subtask DAG    | G → P: LLM/adapter outputs parallelizable plan P     |
| Retrieval (GraphRunner) | q → G: Structured knowledge graph              | Plan: LLM outputs multi-hop plan; verify, then exec  |
| ARC Program Synthesis   | Pixel grid → object graph(s)                   | Plan: Search for programs in DSL over G              |
| Robot Exploration       | Occupancy map → region-evaluation graph        | Diffusion policy over inferred graph                  |
| Tool Planning           | Tool+domain schemas → fused dependency graph   | Subgraph retrieval; LLM plans with rationale         |
| Reasoning Memory        | Runs → reasoning/retrieval graph (persisted)   | Traversal-based pipeline planning for feedback        |

Detailed approaches:

- **Plan-over-Graph:** Natural-language prompt or task description is parsed by an LLM (using CoT prompts and rule extraction) into a JSON-formatted task graph; a LoRA-adapted LLM then plans over graph input, trained under SFT and DPO with synthetic pretraining and real-task fine-tuning [2502.14563].
- **GraphRunner:** LLM in a single prompt generates a holistic traversal plan over a knowledge graph; the verifier ensures action validity and graph compatibility; the executor performs high-level (including multi-hop) traversal actions [2507.08945].
- **ARGA (ARC):** Graph abstractions of images constructed via component extraction; planning is constraint-driven program synthesis in a DSL over graphs; constraint acquisition, best-first search, and hashing/tabu pruning optimize combinatorial search [2210.09880].
- **Plan*RAG:** Multi-hop QA infers a DAG of subqueries explicitly; execution proceeds depth-by-depth in parallel, with on-demand atomic retrieval and per-node answer composition [2410.20753].

## 3. Advantages Over Sequential or Iterative Methods

Empirical and theoretical analysis repeatedly demonstrate the superiority of explicit graph-then-plan pipelines compared to monolithic or sequential reasoning:

- **Parallelism:** Explicit graph representations admit subtask concurrency; e.g., Plan-over-Graph demonstrates substantial makespan reduction (parallel vs. sequential ratios $R \approx 0.7$ for $|V|=50$) [2502.14563].
- **Error Reduction:** Planning over graphs enables global constraint enforcement, reducing mid-chain hallucination and accumulation of model errors (GraphRunner achieves $10$–$50\%$ performance improvement and $3$–$12.9\times$ cost reduction over iterative single-hop methods) [2507.08945].
- **Context Control:** State and dependency information are persisted in the graph, decoupling reasoning from limited-length context windows responsible for context bloat and failure in context-only LLM chains [2410.20753].
- **Composite Feedback and Learning:** Persistent graph memory in reasoning graphs supports evidence-centric, backward traversal for fine-grained feedback, yielding provable accuracy convergence and variance collapse without model retraining [2604.07595].

## 4. Graph Representation, Objectives, and Learning

The structural properties of the graph and the objectives of the planning stage are domain-adapted but structurally analogous:

- **Graphs:** DAGs with nodes as subtasks, regions, objects, tools, or evidence; edges encode ordering, precedence, spatial, or semantic relations; attributes annotate costs, times, or features [2502.14563, 2507.08945, 2210.09880, 2004.13204].
- **Planning Objective:** Formally, plans $P$ are subgraphs or sequences optimally connecting initial and goal nodes under makespan, cost, or accuracy metrics, subject to prerequisites or constraints; various loss functions including cross-entropy, DPO, and program synthesis-specific heuristics are employed [2502.14563, 2210.09880].
- **Learning:** Synthetic graph generation (random/tree-based DAGs), constraint acquisition, hashing, and task-specific pretraining ground the model’s graph-reasoning capacity and structural bias, especially when scaling beyond the comprehension range of direct large-language-model inference [2502.14563, 2210.09880].

## 5. Empirical Results and Benchmarks

Experimental validations highlight robust performance and scaling:

- **Plan-over-Graph:** Llama-trained models achieve optimal rate (OR) of $72.5\%$ and success rate (SR) of $83.0\%$ on real tasks, far surpassing API-based LLMs in optimal scheduling, especially for large graphs (maintain OR $\approx 45\%$ even for $|V|=50$ where zero-shot LLMs degrade to OR~$6\%$) [2502.14563].
- **GraphRunner:** Achieves up to $50\%$ relative improvement in retrieval accuracy over Graph-CoT, with $3.0$–$12.9\times$ token cost reduction and $2.5$–$7.1\times$ faster response times [2507.08945].
- **ARGA (ARC):** Solves $35.6\%$ of test tasks with a $10^3$-fold reduction in combinatorial search compared to baselines, with constraint acquisition and hashing providing significant further speed-ups [2210.09880].
- **Plan*RAG:** On multi-hop benchmarks, Plan*RAG outperforms Self-RAG by $2$–$8$ F1 points and reduces retrieval calls by $20\%$, with further ablation showing graph planning accounts for a $5$-pp accuracy gain [2410.20753].

## 6. Limitations and Future Directions

Current graph-then-plan frameworks face several open frontiers:

- **Static Graph Limitation:** Most pipelines assume static graph representations; real-world applications may require online graph updates, dynamic replanning, or closed-loop perception-action cycles [2502.14563].
- **Expressivity Constraints:** Existing representation schemes may not capture higher-order constraints (non-adjacency, resource bounds) critical for complex or stochastic domains [2004.13204].
- **Integration with Subgraph Neural Modules:** Tight integration of learned subgraph embeddings (e.g., GNNs) may enhance plan induction in highly structured settings [2502.14563].
- **Scalability:** Ultra-large graphs present computational and retrieval bottlenecks, potentially necessitating partitioning, sampling, or adaptive pruning [2510.24690].
- **Cross-Domain Adaptation:** Multimodal and cross-domain scenarios call for more general graph induction and planning machinery, including mixed-initiative user feedback, multi-agent coordination, and explicit uncertainty modeling [2509.19916].

## 7. Contextualization Within Automated Reasoning and AI Planning

The graph-then-plan paradigm has deep roots in classical symbolic planning (e.g., Graphplan as dynamic CSP with EBL/DDB/flexible variable ordering [1106.0230]) and has evolved through contemporary program synthesis, retrieval-based question answering, and agentic multimodal reasoning. Its re-emergence in modern LLM-centric systems reflects the necessity of externalizing state and dependencies for computational tractability, modular reasoning, and robust parallelism, especially as architectural context windows saturate and task complexity escalates. This framing is expected to remain foundational in future cognitive AI and agentic system design.

Source: https://www.emergentmind.com/topics/graph-then-plan-inference-framework