Make Your AI Agents Predictable With Graph Engineering - Zachary Blumenfeld, Neo4j
Summary
Graph engineering is defined as the practice of designing agent work as an explicit graph, where nodes perform work and edges route state. This approach moves beyond simple prompt or context engineering by providing agents with a structured map of logic. The core benefits—predictability, governance, and portability—are achieved by compiling procedural knowledge (skills) and past decision traces into graph-shaped artifacts. This allows agents to execute complex, multi-step processes in a deterministic, auditable manner, significantly improving performance and reducing costs compared to unstructured methods.
Key takeaways
-
Definition and Types of Graphs
Graph engineering involves designing agent work as an explicit graph (nodes do work, edges route state). Three types are discussed: general execution graphs (workflow graphs), context graphs (decision traces connecting data), and procedural graphs (skills or procedures modeled as graphs).
-
Core Benefits of Graph Engineering
5:04
Graph structures provide three key benefits for agents: 1) Predictability (constraining the agent's path for accurate results); 2) Governance (allowing control, auditing, and understanding of agent actions); and 3) Portability (storing the graph structure in a knowledge layer for use across different runtimes).
-
Compiling Skills and Memory
10:53
Procedural knowledge (skills) can be compiled into a graph structure by taking written material (e.g., a skill MD file), scripts, and references, and mapping them into nodes and routing points. Similarly, context graphs (past decision traces) can be distilled into a skill, retaining provenance and governance over time.
-
Demo: Loan Approval Process Improvement
17:27
The speaker demonstrated compiling a complex, poorly governed loan approval task into a graph-shaped skill. This process, which involved multiple policy checks and decision models (like Jev or TypeSafe), drastically reduced execution time (from 7.5 minutes to under 2 minutes) and cost by enforcing a deterministic, auditable path.
Technical details
-
Graph Structure and Components
442s
Graph engineering uses nodes to represent work and edges to route state. The architecture involves a knowledge layer (e.g., Neo4j) sitting between systems of record (DataStax, BigQuery, Snowflake) and the agentic brain/memory tools.
-
Agent Memory and Context Graphs
603s
Context graphs manage different types of memory: short-term (conversation history), long-term (extracted entities), and reasoning/decision trees. This allows agents to maintain a comprehensive, traceable record of decisions.
-
Skill Compilation and Determinism
A skill is compiled into a graph-shaped artifact (YAML format) that contains scripts, assets, and source documentation. This deterministic format allows the skill to be ported across various agent harnesses and runtimes, ensuring the agent follows an exact, predefined path.
-
Observability and Governance
By persisting runs within the graph, users gain observability. It is possible to track all steps, identify which decision branches were taken or skipped, and audit the entire process history, which is crucial for compliance and governance.
Mentioned resources
- Neo4j Agent Memory Service
- Aura
Channel & topics
Watch on YouTube · Back to latest
This independent, AI-assisted summary is provided for commentary and informational purposes. It may contain errors or omit important context. Please watch the original video for the creator's complete presentation. Video, thumbnail, and related copyrights belong to their respective owners.