FDE Times 数据在招 FDE 职位 924▲33 近 7 天在招职位数的变化(同口径比较):不计入本周新开始追踪的公司的职位近 7 天新增 80在招公司 196支持远程 25%美国薪资中位数 $200k招聘最多 Databricks 107
ENVI

前线部署工程师(FDE)的专业媒体

技能指南 · 指南

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

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

分享微博

要点速览

  • 规划器一次调用生成完整计划,执行器调用工具逐步完成,不必每做一步都去问大模型。
  • 计划必须先通过 DAG 校验,不能依赖未知步骤,也不能有环,然后按重试次数和明确的触发规则执行。
  • 评审器按检查清单给草稿打分,但必须设定轮数上限,并能把案件转交给人处理。
案件处理 Agent 示意图:Planner 输出 JSON,经过 DAG 校验(橙色高亮),再进入带重试的 Executor,最后由 Critic 对照检查清单打分。DAG 校验失败时,错误退回 Planner。Executor 最多可重新规划回 Planner 2 次,次数用完后案件转交人工审核员。Critic 判定不通过时把草稿退回修改,通过则发出回复。
重新规划产生的新计划同样必须先通过 DAG 校验才能执行。Critic 只能修改草稿。重新规划次数用完后,案件转交人工审核员。来源:LangChain 对 plan-and-execute 架构的介绍、Airflow 文档及 Anthropic《Building effective agents》,均见文中引用。

在经典的 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。有了这个字段,计划就成了机器可以检查的东西。

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 生成的计划也是同一类依赖声明,只不过它可能是错的。

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

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

{"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 则允许上游步骤一结束就运行,即使上游失败。

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 调用产出结果,另一次调用评估结果并给出反馈,两者循环往复。

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,让它在“现在就给出答案”和“再生成一份计划”之间做选择。这个循环需要一个上限。

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

常见错误

第一个错误是只让评审器看草稿,不给它原始证据。如果 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。

这篇文章对你有帮助吗?

5 个信源
路线图上的下一篇 · 阶段 3: AI 应用Text-to-SQL 智能体的成败,取决于客户的业务定义Vercel 删掉智能体的大部分工具后它仍然好用,因为语义层早已写得清清楚楚。