PaperlayerView exact revision on arXiv

Source-linked AI summary

Graph Engineering in the Era of LLM Agents: From Individual Intelligence to System Intelligence

Yuyuan Feng, Zhishang Xiang, Chaobin Yang, Qichao Ma, Zerui Chen, Yujing Zhang, Ke Huang, Chuanjie Wu, Zhaoxu Liu, Yili Wang, Xin He, Jiapu Wang, Zijin Hong, Hao Chen, Yuanchen Bei, Kun Wang, Shengyuan Chen, Ningyu Zhang, Enyan Dai, Linhao Luo, Qingyi Pan, Qi Wang, Wenqi Fan, Guangjing Wang, Na Zou, Yangqiu Song, Xin Wang, Zechao Li, Xia Hu, Qing Li, Xiao Huang, Zhihong Zhang, Jinsong Su, Qinggang Zhang, Yi Chang

arXiv:2608.21156v1cs.IRcs.AIcs.ET

TL;DR

As complex tasks exceed what standalone agents can organize, the paper reviews Graph Engineering as a system-level approach for coordinating tasks, agents, and runtime states. Its survey finds that work organization and agent coordination are common, while persistent system evolution remains rare, emphasizing explicit organization of relations over simply adding agents.

  • Problem

    Complex, heterogeneous, interdependent, long-horizon tasks exceed what individual agents can organize, motivating system-level intelligence across specialized agents.

  • Method

    The paper systematically reviews Graph Engineering, which uses explicit graphs to organize task decomposition, agent coordination, and runtime state evolution.

  • Results

    Across surveyed domains, work organization and agent coordination are common, runtime state management is emerging, and persistent system evolution remains rare.

  • Takeaways & Limitations

    System-level intelligence depends less on adding models or agents than on explicitly organizing relationships among work, actors, and state.

  • Takeaways & Limitations

    End-task success alone cannot establish System Intelligence because gains may reflect stronger models, longer contexts, additional sampling, or greater computational cost.

Abstract

from arXiv · show

LLMs have evolved from language generators to autonomous agents capable of complex, long-horizon tasks. This evolution has produced paradigms including Prompt Engineering to elicit model capabilities, Context Engineering to manage information access, Harness Engineering to organize external tools and resources, and Loop Engineering to support continual reflection and self-improvement. Yet as tasks grow more complex, individual intelligence faces a fundamental limit: many tasks require heterogeneous expertise, interdependent subtasks, parallel execution, independent verification, and persistent state, exceeding any single agent's organizational capacity. Augmenting one agent's capabilities or context cannot resolve this architectural mismatch; intelligence must instead be distributed across specialized agents and organized at the system level. 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. Achieving it requires more than adding agents; it demands explicit structures to organize work, coordinate heterogeneous agents, and maintain evolving execution states. We introduce Graph Engineering, an emerging paradigm for next-generation agent systems. Unlike prior paradigms that mainly optimize individual interactions or agent-level behavior, Graph Engineering constructs explicit, dynamic, evolving graph structures representing tasks, agents, and system states. These abstractions provide a unified foundation for organizing complex objectives, orchestrating heterogeneous agents, modeling system dynamics, and enabling scalable agent evolution. We systematically review the principles, methodologies, and applications of Graph Engineering for LLM agents. Related papers, open-source data, and projects are collected at https://github.com/DEEP-JLU/Awesome-Graph-Engineering.

1 Introduction

LLMs have progressed from model-level capabilities to autonomous agents through Harness and Loop Engineering, but complex, long-horizon tasks exceed any single agent’s organizational capacity. The paper introduces Graph Engineering to distribute intelligence across specialized agents and organize tasks, coordination, and evolving runtime state at the system level.

  • From Model Intelligence to Individual Intelligence: Harness and Loop Engineering extend LLMs with resources, tools, memory, skills, and persistent iterative execution, yielding Individual Intelligence.The framework characterizes an agent as Agent = Loop(LLM + Harness).
  • From Individual Intelligence to System Intelligence: Individual Intelligence is insufficient for tasks requiring heterogeneous expertise, interdependent subtasks, parallel execution, independent verification, and persistent state.These requirements exceed the organizational capacity of a single agent [88] [93] [155] [415].
  • From Individual Intelligence to System Intelligence: Because augmenting one agent’s capabilities or context cannot resolve this structural mismatch, intelligence must be distributed across specialized agents and organized at the system level.The paper calls this capability System Intelligence [159] [284].
  • Graph Engineering: Graph Engineering uses dynamic graph structures to organize task execution, coordinate agents, and control runtime state evolution for system-level intelligence.Its three organizational problems are Task Organization, Agent Coordination, and Runtime State Management.
  • Contributions: The paper develops a framework spanning agent and system concepts, the evolution from Model to Individual to System Intelligence, graph-based organization, evaluation, software stacks, and applications.The surveyed applications include software engineering, scientific discovery, healthcare, enterprise workflows, digital agents, and social and economic simulation.
  • Contributions: Open challenges include ontology engineering, dynamic and self-evolving graph systems, graph-native agent operating systems, interoperability, structural evolution, state provenance, and persistent System Evolution.The introduction identifies persistent System Evolution as limited in current practice.

2 Preliminaries

Graph Engineering distinguishes the Individual Agent, which combines a Foundation Model, Agent Harness, and iterative Agent Loop, from the Agent System, which coordinates multiple agents and supporting components through shared resources, environments, and system-level state.

  • Individual Agent: An Individual Agent perceives its environment, reasons and acts, adapts through feedback, and consists primarily of a Foundation Model and Agent Harness.The Foundation Model supplies language understanding, reasoning, planning, and generation, while the Harness provides interfaces for perception and context construction.
  • Individual Agent: The Agent Loop repeatedly integrates perception, reasoning, action, feedback processing, and state updates to organize an agent’s capabilities over time.The Foundation Model determines intrinsic cognition, the Harness determines accessible resources and action spaces, and the Loop determines their continuous use.
  • Agent System: An Agent System extends the individual-agent abstraction into a collection of agents operating through shared resources, external environments, and coordination mechanisms.Its agent team may contain role-specialized agents with different capabilities and tasks, while shared resources include tools, model services, memory, knowledge bases, verifiers, and human support.
  • Agent System: Agent-system coordination mechanisms assign tasks, exchange information, integrate results, resolve conflicts, and handle failures.The external environment supplies observations and feedback and evolves in response to agent actions.
  • Agent System: System state records task progress, shared results, agent availability, resource status, environmental changes, and failure records across the entire system.Unlike an individual agent’s local runtime state, system state describes the operational condition of the whole system at time t.

3 From Model Intelligence to Individual Intelligence

Model Intelligence arises from parameter-level capabilities shaped at inference time by Prompt Engineering and Context Engineering, while Loop Engineering adds bounded, stateful, feedback-driven execution toward persistent goal pursuit. These advances produce capable individual agents, but single-agent organization remains limited by parallel scheduling, specialized verification, and persistent failure recovery.

  • Model Intelligence: Pre-training and Post-training establish the model’s general knowledge, reasoning, and behavioral capabilities at the parameter level.Scaling laws, scalable architectures, and post-training methods progressively strengthen and control this capability base [150] [75] [140] [52] [160] [291].
  • Inference-Time Engineering: Prompt Engineering specifies tasks and organizes reasoning, while Context Engineering acquires and manages task-relevant information without changing model parameters.Together, they determine which capabilities are invoked, how reasoning unfolds, and what information conditions outputs [300] [2].
  • Loop Engineering: Loop Engineering coordinates bounded, stateful, feedback-driven execution by using outcomes to control the task’s subsequent trajectory until evidence is sufficient or continuation is unjustified [131] [234].Its defining feature is continual feedback control rather than simply repeating model calls.
  • Limits of Individual Intelligence: Single-agent loops tend to serialize parallel or interdependent subtasks, hiding scheduling decisions, wasting parallelism, and making failure localization difficult [93] [126].In fault diagnosis, log analysis, failure reproduction, and code inspection may proceed in parallel, but propagated intermediate results can obscure the faulty stage.
  • Limits of Individual Intelligence: Single agents struggle to maintain independent specialist and verifier roles, persistent state, and traceable recovery, creating risks of role confusion, confirmation bias, and unrepaired early errors [88] [155].These weaknesses are especially consequential in long-running web and coding tasks, where small early mistakes can persist until late failure.

4 Graph Engineering: From Individual Intelligence to System Intelligence · 4.1 Overview of Graph Engineering

Graph Engineering addresses the limits of individual intelligence by using explicit graph structures to organize tasks, coordinate heterogeneous components, and manage runtime states. This structure-centered foundation supports system-level organization, coordination, monitoring, recovery, optimization, and continual evolution toward System Intelligence.

  • 4.1 Overview of Graph Engineering: Individual intelligence struggles with parallel and interdependent scheduling, heterogeneous capability integration, and runtime-state maintenance, motivating System Intelligence through complementary components pursuing shared goals [154] [159].
  • 4.1 Overview of Graph Engineering: System Intelligence depends on explicitly representing, constraining, and optimizing relationships among tasks, components, and runtime states rather than merely aggregating agents.
  • 4.1 Overview of Graph Engineering: Graphs coordinate heterogeneous components by representing operational topologies and communication patterns, enabling collaboration according to capabilities and roles [69] [205] [433].
  • 4.1 Overview of Graph Engineering: Graphs organize complex objectives through decomposition, dependency modeling, and workflow refinement into schedulable, executable operations [280].
  • 4.1 Overview of Graph Engineering: Graphs support runtime-state management by recording events, dependencies, and state transitions, converting scattered operational information into persistent execution-state representations.
  • 4.1 Overview of Graph Engineering: Graph Engineering uses graphs as a core substrate for externalizing relationships among tasks, components, and runtime states to support system-level organization, coordination, monitoring, recovery, and optimization.
  • 4.1 Overview of Graph Engineering: System evolution uses execution feedback and state evidence to iteratively improve Graph Engineering structures and enable continual evolution of system intelligence.

4.2 Task Organization: Structuring What to Do

Task Organization converts high-level objectives into explicit subgoals, dependencies, and schedulable graphs, then compiles them into executable workflows that can be optimized and adapted using runtime feedback. This shifts agent design from implicit reasoning and acting toward explicit work structures.

  • Goal Decomposition: Goal Decomposition Graph transforms objectives into explicit, schedulable sub-goal graphs that expose dependencies for later workflow construction and execution adaptation.This supports interdependent actions, parallel branches, verification steps, and dynamic replanning that are difficult to manage through context alone.
  • Workflow Optimization: Explicit dependency graphs enable parallel scheduling, including LLMCompiler’s [156] dataflow DAG and Plan-over-Graph’s [464] dependency-constrained agent schedules.Ready nodes can be dispatched once their upstream dependencies are satisfied.
  • Workflow Optimization: Workflow optimization compiles semantic subgoals into executable workflows over LLM calls, agents, retrieval, tools, memory, aggregators, and verifiers.Graph-based workflow methods search and optimize alternative control flows rather than leaving the operations space unstructured.
  • Workflow Optimization: Static task and workflow graphs remain insufficient for open-ended environments, motivating dynamic adaptation to incorrect intermediate results, tool failures, and ambiguous feedback.DyFlow [363] exemplifies execution-adaptive workflow graphs that respond to real-time execution feedback.
  • Overall Perspective: Task Organization provides a unified graph-based view of task and execution management, specifying what work must be accomplished, how it should be operationalized, and how execution can adapt.Figure 6 summarizes Goal Decomposition and Workflow Optimization as complementary mechanisms for organizing and managing agentic work.

4.3 Agent Coordination: Structuring Who Works

Agent coordination structures heterogeneous agents by modeling their capabilities, organizing responsibilities and work flows, and adapting runtime communication as execution unfolds. Graph representations make these relationships explicit while distinguishing relatively stable team organization from dynamic information exchange and feedback.

  • Overview: Graph-based agent coordination addresses capability modeling, team organization, and runtime communication as three connected functions for coherent multi-agent execution.These functions identify suitable agents, determine responsibilities and work movement, and adapt information exchange during execution.
  • Capability Modeling: Capability graphs assign evolving heterogeneous work to agents using information about skills, resources, permissions, and reliability.Capability mismatches can delay parallel execution and compromise downstream results; persistent, updateable representations address the limitations of task-specific scores, routing policies, and orchestration graphs.
  • Team Organization: Team-organization graphs encode agents, roles, and tasks with typed relations for assignment, delegation, supervision, handoffs, and review.They can combine chains, routing, fan-out/fan-in, and dynamically changing structures to specify participants, responsibilities, and how work moves among them.
  • Communication Modeling: Runtime communication graphs model which agents or human participants exchange information at particular execution points and how feedback changes subsequent actions.Communication supports clarification, review, error correction, and intervention, while feedback can activate or revise later interactions.
  • Communication Modeling: Team organization determines who participates and their responsibilities, whereas communication modeling determines when information and feedback must flow during execution.The distinction separates relatively stable responsibility relations from task- and state-dependent interaction structures.

4.4 Runtime State Management: Structuring How the System Operates

Runtime State Management records consistent execution histories, localizes faults using evidence and dependencies, and enables selective recovery from validated boundaries. Together, these capabilities provide the substrate for monitoring, diagnosis, safe resumption, and continual system evolution.

  • Overview: Runtime State Management converts distributed execution histories into a reliable substrate for monitoring, diagnosis, recovery, and continual system evolution.It complements Task Organization and Agent Coordination by representing what actually happened, not merely what should happen or who should act.
  • State Recording: Runtime State Management records distributed updates about progress, roles, commitments, facts, resources, and external effects in consistent, traceable views.Reliable state requires structured representation, governed updates, scoped visibility, and consistency management, but existing studies lack a unified graph-native implementation.
  • Fault Localization: Fault localization detects deviations, traces effects through dependencies, tests hypothesis–evidence relationships, and identifies execution regions that remain valid for recovery.Temporal or structural links alone do not establish causality; runtime records preserve provenance and support inspection, backtracking, and branch-level diagnosis.
  • Failure Recovery: Failure recovery selects explicit boundaries to retract invalid states, replay computation, compensate external effects, or branch into alternative execution paths.Effective recovery selectively repairs affected regions while accounting for state dependencies and committed external effects, then records the boundary, corrective actions, and resulting state.

4.5 System Evolution

System Evolution enables system intelligence to improve across executions by using runtime evidence to refine task organization, agent coordination, and state management. Validation and rollback ensure reliable improvements persist while failures inform subsequent decisions, creating a closed loop from execution to experience to evolution.

  • Evolution of Task Organization: Task evolution refines objective decomposition, task structures, and workflows when intermediate outcomes or changing conditions invalidate predefined plans.TDAG [362] dynamically decomposes complex tasks and generates specialized agents as execution unfolds; Flow refines subtask allocation.
  • Evolution of Agent Coordination: Agent coordination evolves team structures and communication patterns as task requirements and component capabilities change.SwarmAgentic jointly optimizes agent functionality and collaboration structures through feedback-guided population search; AgentNet supports decentralized coordination.
  • Evolution of Runtime State Management: Runtime state management distills execution histories into reusable knowledge while validating, revising, or rolling back updates to prevent erroneous experience from propagating.This extends state beyond execution and recovery toward accumulating experience for future improvement.
  • System Evolution: System Evolution turns execution outcomes into system-level updates, enabling intelligence to progress from runtime adaptation toward sustained, experience-driven evolution.Open-ended and long-horizon execution generates evidence about effective structures, coordination strategies, and failure modes.

5 Open Challenges and Research Opportunities

Graph Engineering’s transition from task-specific structures to reusable, continuously operating infrastructure raises challenges in capability integration, persistent and cross-graph evolution, graph-native systems support, and privacy and ethics. Addressing these challenges requires explicit relationships among capabilities, coordinated structural change, shared runtimes, and governance over distributed persistent state.

  • Unified Capability Graphs: Unified capability graphs should represent models, tools, skills, memories, data sources, verifiers, and environments with typed relationships, then connect them to task, agent, and runtime-state graphs.Edges may encode dependency, compatibility, composition, substitution, authorization, cost, and reliability, enabling capability selection and task decomposition to interact explicitly.
  • Persistent Evolution: Self-evolving graph systems must convert execution evidence into persistent, reusable structural changes rather than merely adapting a single trajectory.They must identify which dependencies, agent relations, capability assignments, or state structures caused success or failure and assess whether changes generalize beyond the current execution.
  • Cross-Graph Evolution: Task, agent, capability, and state graphs must evolve jointly under shared constraints while preserving provenance, versioning, permissions, and runtime assumptions.Changing one graph can alter required capabilities, invalidate communication relations, or disrupt authorization and execution conditions.
  • Graph-Native Infrastructure: A graph-native agent operating system could unify tasks, agents, capabilities, and runtime states as typed, versioned objects with shared scheduling, storage, recovery, provenance, and permission mechanisms.Linking execution traces to their generating structures would allow historical or counterfactual evaluation of candidate changes and commitment of validated improvements as new graph versions.
  • Privacy and Ethics: Long-horizon coordination of agents, tools, memories, and shared states amplifies privacy and ethical risks through information replication, workflow propagation, persistent retention, unauthorized access, cross-task leakage, and unintended private-attribute inference.These risks arise because system intelligence distributes decisions and execution state across multiple interconnected components.

6 Future Direction: Ontology Engineering for Next-Generation System Intelligence

Ontology Engineering supplies the shared, machine-interpretable semantics needed to connect, validate, reuse, and evolve Graph Engineering structures. Future system intelligence also requires explicit goal formation, grounding, governance, and evaluation beyond end-task success.

  • Motivation: Ontology Engineering establishes shared definitions for system entities, relations, and constraints, addressing inconsistent interpretations across graph views, components, and execution stages.It supports connecting, validating, reusing, and evolving graph structures.
  • System-Level Evaluation: End-task success alone cannot establish System Intelligence; evaluation should separate component capability from system organization, coordination, and state management.Standardized meanings for success, failure, contribution, recovery, consistency, and runtime cost enable comparable traces, structural ablations, and causal analysis.
  • Ontology Structure: A layered ontology should combine core concepts, specialized modules, and domain extensions covering goals, agents, capabilities, evidence, policies, states, and outcomes.This modular structure provides consistent definitions without requiring every system to share identical domain concepts.
  • Goal Formation and Value Alignment: Ontology Engineering can make goal provenance, priority, authorization, completion criteria, and constraints explicit and verifiable, while exposing conflicts and unauthorized modifications.It clarifies normative constraints but cannot determine which values a system should adopt.
  • Shared Semantics and World Grounding: Shared semantics must connect to tool outputs, observations, timestamps, provenance, and validation results because semantic consistency alone does not guarantee factual correctness.Ontology-guided multi-agent systems can dynamically maintain this semantic layer.
  • Governance and Evolution: Future ontologies require provenance checking, consistency validation, impact analysis, version control, compatibility checking, migration, rollback, and runtime-linked constraint enforcement [490].LLMs may propose concepts and relations, but semantic changes should undergo governance before adoption.

7 Benchmarks, Datasets, and Evaluation

Evaluation is organized around three intelligence levels—Model, Individual, and System—whose units progress from bounded outputs to sustained trajectories and coordinated multi-component systems. Graph-engineered systems additionally require structural, operational, and evolutionary evaluation, while current benchmarks remain fragmented and weak on isolating system-level gains.

  • Evaluation Levels: Evaluation units progress from bounded model outputs, to individual-agent trajectories, to the organization and coordination of multiple components and their relations.Model Intelligence evaluates bounded interactions; Individual Intelligence evaluates sustained reasoning, tool use, and environmental feedback; System Intelligence evaluates coherent multi-component organization, maintenance, and improvement.
  • Evaluation Resources: Benchmarks, datasets, and executable environments provide complementary evaluation resources for tasks, reusable artifacts, and observable, modifiable execution state.Table 1 distinguishes benchmarks or protocols (B), datasets or traces (D), and executable environments (E), which may overlap.
  • System Intelligence: System Intelligence benchmarks probe work decomposition, dependency-aware scheduling, hierarchical orchestration, coordination, communication, scalability, self-organization, adaptive workflows, topology, runtime design, and multi-agent optimization.AgentsNet, DBS, MASEval, MAS-PromptBench, and MAFBench extend evaluation toward adaptation, evolution, and alternative multi-agent configurations [102] [72] [14].
  • Evaluation Dimensions: Across all levels, evaluation should report effectiveness, efficiency, and robustness, while graph-engineered systems additionally require structural fidelity, operational correctness, and traceable, controllable evolution.These dimensions distinguish successful outcomes from valid underlying structures, correctly executed graph operations, and governable structural change.
  • Open Gaps: Current evaluation must separate system-level gains from stronger models, larger contexts, tools, retries, or compute, while addressing fragmented resources and weak structural credit assignment.The section identifies fragmented coverage across work organization, coordination, runtime state, and evolution, alongside weak dynamic system-level evaluation.

8 Open-Source Libraries and Engineering Ecosystem

The open-source ecosystem spans Model, Individual, and System Intelligence through reusable infrastructure, agent runtimes, and multi-component orchestration. However, these layers remain fragmented, with limited shared representations, cross-run structural evolution, and typed causal state.

  • Ecosystem scope: Libraries are grouped by primary engineering target because many span levels, translating Model, Individual, and System Intelligence into executable engineering stacks.The survey includes publicly documented reusable projects whose abstractions directly affect intelligent-system construction or execution.
  • Model Intelligence: Model Intelligence infrastructure covers model execution, distributed pretraining, post-training, and scalable reinforcement-learning pipelines [323].Transformers, Megatron Core, LLaMA-Factory, verl, and slime represent these engineering concerns.
  • Individual Intelligence: Individual Intelligence libraries organize model–tool loops with middleware, permissions, validation, sessions, state, context workflows, persistent memory, temporal knowledge, protocols, and visual composition [296].Representative systems include LangChain, OpenAI Agents SDK, Claude Agent SDK, Pydantic AI, LlamaIndex Workflows, Haystack, Burr, Letta, Graphiti, MCP, Langflow, and Dify.
  • System Intelligence: System Intelligence libraries make task, agent, executor, and shared-state relationships explicit through graph execution, messaging, role organization, event flows, workflow engines, and topology optimization [182].LangGraph, Microsoft Agent Framework, Google ADK, AutoGen, CrewAI, CAMEL, Mastra, and GPTSwarm exemplify these approaches; AutoGen is retained for historical influence despite maintenance mode, while Microsoft recommends Agent Framework for new projects.
  • Open limitations: The ecosystem lacks common representations for tools, messages, workflows, events, state, dependencies, capabilities, authority, and organization; current dynamism rarely enables systematic cross-run evolution.State is fragmented across checkpoints, memories, snapshots, histories, logs, and temporal stores, while observability seldom captures typed causal links from observations and failures to later improvements.

9 Applications of Graph Engineering

Graph Engineering applications are organized by domain, focusing on how work organization, agent relations, and runtime state affect execution. Across software, science, healthcare, and enterprise systems, applications increasingly move from individual agents toward structured multi-agent systems, while full graph engineering remains an emerging goal.

  • Application framework: Applications are classified by domain because structural decisions affect real work, with intelligence level and Graph Engineering focus used as cross-domain descriptors.The review includes research prototypes and deployed systems when changing workflows, agent relations, or runtime state changes execution; retrieval-only knowledge graphs are excluded.
  • Software engineering: Software engineering most clearly exhibits the transition to System Intelligence through specialist roles, repository interfaces, persistent event streams, parallel agents, worktrees, checkpoints, and shared task state.MetaGPT and ChatDev use predefined stages and roles, while SWE-agent emphasizes agent–repository interfaces [418]; newer systems expose increasingly explicit parallel coordination.
  • Scientific discovery: Scientific systems organize hypotheses, evidence, tools, experiments, and researchers through coordinated specialists, supervisory workflows, physical validation, and feedback that updates subsequent hypotheses.Co-Scientist assigns generation, critique, ranking, and refinement to specialized agents, while Robin links literature, analysis, and laboratory evidence.
  • Healthcare: Healthcare requires coordinated specialization, longitudinal state, authority, and evidence provenance, with systems progressing from multidisciplinary consultation toward evolving care plans grounded in patient history and guidelines.DeepRare coordinates phenotype, genotype, retrieval, and analysis agents while accumulating traceable evidence; AMIE maintains conversational and management-reasoning state across visits.
  • Cross-domain maturity: Across domains, Work Organization, Agent Team, and Runtime State structures are increasingly common, but full Graph Engineering still requires observable, controllable, and consistently evolving structures.The review distinguishes graph-structured systems from graph-engineered systems because contemporary structures are often manually selected or fixed before execution; simulated emergence also requires calibration before supporting real-world causal claims.

10 Conclusion

The conclusion argues that heterogeneous, interdependent, long-horizon tasks expose the limits of individual agents and require System Intelligence organized through Graph Engineering. Graph abstractions make work, agent, and runtime-state relations explicit and adaptable while leaving open challenges in alignment, governance, evaluation, privacy, and safe self-improvement.

  • 10 Conclusion: Graph Engineering organizes system intelligence through three complementary views: work organization, agent coordination, and runtime state management.These graph abstractions represent tasks, agents, and states while structuring system-level relations.
  • 10 Conclusion: Graphs can schedule work, bind capabilities, trace execution, localize failures, and enable controlled evolution across agent systems.The survey presents these functions as evidence that graphs are operational and adaptable, rather than merely representational.
  • 10 Conclusion: System-level intelligence depends less on adding models or agents than on explicitly organizing their relations for complex tasks.Individual-agent loops struggle with parallel work, specialized expertise, independent verification, and persistent state as tasks become more heterogeneous, interdependent, and long-horizon.
  • 10 Conclusion: Graph Engineering remains an emerging field facing open challenges in semantic alignment, graph governance, evaluation, privacy, and safe self-improvement.The survey positions graph-native infrastructure as a direction for more scalable, controllable, and evolvable agent systems.

11 Appendix

Existing surveys cover agent capabilities, engineering infrastructure, and system-level organization, while Graph Engineering distinguishes itself by treating explicit graphs as the organizational substrate of intelligent systems. It integrates task organization, agent coordination, runtime state, and system evolution into a coupled framework.

  • Existing surveys examine agent capabilities and graph-enhanced planning, memory, tool use, reasoning, execution, and multi-agent interaction [20] [218].
  • Other surveys emphasize the infrastructure and system organization supporting agents, including harnesses, execution loops, persistent state, orchestration, failure recovery, and self-evolution [284].
  • Unlike graph–agent approaches that enhance particular capabilities, Graph Engineering couples graph structures so changes in tasks, agents, and runtime evidence can revise the system.Dynamic graph transformation is closely related but primarily focuses on persistent agent evolution and rewriting memories, tools, skills, workflows, and relations.
  • Graph Engineering treats explicit graphs as the organizational substrate for task organization, agent coordination, runtime state management, and system evolution.These structures represent goals, dependencies, workflows, capabilities, responsibilities, communication, execution evidence, failures, and recovery dependencies.
  • Graph Engineering extends Prompt, Context, Harness, and Loop Engineering by addressing the organization of capabilities, information, execution infrastructure, and feedback-driven control at system level.
Loading 2608.21156v1…