Google and university researchers propose self-evolving Procedural Graphs for LLM agents

A new paper from Google researchers and collaborators at Georgia Tech and Peking University introduces the Procedural Graph, an explicit structure that gives LLM agents step-by-step guidance and rewrites itself by studying the gap between failed and successful runs. The paper, posted to arXiv and featured on Hacker News's front page, is summarised by DAIR Academy as the work of Yuxing Lu, Yicheng Chen, Shanchan Wu and Sercan Arik at Google together with the two universities.

The problem: procedural knowledge stays implicit

According to the paper's abstract, most agents today choose their next action through free-form generation over an ever-growing transcript of prior steps. Whatever the system knows about what to do, when, and in what sequence remains buried in that context rather than written down anywhere. The consequences show up as trajectories lengthen: agents drift away from their objective, call tools in the wrong order, and loop through actions that are not working.

Knowledge graphs, but for what-to-do

The paper's organising analogy comes from knowledge graphs. A knowledge graph records facts as entity-relation-entity triplets that answer "what is" questions; a Procedural Graph records (procedure, relation, procedure) triplets that answer "what to do" questions. At each decision point the framework works out which node the agent currently occupies, and a separate guidance model reads the surrounding subgraph and turns it into situation-specific advice for the immediate next move. As DAIR Academy's summary stresses, this advice steers the solver rather than commanding it, so the acting model can still deviate when the graph itself is wrong.

Self-evolution behind a validation gate

The graph is not static. An LLM refiner compares failed trajectories with successful ones and proposes edits to the graph's shape and node attributes. Those edits are only committed if they hold or improve results on held-out validation data, and rejected proposals are archived rather than deleted, which stops the refiner from cycling back to the same change. According to the abstract, running this loop from a bare starting skeleton produces graphs on par with or better than hand-designed ones, and it can also repair a flawed prior supplied by an expert instead of simply inheriting the expert's mistakes.

Reported results

Across multiple datasets, task types and backbone LLMs, the authors report steady improvements over memory-based baselines, with self-evolution adding further gains without extra manual engineering. Both available sources describe the evaluation only at that level of detail — no specific benchmarks, scores or model names appear in the summary material — so readers will need the paper itself for the quantitative picture.

Why it matters

Reliability over long horizons is one of the main obstacles between today's agent demos and dependable production systems. This work externalises procedural knowledge into an artefact that can be inspected, debugged and edited, instead of leaving it implicit in a prompt or a memory buffer. The steer-don't-command design, paired with a validation gate on every edit, offers a middle path between rigid hand-written workflows and entirely unconstrained agents. The fact that the loop can grow a competent graph from almost nothing suggests agent scaffolding can be cultivated rather than engineered, which would lower the cost of pointing agents at new domains. The usual caveats apply: this is a single paper whose headline claims rest on its own evaluation, and the approach assumes a trustworthy way to score trajectories on validation tasks.