One-sentence Summary

Researchers from The Hong Kong Polytechnic University, Nanyang Technological University, and other institutions introduce Graph Engineering, a paradigm for building LLM agent systems that constructs explicit, dynamic, and evolving graph structures of tasks, agents, and system states to organize heterogeneous agents into System Intelligence beyond individual optimization, enabling orchestration, dynamic modeling, and scalable evolution.

Key Contributions

• The paper introduces Graph Engineering, a structure-centered paradigm that uses explicit, dynamic graph abstractions to represent tasks, agents, and system states. This enables organizing complex objectives and coordinating heterogeneous agents beyond individual agent optimization.
• It organizes the surveyed literature into three complementary graph views: work organization, agent coordination, and runtime state management. These graph-based abstractions support scheduling, capability binding, execution tracing, failure localization, and controlled system evolution.
• The survey identifies open challenges in semantic alignment, graph governance, evaluation, privacy, and safe self-improvement. It also provides a curated collection of resources to guide future work toward graph-native infrastructure for system intelligence.

Introduction

Large language models have become foundational to intelligent systems, but model-level capability and individual agent loops are not enough for complex real-world tasks that require heterogeneous expertise, parallel execution, independent verification, and persistent long-horizon state. Prompt, context, harness, and loop engineering improve individual agents, yet they still force interdependent work into a shared context and a mostly sequential control flow, creating bottlenecks in scheduling, role separation, and failure recovery. Prior multi-agent approaches can also remain limited because they may lack clear work organization, coordination mechanisms, and consistent runtime state management. The authors introduce Graph Engineering as a structure-centered paradigm that uses graph abstractions to explicitly represent and govern task organization, agent coordination, and runtime state evolution, aiming to support system-level intelligence rather than merely adding more capable agents.

Dataset

The authors describe the dataset and evaluation section as a conceptual classification of resources rather than a concrete dataset inventory.

• Composition and sources: The section distinguishes three resource types: benchmarks, datasets, and executable environments. Benchmarks define tasks, evaluation protocols, and scoring rules. Datasets provide reusable instances, annotations, graphs, interaction records, or execution traces. Environments expose executable state that an agent can observe and modify.
• Key details for each subset: No concrete dataset sizes, sources, or filtering rules are provided. The paper only notes that resources are labeled in Table 1 as B for benchmark, D for dataset, and E for executable environment, and that these forms are not mutually exclusive.
• How the paper uses the data: Evaluation resources are organized around three intelligence levels: Model Intelligence, Individual Intelligence, and System Intelligence. Model Intelligence concerns bounded model interactions; Individual Intelligence concerns a single autonomous agent combining reasoning with external capabilities over a sustained trajectory; System Intelligence concerns multiple coordinated intelligent components.
• Processing and metadata construction: The section does not describe dataset preprocessing, cropping, splits, or mixture ratios. Its main metadata scheme is the three-level intelligence taxonomy plus the B/D/E resource type labels from Table 1.

Method

The authors propose a hierarchical framework for intelligent systems, evolving from individual agents to graph-based system intelligence. An Individual Agent is defined as an autonomous entity $\mathcal{A}_i = \mathrm{Loop}(\mathcal{F}_i, \mathcal{H}_i; s_i^t)$Ai​=Loop(Fi​,Hi​;sit​), where the Foundation Model $\mathcal{F}_i$Fi​ provides cognitive capabilities and the Agent Harness $\mathcal{H}_i$Hi​ manages external resources.

The transition from Model Intelligence to Individual Intelligence is achieved through specific engineering layers. Foundation models establish parametric capabilities via pre-training and post-training. Prompt and Context Engineering condition these capabilities for specific tasks. Harness Engineering extends the model by connecting it to persistent memory, tools, and execution environments. Loop Engineering then organizes these resources into iterative cycles of perception, planning, action, and feedback, enabling sustained goal-directed behavior.

To address the limitations of individual agents in managing parallel and interdependent tasks, the authors introduce Graph Engineering. This approach uses graph structures to explicitly represent and optimize the relationships among tasks, components, and runtime states, forming the basis of System Intelligence.

The Graph Engineering framework comprises three core modules: Task Organization, Agent Coordination, and Runtime State Management.

Task Organization structures high-level objectives into executable workflows.

Goal Decomposition breaks down complex objectives into explicit subtasks and dependency graphs, allowing for dependency-aware scheduling and dynamic refinement as intermediate results emerge. Workflow Optimization compiles these subgoals into executable operators and control flows. This process involves searching and optimizing the workflow structure itself and adapting the execution path based on runtime feedback, ensuring the system can revise both the workflow and remaining subgoals dynamically.

Agent Coordination manages the collaboration of heterogeneous agents.

Agent Capability Modeling maps agents to their specific skills, tool access, and reliability profiles. Agent Team Organization arranges these agents into collaboration structures, such as sequential chains, routing topologies, or fan-out and fan-in patterns, which can dynamically reconfigure based on context. Multi-agent Communication governs information flow, optimizing the communication topology by removing inefficient links and evolving interaction patterns across execution rounds.

Runtime State Management ensures system reliability by tracking execution and handling failures.

State Recording maintains traceable runtime views and role bindings, enforcing governed updates where changes are validated before commitment. Fault Localization detects anomalies and traces execution deviations to identify the root cause and the first invalid state. Failure Recovery utilizes this diagnosis to establish a recovery boundary, preserving valid work while selectively re-executing or repairing affected regions to safely resume the system.

Experiment

The evaluation framework organizes resources around three intelligence levels: Model Intelligence assesses bounded model outputs, Individual Intelligence evaluates agent trajectories over sustained interactions, and System Intelligence examines multi-component organization and evolution. Benchmarks and applications reveal that while work organization and agent team structures are increasingly common, persistent system evolution and structural credit assignment remain underexplored. Across domains, the central challenge is moving from manually fixed structures to graph-engineered systems where structural changes are observable, controllable, and transferable across tasks and time.

The listed Model Intelligence resources are benchmarks and datasets that target bounded model interactions such as broad knowledge, graduate-level scientific reasoning, NP-complete problem solving, Olympiad mathematics, and instruction following. Several entries emphasize objective or formal verification, and one entry focuses on evolving multi-turn dialogues with constraint tracking and failure recovery. The accompanying discussion frames these resources within a broader taxonomy that also covers Individual Intelligence, System Intelligence, and executable environments. All listed Model Intelligence entries are typed as B/D, meaning they serve as benchmarks or evaluation protocols combined with datasets, annotations, or traces. Verifiability is a recurring emphasis: OlymMATH offers formal verification, NPPC offers automatically verifiable reasoning, and IFEval uses objectively checkable constraints. EvolIF extends evaluation beyond single-turn responses to evolving multi-turn dialogues with constraint tracking and failure recovery.

Open-source libraries for intelligent systems are organized by their primary engineering target across model, individual, and system intelligence. Model intelligence tools span distributed pretraining, post-training, reinforcement learning, and serving, with recent projects integrating training and rollout generation. The broader ecosystem is adopting agent team structures and runtime state management, but persistent structural evolution remains uncommon. Model intelligence libraries cover the full lifecycle from distributed pretraining (Megatron Core) to high-throughput serving (vLLM), predominantly under Apache-2.0 licensing. Projects like verl and slime merge training with rollout serving, showing a practical convergence of model training and inference for reinforcement learning. Across application domains, work organization and agent team engineering are widely adopted, but systems rarely revise their organizational structure permanently from accumulated evidence.

Across application domains, Work Organization and Agent Team Engineering are already common, while Runtime State Management is becoming more visible through event streams, checkpoints, and shared task boards. Persistent System Evolution remains rare, with most systems adapting within fixed structures rather than revising them from accumulated evidence. Software coding agents illustrate a practical transition from Individual to System Intelligence, but adding agents alone does not guarantee System Intelligence without careful decomposition, responsibility assignment, and state sharing. Work Organization and Agent Team Engineering appear in most representative applications, from end-to-end software production to multi-agent coding systems. Runtime State Management is increasingly visible through agent-computer interfaces, event streams, persistent task boards, and reproducible execution histories. Persistent System Evolution is absent from the listed systems, which adapt within predefined organizational structures rather than permanently revising them from evidence. Software engineering systems such as OpenHands, Codex, and Claude Code span Individual and System Intelligence, employing parallel agents, subagents, and shared runtime state. The application evidence supports a distinction between being graph-structured and being graph-engineered, where the latter requires structural objectives, graph-level observability, controlled mutation, and evidence of persistent improvement.

The evaluation landscape spans benchmarks for bounded model interactions with a strong emphasis on verifiability, including formal verification and objectively checkable constraints, while open-source libraries increasingly merge training and inference for reinforcement learning. Across application domains, work organization and agent team engineering are widely adopted, and runtime state management is gaining visibility through event streams and shared task boards. However, persistent system evolution remains rare, as most systems adapt within fixed structures rather than permanently revising their organization from accumulated evidence. The evidence supports a distinction between merely being graph-structured and being graph-engineered, where the latter requires structural objectives, graph-level observability, controlled mutation, and evidence of persistent improvement.