Breaking Down Agent Engineering: Graph, Loop, and Harness – A Full Implementation Guide

1. Real Pain Points in Repository Security Audits

In 2026, developers performing full‑repo risk scans with traditional single‑Loop agents face invisible processes hidden inside conversational context, making it impossible to distinguish parallel scan nodes, failure‑recovery paths, and human‑approval boundaries. Time‑outs in authentication or logging modules trigger global retries, and lack of unified controls over permissions, time‑outs, and concurrency leads to over‑privileged changes and token budget overruns.

2. Core Concepts Clarified

2.1 Loop Engineering – Self‑Closed Iteration

Loop builds a "execute → verify → fix → retry" cycle, analogous to a basic while loop, solving how to iteratively correct a failed task and when to consider it converged. It suits single‑goal, linear tasks such as fixing a file bug, checking an API endpoint, or small‑scale document validation. Its limitation is inability to handle multiple agents, branching dependencies, or complex failure‑recovery paths because all logic is coupled in one context.

2.2 Graph Engineering – Explicit Topology

Graph models the entire workflow as nodes and edges. Nodes can host agents, code functions, human approvals, or tool calls; edges define data flow, conditional branches, parallel merges, and failure‑recovery loops, supporting cyclic directed graphs. This makes task dependencies, parallel scheduling, branch routing, and failure‑recovery visualizable and auditable. Industry examples include LangGraph, AutoGen GraphFlow, and Claude Code Dynamic Workflows.

2.3 Harness – Runtime Control Layer

Harness sits beneath the model and orchestration, providing a standardized execution base. It does not participate in task flow logic but enforces safety through permission whitelists, sandbox isolation, concurrency limits, time‑outs, idempotent keys, audit logs, human‑approval gates, token budgeting, and fault‑rollback mechanisms.

3. From Implicit to Explicit Processes

3.1 Legacy Single‑Loop Mode

Early agents made scheduling decisions dynamically within model context, leading to three hard problems: unpredictable dependencies, difficult fault localisation, and uncontrolled resource consumption.

3.2 New Graph‑Based Mode

Claude Code Dynamic Workflows (v2.1.154+, released May 2026) generates JavaScript orchestration scripts that run independently of the conversation window. Official limits (July 2026) cap a workflow at 1,000 sub‑agents, 16 concurrent agents, and trigger a Large workflow warning beyond 25 agents or 1.5 M tokens. All scripts are persisted for versioning, audit, and replay.

3.3 DAG vs. Agent Graph

Traditional DAG tools like Airflow enforce acyclic structures suitable for batch jobs, lacking failure‑recovery loops. Agent graphs require stateful directed graphs that natively support back‑edges, human‑involved branches, and partial failure degradation.

4. Core Graph Engineering Practices

4.1 Data Edges – Contracted I/O

Each node must declare structured inputs and outputs. Example for a security‑audit node: input repo (commit, target, paths, policy_version); output findings[], evidence[], status. Failure types are retryable, terminal, or needs_human. Runtime constraints include timeout, max_attempts, and an idempotency_key.

4.2 Permission Edges – Prevent Over‑Privileged Actions

When flow moves from read‑only scanning to write‑back fixing, permission edges enforce read‑only worktrees for scans, sandboxed writes for fixes, and mandatory human gates for high‑risk actions such as database migrations or key changes.

4.3 Validation Edges – Separate Execution and Evaluation

Deterministic checks (compilers, unit tests, static rules) run before any model involvement. Semantic validation is delegated to a dedicated verification agent that returns detailed evidence on failure rather than a vague “result not met”.

4.4 Recovery Edges – Fault‑Tolerant Strategies

Four aggregation rules govern parallel node failures: (1) all‑success gating, (2) minimum‑success gating, (3) timeout degradation, and (4) critical‑failure termination. Supporting mechanisms include checkpoint persistence, retry limits, and compensating rollbacks.

5. When to Use Graph vs. Loop

Graph is appropriate when a workflow has multiple parallel or branching dependencies and each stage produces independent verifiable results (e.g., full‑repo audits, large code migrations, multi‑module testing, high‑risk releases). Loop suffices for simple linear tasks, small‑scale fixes, short‑interval checks, or exploratory research where the dependency graph is not yet stable.

Common pitfalls: assuming edges are free (they incur serialization, state storage, scheduling, and token costs), treating parallel agents as independent validators (risking consensus bias), and allowing models to freely modify production topologies without pre‑approved templates and permission gates.

6. Practical Deployment Blueprint

6.1 Narrow Graph for PR Audits

Read code diff → identify affected modules → run unit tests, static checks, security scans in parallel → aggregate risk evidence → independent verification node → human review. Failure at verification loops back to the fix node with a maximum of two iterations.

6.2 Five Mandatory Hard Rules

Standardize contracts for every node (inputs, outputs, time‑outs, retry limits, idempotency).

Reuse existing CI deterministic checks; do not replace them with agents.

Isolate fix nodes in sandboxed environments without production credentials.

Enforce failure‑evidence on back‑edges and cap iterations, token usage, and execution time.

Retain manual approval for merge actions and archive scripts, code snapshots, and logs for audit.

6.3 Pre‑Release Fault‑Injection Checklist

Validate each node’s I/O schema and failure type.

Ensure edges transmit structured data, not free‑form text.

Confirm parallel merge rules and cancellation policies.

Verify iteration limits and convergence criteria.

Check that parallel nodes share a common code snapshot and that writes are idempotent and rollback‑able.

Prefer low‑cost code processing over large‑model parsing where possible.

Place human gates on permission‑escalation nodes to guarantee reproducible audits.

7. Core Conclusions

The claim that “Loop is dead, Graph is alive” is oversimplified; the three layers are complementary. Graph provides visualizable, schedulable, auditable topology for multi‑agent collaboration; Loop supplies iterative convergence within Graph’s back‑edges; Harness guarantees safe execution through unified permission and resource controls. The 2026 evolution of Agent engineering turns hidden conversational branching into explicit, observable graph scripts, enabling production‑grade AI workflows to be managed, audited, and safely deployed.

Practical advice: start with lightweight narrow graphs, expand only after stability, choose Loop for simple linear tasks, Graph for complex branching, and always pair both with Harness for security and resource governance.