Graph Engineering Restructures Agent Systems: From Harness to Ontology

From Individual to System Intelligence

The article summarizes the 2026 survey Graph Engineering in the Era of LLM Agents: From Individual Intelligence to System Intelligence by Yuyuan Feng et al. (arXiv:2608.21156v2). It argues that agent engineering has progressed through Prompt Engineering, Context Engineering, Harness Engineering, and Loop Engineering, turning models into autonomous units that interact with environments. However, as tasks grow complex, the bottleneck shifts from single-agent capabilities to how multiple intelligent components collaborate on long-running, parallel, dependent tasks requiring independent verification and persistent state.

Three Levels of Intelligence

Model Intelligence : pre-training, post-training, Prompt/Context Engineering.

Individual Intelligence : adds Harness (tools, memory, skills, execution environment) and Loop (perception–reasoning–action–feedback–state update). Formalized as Loop(Foundation Model, Harness; Runtime State).

System Intelligence : organizes multiple agents via explicit graph structures — Graph Engineering.

Task Organization: Explicit DAGs Replace Implicit Plans

Instead of keeping plans only in context, systems now externalize them as dynamic graphs where nodes are sub-tasks and edges express dependencies, ordering, concurrency, and verification constraints.

LLMCompiler compiles function-calling plans into dataflow DAGs; ready nodes execute in parallel.

Plan-over-Graph generates parallel agent schedules directly from task dependency graphs.

TDAG and Flow allow runtime graph modification: splitting tasks, adjusting dependencies, spawning agents based on intermediate results.

GPTSwarm, ADAS, AutoFlow, AFlow treat agent workflows as search/optimization objects.

DyFlow, EvoFlow, QualityFlow use runtime feedback to continue, clarify, debug, rollback, or rewrite plans.

The result is a hybrid: models propose/modify structure; runtime constrains, schedules, verifies, and records execution.

Runtime State Management: Beyond Memory

State recording must capture evidence, provenance, and version for every transition — not just "memory".

Magentic-One maintains Task Ledger and Progress Ledger.

Graph of States uses structured belief states, causal graphs, and state-machine constraints.

PatchBoard validates agent-generated patches against schema, role permissions, and runtime invariants before commit.

MemTX distinguishes tentative writes from transactional belief commits, preserving provenance and repair semantics.

The survey identifies a proposal–validation–commit boundary: observed/proposed changes must be validated before becoming authoritative. Concurrency requires isolation, causal ordering, conflict resolution; append-only history and event sourcing enable reconstruction, replay, and branching. A unified graph-native transaction implementation remains an open problem.

Fault Localization and Recovery

Errors often surface far from their origin. Systems must retain actor, transition, dependency, and validation evidence to hypothesize root causes.

MAGE uses hierarchical state trees to locate faulty branches.

Who & When attributes failures to responsible agents and steps.

MAST classifies failures into system design, agent collaboration, and task verification.

TraceElephant incorporates execution traces, intermediate context, and full inputs.

Recovery demands a recovery boundary : which states to undo, which internal computations to replay, which external side-effects need compensation (since they cannot be rolled back).

Event Sourcing, AgentGit, Shepherd support replay/rollback/branching.

DART recovers to semantically valid boundaries.

SagaLLM, RAC combine checkpoints with compensation.

Atomix coordinates reversible and irreversible external operations.

Unlike traditional systems, post-recovery the model may need to re-plan subsequent tasks rather than mechanically resume.

Agent Coordination: Toward a Control Plane

Coordination splits into capability modeling, team organization, and communication.

Capability Modeling makes skills, resources, models, permissions, reliability, and task-fit explicit as typed graph nodes/edges (Agent, Skill, Tool, Model). Enables capability-aware routing when conditions change.

Examples: DyLAN estimates candidate contributions; MasRouter selects collaboration mode/role/model by difficulty/cost; SkillGraph guides communication topology via skill relations; MaAS searches multi-agent structures in an Agentic Supernet.

Team Organization patterns: chain (MetaGPT, ChatDev), orchestrator-based (Magentic-One), parallel aggregation (Mixture-of-Agents, MacNet), dynamic restructuring (Puppeteer, AgentNet). Communication graphs must balance information value, invocation cost, and error propagation risk.

The survey proposes a Graph-Native Agent Operating System that elevates Task, Agent, Capability, and Runtime State to first-class objects unified by a typed, versioned graph. Shared runtime services would include graph scheduling, capability discovery, state storage, event/provenance logging, structural transactions, permission enforcement, checkpoint/replay/rollback, and graph-level observability.

Precursors: MCP (external capability access), LangGraph (explicit workflow/state), AIOS (OS-level scheduling, context, memory, storage, tool, access control).

These still lack a common structural substrate for organizing complete agent systems; the emerging control plane treats models, tools, skills, and specialized agents as heterogeneous execution resources.

System Evolution and Ontology Engineering

Future systems will feed runtime success/failure/structural adjustments back into task graphs, team structures, capability relations, and state graphs — constrained by provenance, versioning, validation, replay, and rollback. Ontology Engineering aims to establish shared entity, relation, type, and constraint semantics so that concepts like "task complete", "evidence sufficient", "state valid", "permission legal" are not left to individual agent interpretation.

The next competitive frontier: not just stronger models or more tools, but organizing probabilistic intelligent components into explainable, verifiable, recoverable, continuously evolving yet governed production systems. Graph Engineering provides the system structure that lets models generate intelligence while the system ensures stable collaboration.

Source: Yuyuan Feng et al., "Graph Engineering in the Era of LLM Agents: From Individual Intelligence to System Intelligence", arXiv:2608.21156v2, 2026-08-26.