# 别再让 Agent 每走一步都去问大模型

> 把贷款案件 Agent 拆成规划、DAG 校验、执行、评审和重规划后，效果可以度量；流程固定时，手写工作流就够了。

原文: https://fdetimes.net/zh/guides/planner-executor-agent-dag-critic-loop/

在经典的 ReAct 中，LLM 每次只规划一个子问题。三步就能完成的任务，这样做没有问题。

贷款申请则不同。它要做数据提取、身份证件核验、收入核实、风险评分，还要起草回复。用 ReAct 方式构建的 Agent 每做一个动作都得回头问一次大模型，而且事先无法确定它会走哪条路径。

LangChain 在介绍规划型 Agent 的文章中描述了规划-执行（plan-and-execute）架构，把工作一分为二：规划器（planner）用 LLM 为整个任务生成多步计划；执行器（executor）接收用户问题和计划中的某一步，调用一个或多个工具完成该步。

本指南分五步构建这样一个案件处理 Agent：规划器、有向无环图（DAG）校验、带重试的执行器、评审器（critic），以及重新规划。

## 需要准备什么？

需要 Python 3、一个封装所用模型的函数 `call_llm(prompt) -> str`，以及一个把工具名映射到 Python 函数的字典 `TOOLS`。为便于阅读，下面的代码做了**简化**：没有超时处理，没有日志，也没有完整的 schema 校验。贷款申请只是一个假设的例子，可以换成自己的业务领域。代码中的提示词和错误信息为中文，使用时可按需改写。

动手之前，值得记住 Anthropic 在《Building effective agents》中的一条建议：先找最简单的方案，只在确有必要时才增加复杂度。如果客户的流程本来就是固定的，手写工作流就够了。只有当步骤顺序因案件而异时，规划器才有存在的价值。

## 第 1 步：规划器必须返回数据，而不是一段文字

让规划器返回带 `depends_on` 字段的 JSON。有了这个字段，计划就成了机器可以检查的东西。

```python
import json

PLAN_PROMPT = """你是规划器。针对下面的案件材料，返回 JSON：
{"steps": [{"id": "...", "task": "...", "tool": "...", "depends_on": ["..."]}]}
只能使用以下工具：extract_fields, check_id, verify_income, score_risk, draft_reply。
案件材料：
"""

def plan(case_text):
    raw = call_llm(PLAN_PROMPT + case_text)
    steps = json.loads(raw)["steps"]
    for s in steps:
        if s["tool"] not in TOOLS:
            raise ValueError(f"无效的工具：{s['tool']}")
    return steps
```

**检查：**打印三个不同案件的计划。`check_id` 和 `verify_income` 都应该依赖 `extract_fields`，但彼此之间没有依赖。如果规划器把它们排成一条链，说明提示词没有讲清楚这两项任务相互独立。

## 第 2 步：确认计划是 DAG 之前，不要信任它

Airflow 文档把 DAG 定义为承载运行一个工作流所需全部信息的模型，其结构来自任务之间声明的依赖关系。LLM 生成的计划也是同一类依赖声明，只不过它可能是错的。

```python
def check_refs(steps):
    ids = {s["id"] for s in steps}
    unknown = {d for s in steps for d in s["depends_on"]} - ids
    if unknown:
        raise ValueError(f"依赖了不存在的步骤：{unknown}")

def topo_order(steps):
    check_refs(steps)
    deps = {s["id"]: set(s["depends_on"]) for s in steps}
    order = []
    while deps:
        ready = [k for k, ds in deps.items() if not ds]
        if not ready:
            raise ValueError(f"计划存在环：{list(deps)}")
        for k in ready:
            order.append(k)
            del deps[k]
        for ds in deps.values():
            ds.difference_update(ready)
    return order
```

为了看清这段代码的实际输出，假设规划器为一份示例贷款申请返回了下面的计划（仅作演示，并非任何模型的真实输出）。步骤依次为：提取关键字段、核验身份证、核查银行流水、风险评分、起草回复函。

```json
{"steps": [
 {"id": "s1", "task": "提取关键字段", "tool": "extract_fields", "depends_on": []},
 {"id": "s2", "task": "核验身份证", "tool": "check_id", "depends_on": ["s1"]},
 {"id": "s3", "task": "核查银行流水", "tool": "verify_income", "depends_on": ["s1"]},
 {"id": "s4", "task": "风险评分", "tool": "score_risk", "depends_on": ["s2", "s3"]},
 {"id": "s5", "task": "起草回复函", "tool": "draft_reply", "depends_on": ["s4"]}
]}
```

对这个 `steps` 列表调用函数：

```
>>> topo_order(steps)
['s1', 's2', 's3', 's4', 's5']
```

`while` 循环共执行四次。第一轮只有 `s1` 就绪；第二轮 `s2` 和 `s3` 同时就绪，所以这两步可以并行；第三轮轮到 `s4`，最后一轮是 `s5`。

**检查：**手动修改上面的计划，让 `s4` 依赖 `s5`。函数必须抛出 `计划存在环：['s4', 's5']`，而不是卡死。这一阶段出现的错误应该连同错误信息一起退回给规划器，而不是继续进入执行。

## 第 3 步：执行器需要重试和明确的运行规则

Airflow 有两个思路可以直接套用。第一个是为所有步骤统一设置 `retries` 等默认参数。第二个是触发规则（trigger rule）：默认的 `all_success` 表示只有所有上游步骤都成功，当前步骤才运行；`all_done` 则允许上游步骤一结束就运行，即使上游失败。

```python
DEFAULTS = {"retries": 2}

def run_step(step, case_text, results):
    inputs = {d: results.get(d) for d in step["depends_on"]}
    last_err = None
    for _ in range(DEFAULTS["retries"] + 1):
        try:
            return TOOLS[step["tool"]](case_text, step["task"], inputs)
        except Exception as e:
            last_err = e
    raise last_err

def execute(steps, case_text):
    by_id = {s["id"]: s for s in steps}
    results, status = {}, {}
    for sid in topo_order(steps):
        step = by_id[sid]
        rule = step.get("trigger_rule", "all_success")
        upstream_ok = all(status[d] == "success" for d in step["depends_on"])
        if rule == "all_success" and not upstream_ok:
            status[sid] = "skipped"
            continue
        try:
            results[sid] = run_step(step, case_text, results)
            status[sid] = "success"
        except Exception:
            status[sid] = "failed"
    return results, status
```

这个执行器在步骤之间不调用大模型。LangChain 认为这正是该架构的主要优势：不必每做一个动作都去询问大模型，多步工作流因此跑得更快。

**检查：**让 `verify_income` 总是报错。用第 2 步的示例计划，正确结果应是 `s3` 为 `failed`，`s4` 和 `s5` 为 `skipped`。像“写审核日志”这样的步骤应设为 `all_done`，这样无论案件在哪一步中断，都能留下记录。

## 第 4 步：评审器负责打分，不负责改写

LangChain 指出，反思（reflection）是一种能提升 Agent 质量和成功率的提示策略。在生成器/评审器循环中，评审器被提示扮演老师，对第一版答案给出建设性反馈。

Anthropic 把这种模式称为评估器-优化器（evaluator-optimizer）：一次 LLM 调用产出结果，另一次调用评估结果并给出反馈，两者循环往复。

```python
CRITIC_PROMPT = """你是一名严格的评审。请对照证据检查草稿。
检查清单：金额与材料一致；不做政策不允许的承诺；
每条拒绝理由都有证据支持。返回 JSON {"pass": true/false, "issues": [...]}。
"""

def reflect(draft, evidence, max_rounds=2):
    verdict = None
    for _ in range(max_rounds):
        payload = json.dumps({"draft": draft, "evidence": evidence}, ensure_ascii=False)
        verdict = json.loads(call_llm(CRITIC_PROMPT + payload))
        if verdict["pass"]:
            return draft, verdict
        draft = call_llm(f"根据以下反馈修改草稿 {verdict['issues']}：\n{draft}")
    return draft, verdict
```

提示词要求评审器扮演一位严格的老师，检查三件事：金额与材料一致；草稿没有做出政策不允许的承诺；每条拒绝理由都有证据支持。

价值在于检查清单。如果只是笼统地问评审器“这样好不好”，它没有任何标准可依。从客户自身规则中提炼出三条具体标准，评审器就有了检查依据；每次草稿被退回，你也能拿到明确的理由。

## 第 5 步：重新规划，并且知道何时停下

LangChain 介绍说，执行结束后会用重新规划（replan）提示词再次调用 Agent，让它在“现在就给出答案”和“再生成一份计划”之间做选择。这个循环需要一个上限。

```python
REPLAN_PROMPT = """根据各步骤的状态，返回 JSON：
{"action": "finish", "response": "..."} 或 {"action": "replan", "steps": [...]}
"""

def handle_case(case_text, max_replans=2):
    steps = plan(case_text)
    for _ in range(max_replans + 1):
        results, status = execute(steps, case_text)
        payload = json.dumps({"status": status, "results": results}, ensure_ascii=False, default=str)
        decision = json.loads(call_llm(REPLAN_PROMPT + payload))
        if decision["action"] == "finish":
            return reflect(decision["response"], results)
        steps = decision["steps"]
    return {"action": "escalate_to_human", "status": status}
```

`escalate_to_human` 分支是一项设计决策，不是无关紧要的细节。在客户项目中，把案件连同每一步的状态交给审核人员，远比一个自信却错误的答案更容易被接受。

**要点:** LLM 生成的计划只是一份提案。只有通过 DAG 校验，并配上重试、触发规则和轮数上限，它才算得上一个程序。

## 常见错误

第一个错误是只让评审器看草稿，不给它原始证据。如果 `extract_fields` 读错了金额，草稿本身仍可能前后一致，评审器也就无从核对。

LangChain 提到 Reflexion 的一个相关局限：它沿着单一固定的轨迹推进，一步出错就可能影响后续决策。因此要像上面的代码那样，把原始证据交给评审器，让早期错误仍有机会被发现。

第二个错误是彻底抛弃 ReAct。按照 ReAct 作者的说法，推理与行动交替进行，有助于模型跟踪和更新计划、处理异常。对于较难的步骤，比如读取格式特殊的银行流水，执行器完全可以是运行在 DAG 某个节点里的小型 ReAct Agent。

第三个错误是所有步骤都用同一个 `retries` 设置。给客户发邮件不该像读文件那样重试，否则客户可能收到三封邮件。

## 这项技能在客户现场用在哪里？

进驻客户的第一天，首要工作不是写提示词，而是和审核人员坐下来，把他们的真实流程画成 DAG：哪一步等哪一步，哪种失败会终止整个案件，哪种失败仍然要记录在案。这张图就是 `depends_on` 和 `trigger_rule`，他们的检查清单就是评审器的提示词。

阅读前线部署工程师（FDE）或 AI 工程师岗位的职位描述时，留意“multi-step workflows”“orchestration”“evaluation”这类字眼。简历上不要只写“用 LLM 构建了一个 Agent”，而要写明你把规划器和执行器分开、用 DAG 校验计划，并给出系统将多大比例的案件转交人工处理。

处理多步案件的好 Agent，不是什么都能自己搞定的 Agent，而是一旦出错，你能指出哪个节点失败、并解释原因的 Agent。

**本周动手试试:**

- 挑选公司里一个真实的多步流程，先在纸上画成 DAG，再让规划器根据文字描述复现出完全相同的 DAG。
- 按本指南写出 topo_order 函数，用三份有问题的计划测试它：依赖了不存在的步骤、两个步骤互相依赖形成环、使用了不在列表中的工具。
- 跑 10 个示例案件，记录每个案件的评审轮数和重新规划次数，再根据这些数字设定停止阈值。

## 信源

- [Plan-and-Execute Agents (LangChain)](https://www.langchain.com/blog/planning-agents)

- [Dags (Airflow Documentation)](https://airflow.apache.org/docs/apache-airflow/stable/core-concepts/dags.html)

- [Reflection Agents (LangChain)](https://www.langchain.com/blog/reflection-agents)

- [ReAct: Synergizing Reasoning and Acting in Language Models](https://react-lm.github.io/)

- [Building effective agents (Anthropic)](https://www.anthropic.com/engineering/building-effective-agents)
