Procedural Graphs: Self-Improving LLM Agent Execution Structures

wpnews.pro

#

Procedural Graphs: Self-Evolving Execution Structures for LLM Agents

#

When AI Agents Start Writing Their Own "Brain Circuits"

Published: September 10, 2026 | Reading time: 12 minutes

On September 9, 2026, researchers Yuxing Lu, Yicheng Chen, and Shanchan Wu published a groundbreaking paper on Procedural Graphs — a self-evolving execution structure for LLM agents that can literally rewrite its own "brain circuits."

Paper: arXiv:2609.08593

#

The Problem with Current LLM Agents

Today's LLM agents (like AutoGPT, LangChain agents) work like this:

Maintain a growing memory of past thoughts, observations, actions
Generate next action based on this memory

No fixed structure , no predefined流程

This works for simple tasks, but breaks down for complex ones:

Lost goals : Forget what they're supposed to do in long interactions #

Action mismatch : Call tools in wrong order (e.g., analyze before searching) #

Repeated labor : Try same ineffective operations repeatedly #

No planning : No global view, step-by-step navigation Analogy: Like a chef without a recipe — overwhelmed by complex dishes.

#

The Solution: Procedural Graphs

Procedural Graphs organize procedural knowledge ("how to do") just like Knowledge Graphs organize factual knowledge ("what is"):

Core Components

Nodes (程序步骤):

Each node represents a procedural step
Contains: description, expected I/O, success/failure conditions
Like a box in a flowchart

Edges (关系):

Represent relationships between steps
Types: Sequential ("then"), Conditional ("if...then"), Parallel ("simultaneously")
Like arrows in a flowchart

Attributes (属性):

Execution probability, average time, success rate, common error patterns
Update with execution experience

#

How It Works: A Concrete Example

Task: "Book a cheap flight from Beijing to Shanghai, departing tomorrow."

Procedural Graph:

This is a directed graph with branches, loops, and conditionals — far more powerful than linear memory.

#

The Self-Evolution Mechanism

The most amazing capability is self-evolution:

Evolution Cycle

Collect trajectories : Record complete execution paths 2. Compare analysis : Contrast failed trajectories with successful ones 3. Identify differences : Find where things went wrong 4. Generate edits : LLM Refiner proposes modifications 5. Verify and retain : Test on validation set

Three Types of Edits

Topology Edits :

Add new nodes (new steps)
Remove redundant nodes
Add/modify edges (change flow structure)

Attribute Edits :

Update node success rate statistics
Adjust condition thresholds
Update execution probabilities

Content Edits :

Modify node descriptions for accuracy
Update guidance language for effectiveness

#

From Skeleton to Maturity Researchers tested three initialization methods:

Amazing Discovery: Even starting from a flawed expert prior, the evolution mechanism can "repair" it to achieve good performance.

This shows robustness — doesn't require perfect initial design.

#

Why Graphs Beat Memory

Key Advantage: Procedural Graphs abstract the general flow for a class of tasks, not just specific past cases.

Analogy:

Workflow Memory = Remember "Last time I made Mapo Tofu, I stir-fried meat first, then added bean paste"
Procedural Graph = Understand "General stir-fry flow: Heat pan → Add oil → Stir-fry main ingredient → Season → Serve"

The latter generalizes to any stir-fry; the latter can only repeat Mapo Tofu.

#

Experimental Results

WebShop (Web Shopping)

Task: Purchase items on e-commerce sites based on natural language instructions

- Graph vs Memory: **15-25% success rate improvement**
- Evolved Graph vs Initial: **10-20% improvement**

ALFWorld (Home Tasks)

Task: Execute daily tasks in simulated home environment
Graph helps remember complex object interaction sequences

  HotPotQA (Multi-hop QA)

- Task: Multi-step information retrieval and reasoning

Graph optimizes retrieval strategy and evidence integration

Tool Use Tasks

Task: Combine multiple APIs to complete complex goals
Graph ensures correct tool call order and parameter settings

#

Key Findings

  Finding 1: Cross-LLM Generalization

- Graph evolved on one LLM (e.g., GPT-4) can transfer to another (e.g., Claude or Llama)

Shows graphs capture task structure , not model-specific traits

  Finding 2: Few-Shot Advantage

- Effective even with **few examples (<10)**

Pure memory baseline drops sharply with few samples

Finding 3: Expert Prior Repairability

Can repair flawed human-designed starting points
Lowers deployment threshold — no perfect initial design needed

#

Deeper Insights

From Connectionism to Symbolism Procedural Graphs represent an important trend: neural-network + symbolic-structure fusion.

Deep Learning (connectionism): Good at learning patterns from data, lacks explicit reasoning structure #

Symbolic AI : Good at logical reasoning and structured knowledge, lacks learning from data

Graph combines both:

LLM provides semantic understanding
Graph structure provides procedural constraints

This is a Neuro-Symbolic architecture — possibly a key path to more reliable AI.

Biological Intelligence Analogy

Human brain similarly combines two systems:

System 1 (fast, intuitive, pattern-matching): Like LLM generation #

System 2 (slow, logical, rule-based): Like Procedural Graph execution The graph is like giving LLMs a System 2 — an explicit, checkable, fixable execution controller.

#

Code Example: Creating a Procedural Graph

#

Architecture Overview

Key Components

Graph Store : Stores nodes, edges, and attributes 2. Navigator : Determines next node based on current state 3. Refiner : Proposes graph edits based on trajectory feedback 4. Verifier : Tests graph modifications on validation set

Evolution Process

Collect execution trajectories
Compare successful vs. failed paths
Identify differences and generate edits
Verify edits on validation set
Apply successful edits to production graph

#

Software Engineering Perspective

Procedural Graphs introduce key concepts:

Separation of Concerns

"What to do" (task understanding): LLM #

"How to do" (execution flow): Graph #

"How to improve" (flow optimization): Refiner

Version Control

Every graph edit is recorded
Can rollback to previous versions
Can compare performance across versions

Testability

Graph can be independently tested on validation sets
Edit effects can be quantified
Avoids "black-box optimization" uncertainty

#

Conclusion

The story of Procedural Graphs is essentially a story about organization.

Information alone has no value. Only when organized into useful structures — recipes, flowcharts, algorithms, organizational charts — can it guide action, produce results, and continuously improve.

LLM agents have massive knowledge and powerful generation capabilities, but lack structured execution frameworks. Procedural Graphs fill this gap:

Give agents a "skeleton" — clear execution flow
Give agents "learning ability" — self-evolve from failures
Give agents "explainability" — humans can understand and modify its "thinking"

When that recipe starts rewriting itself, it's no longer just a book. It becomes a living thing — constantly adapting, learning, and improving.

This is the ultimate vision of Procedural Graphs: Not giving agents a fixed program, but giving them a brain that can write its own programs.

This article is based on research published by Yuxing Lu, Yicheng Chen, and Shanchan Wu on September 9, 2026. Paper: arXiv:2609.08593

source & further reading

dev.to — original article TS Evidence Graph: Make Every SKILL Instruction 100% Enforced AI agents can sound strategic while reasoning from events that never happened Will Mojo Replace Python for AI Development?