Graph Engineering organizes LLM agents as evolving graphs
Large language models have moved from plain text generators to autonomous agents that carry out complex, long-running tasks. That shift, the authors write, has already produced four paradigms: Prompt Engineering, which elicits model capabilities; Context Engineering, which manages information access; Harness Engineering, which organizes external tools and resources; and Loop Engineering, which supports continual reflection and self-improvement.
The authors argue that all four paradigms still work within a single agent, and that approach hits a hard limit as tasks get harder. Many real tasks need heterogeneous expertise, subtasks that depend on each other, work that can run in parallel, independent verification of results, and state that persists across steps, more than any one agent can organize on its own. Making that one agent more capable, or giving it a bigger context window, does not fix the mismatch: the problem is architectural, and intelligence has to be spread across multiple specialized agents and coordinated at the level of the whole system, not concentrated in one.
The paper names that target capability System Intelligence: an agent system's ability to organize and coordinate multiple intelligent components into a coherent, adaptive whole pursuing a shared objective. Reaching it, the authors say, takes more than adding more agents to a system; it requires explicit structures that organize the work, coordinate agents with different roles, and keep track of an execution state that keeps evolving as the system runs.
To build those structures, the paper introduces Graph Engineering, an emerging paradigm for this next generation of agent systems. Where the four earlier paradigms mainly tune how one agent behaves or interacts, Graph Engineering builds explicit graphs that evolve over time and represent the tasks, the agents, and the system's state directly. The authors present these graph structures as a single foundation that can organize complex objectives, orchestrate agents with different specialties, model how the system changes over time, and let the whole system evolve at scale.
The paper itself is a systematic review: it walks through the principles, methods, and applications that make up Graph Engineering as a field, rather than reporting new experiments or benchmark results of its own. Alongside the paper, the authors maintain a collection of related papers, open source data, and projects on GitHub, at https://github.com/DEEP-JLU/Awesome-Graph-Engineering.
Key facts
- The paper introduces Graph Engineering, a paradigm that represents tasks, agents, and system state as explicit, evolving graphs rather than optimizing a single agent's behavior.
- It argues that four earlier paradigms, Prompt Engineering, Context Engineering, Harness Engineering, and Loop Engineering, all operate on a single agent and cannot handle tasks needing heterogeneous expertise, interdependent subtasks, parallel execution, independent verification, and persistent state.
- The authors name the goal System Intelligence: an agent system's ability to organize and coordinate multiple intelligent components into a coherent, adaptive whole pursuing a shared objective.
- The paper is a systematic review of Graph Engineering's principles, methodologies, and applications, not a report of new experiments or benchmarks.
- Related papers, open source data, and projects on Graph Engineering are collected on GitHub at https://github.com/DEEP-JLU/Awesome-Graph-Engineering.
Why it matters
As LLM agents take on longer and more complex tasks, teams keep hitting the same wall: one agent, however capable or however large its context window, cannot organize work that needs different kinds of expertise, subtasks with dependencies, parallel execution, independent checks, and state that persists across many steps. The paper's argument is that this is not a capability problem to fix with a bigger model: it is an architectural one, and the fix has to happen at the level of the whole system rather than the individual agent. Graph Engineering is offered as a name and a structure for that shift, representing tasks, agents, and system state as explicit graphs that evolve as the system runs, rather than leaving coordination implicit in how agents happen to interact.
Who it affects
This is a research contribution aimed at people designing multi-agent LLM systems: orchestration frameworks, multi-agent research groups, and engineers building production systems where tasks get split across specialized agents. It is a review and framing paper rather than a tool or a product, so it does not ship anything to install; instead it offers a vocabulary and a structural approach for coordinating many agents at once, a problem the authors say the four single-agent paradigms do not address.
How to use it
There is no software to install here. The paper works as a systematic review, walking through the principles, methodologies, and applications that make up Graph Engineering as an emerging field, so the practical way to use it is as a map of that space rather than a tool to run. The authors maintain a companion collection of related papers, open source data, and projects at https://github.com/DEEP-JLU/Awesome-Graph-Engineering, which is the more concrete entry point for anyone looking for specific implementations rather than the paradigm's framing.
How solid is it
The paper presents itself as a systematic review of principles, methodologies, and applications, not an empirical study. It reports no experiments, benchmarks, or case studies of its own showing that graph-based coordination outperforms the four earlier paradigms it argues against. The case for Graph Engineering rests on argument and synthesis of prior work rather than new measurement.
Risks and caveats
The text names no individual authors or institutional affiliation, and gives no date for when the paper was submitted or published, so a reader cannot trace who wrote it or when from the abstract alone. It also does not state how many papers the review covers, how many projects sit in the companion GitHub collection, or any specific graph algorithm, system architecture, or software implementation beyond the general framing of graph structures that evolve over time. Readers who need concrete methods will have to follow the GitHub collection rather than this abstract.
“We call this System Intelligence: an agent system's ability to organize and coordinate multiple intelligent components into a coherent, adaptive whole pursuing a shared objective.”
— the authors