Why Loop Engineering Is Obsolete: Master Graph Engineering in One Guide

Prompt → Loop → Graph

Early agents used a single instruction, e.g.

请分析这份报告，并给出三个主要结论。

. Loop agents added a feedback cycle such as

分析任务 → 调用工具 → 查看结果 → 发现问题 → 调整方案 → 再次执行

, but the whole task remained inside one agent. Graph Engineering asks which sub‑tasks truly depend on each other and arranges them as a directed graph, exposing parallelism, conditional branches and aggregation.

What Graph Engineering Is

A graph treats a complex task like a project team. Each node has a single responsibility, knows what it receives, what it must produce, and when it is considered complete. Edges represent real data dependencies, not merely sequential ordering. The core question shifts from “first step, second step” to “which tasks really need the results of previous tasks?”.

Why Linear Agents Are Inefficient

In a competitive‑analysis workflow the naïve linear pipeline writes:

先研究竞品 A 再研究竞品 B 再研究竞品 C 然后比较三个产品 最后写成报告

The three research sub‑tasks are independent and can run concurrently, but the linear design forces them into a queue, increasing latency and cost.

Problems of a Single Agent

Independent tasks are forced into a sequential queue, wasting time and causing interference.

The same agent validates its own output, leading to “consistent but wrong” results.

Accumulating intermediate results fills the prompt context, causing early constraints to be forgotten.

A failure in any node halts the downstream work, even when other branches could still produce value.

Seven Actions to Transform a Linear Agent into a Graph

One clear responsibility per node – split a monolithic node such as “查资料 判断真假 生成观点 撰写全文 检查引用” into distinct nodes:

节点 A：搜集资料
节点 B：提取事实
节点 C：检查事实
节点 D：组织观点
节点 E：完成写作
节点 F：检查引用

Do not queue independent tasks – run parallel research directions (market size, policy, technology, etc.) and merge results later.

Only wait when all branches are needed – if each file can be tested immediately after migration, start testing without waiting for the other files.

Route different problems differently – classify code changes by risk and send them through separate verification paths, e.g.

小型文档修改 → 简单检查
普通功能修改 → 常规审查
认证与支付修改 → 深度安全审查
数据库迁移 → 迁移检查 + 回滚检查

Add hard validation gates – insert checkpoints such as compile → automated test → security scan, which aim to falsify upstream results.

Localize failure handling – define per‑node policies (retry, skip, downgrade, abort) instead of a single global policy.

Set explicit loop stop conditions – specify success criteria, maximum iterations, stagnation limits, budget caps and hand‑off to humans, e.g.

测试全部通过 → 停止
连续两轮没有减少错误 → 停止
已经修改五轮 → 停止
出现架构冲突 → 转人工

Hand‑off Between Nodes

A node should output a structured contract rather than free‑form text. Example fields:

文件位置, 问题描述, 相关证据, 风险等级, 判断信心, 验证状态, 建议动作

This stable schema prevents downstream nodes from breaking when upstream implementations change.

Graphs Must Touch Reality

Purely model‑internal loops can converge on the same mistaken data. Real‑world anchors such as actual test results, compiler output, database state, or human approval are required for trustworthy conclusions.

Claude Code Dynamic Workflows as a Graph Tool

Claude can generate a JavaScript orchestration script that defines nodes, parallel pipelines, conditional routing, loops and aggregation. The mapping between graph concepts and Dynamic Workflows is:

Node → sub‑agent

Parallel branch → pipeline() Data hand‑off → JavaScript variable

Conditional routing → if / filter / branch

Loop → repeated execution with stop condition

Aggregation node → agent that de‑duplicates, sorts and integrates results

Graph executor → Workflow Runtime

Graph generator → Claude

Dynamic Workflows separate planning (the generated JavaScript) from execution (sub‑agents). Each sub‑agent still consumes tokens, so start with a small scope.

Full Graph Example: Industry Research Report

Define research scope (object, time range, audience, core questions).

Split into independent directions: market size, policy, technology, key players, user feedback.

Each direction produces a structured output containing core findings, sources, dates, evidence and confidence.

Fact‑checking node validates numbers, dates, citations and flags contradictions.

Conflicts are routed to a dedicated analysis node (e.g., reconcile differing market estimates).

Chapter‑writing nodes draft sections (overview, drivers, competition, opportunities, risks, outlook).

Final validation node checks reality anchors (source availability, fact vs. opinion, citation validity, missing counter‑evidence) and optionally routes to human reviewers for high‑impact domains.

The result is not a single monolithic report but a traceable pipeline that explains where each conclusion originates, which checks it passed and what uncertainties remain.

When Graph Engineering Is Worth It

Use a graph when a task exhibits one or more of the following:

Multiple independent sub‑tasks

Many files or information sources

Different inputs require different processing paths

Critical conclusions need multi‑layer validation

Partial‑branch failures should not abort the whole job

Task scale is unknown at start

The pipeline is repeatable

Cost, latency or failure‑location analysis matters

Typical examples: large‑scale code review, batch migration, deep research reports, multi‑source fact‑checking, periodic market monitoring, complex data analysis, large‑scale content moderation.

When Not to Use Graphs

Simple one‑shot tasks (short rewrite, single classification, fixed‑format extraction) do not benefit from graph overhead. If a task has only two or three steps and the later step truly needs the full output of the previous step, a linear flow is simpler.

Getting Started with Your First Agent Graph

Answer these five questions to produce a minimal viable graph:

What is the final deliverable?

Which pieces of work can be performed independently?

What exact data must be handed off between nodes?

Where are hard validation checkpoints required?

How should failures be handled and when should the process stop?

Conclusion

Prompt Engineering optimizes a single model call. Loop Engineering adds iterative action. Graph Engineering orchestrates multiple models, tools and checks into a structured system, turning the design focus from “how should one agent think?” to “where should we split, parallelize, aggregate, validate, ignore, abort or stop?”.