Graph Engineering: Scaling AI Agents with Verification

The Shift from Loop to Graph Engineering

Loop engineering relies on a single agent following a linear path, where each step must wait for the previous one to complete and verify. Graph engineering improves this by splitting a task into smaller, parallelized nodes, each handled by its own agent. This structure significantly increases throughput and allows for cost optimization by assigning cheaper models (like Haiku) to simpler nodes and more capable models (like Opus) to complex tasks. However, graphs consume significantly more tokens than linear loops, and a single failure in a node can corrupt the entire output because the final result often obscures the source of the error.

Implementing Multi-Angle Verification

To maintain reliability in a graph, verification must be decoupled from the agent that performed the work. The author recommends building custom skills using the Skill Creator plugin in Claude Code to implement three types of verification:

• Standalone Skills: Deep, comprehensive reviews run manually after a task is complete, such as a security-focused code audit.
• Embedded Skills: Automated checks that fire during the workflow, such as visual regression testing using Chrome Headless Shell instead of a full browser to save memory and time.
• Chained Orchestration: An orchestrator agent that triggers multiple specialized review skills (e.g., Code Review, Simplify, Verify, and Design) simultaneously across different context windows, aggregating findings into a single report.

Avoiding Verification Pitfalls

Using the same agent to build and review code creates a bias that misses errors. The author suggests using the -p flag in Claude Code to launch a fresh, isolated session for a "Second Opinion" review. Furthermore, model selection for verification is critical; while cheaper models are faster, they may flag false positives on intentional design choices, leading to unnecessary token burn and wasted compute as agents attempt to fix non-existent issues. Verification should be treated as a specialized node in the graph, where the cost of a high-intelligence model is justified by the prevention of cascading failures.