🎯 今日核心问题

  1. ReAct 在 3 步以内很好用,为什么到 8 步以上就开始「忘了自己要干嘛」?
  2. Planner 产出的计划该用什么数据结构,才能让 Executor 无歧义执行?
  3. 执行到第 4 步发现第 2 步的前提错了,计划要不要改、怎么改?

📖 精读提纲

【一】ReAct 的三个结构性缺陷

ReAct 每一步都重新「看全部历史 + 决定下一步」。任务一长,三个问题同时出现:

Plan-and-Execute(源自 BabyAGI / LangChain 的 Plan-and-Execute Agent)的思路很朴素:把一次大 LLM 调用换成一个 Planner 一次 + 若干 Executor 多次 + 可选 Replanner 若干次。Planner 只看用户目标和工具清单,输出一个结构化的步骤列表;Executor 每次只处理「当前这一步」,上下文里就只有这一步的指令和前置产出。

【二】计划的数据结构决定成败

绝大多数人做 Plan-and-Execute 失败在第一步:让模型输出一段 Markdown 列表当计划。后果是 Executor 没法判断「第 3 步完成了吗」,也没法在步骤间传值。正确的做法是让模型输出严格 JSON,且每个步骤必须包含四个字段:

LangChain4j 里用 AiServices + 返回类型为 List<PlanStep> 的 interface,配合 @V 注解描述字段约束,模型基本能稳定输出。注意:Java record 是首选,因为反序列化后天然不可变,避免 Executor 偷偷改计划。

【三】实战应用:Spring Boot 场景

场景:竞品周报生成。目标「对比我们和两家竞品本周的 AI 功能更新,出 500 字结论」。步骤大致是:查各自更新日志 → 提取功能点 → 建对比表 → 写结论 → 生成推送文案。这 5 步里前 3 步的顺序是固定的,第 4 步依赖第 2、3 步,第 5 步依赖第 4 步。

Spring Boot 里的实现要点:计划持久化。把 Plan 存进数据库(一张 agent_plan 表 + 一张 agent_step 表),每完成一步就 update 一次状态。这样进程重启能续跑(第4周 D6 会用到),也能让前端轮询进度(D6)。如果你的 Agent 只是同步阻塞在 HTTP 请求里,可以先用内存态,但表结构建议一开始就建好。

执行器用 CompletableFuture 做 dependsOn 无关的步骤并行。注意模型 API 有并发限流,要给个固定大小的线程池(比如 4),别让 20 个步骤同时打出去。

【四】常见误区

💻 代码示例

public record PlanStep(
        String id,
        String goal,
        List<String> dependsOn,
        String expectedOutput) {}

public record Plan(List<PlanStep> steps) {}

interface Planner {
    @SystemMessage("""
        你是任务规划器。根据用户目标,输出 3-7 个步骤的执行计划。
        每个步骤的 goal 必须描述"要得到的结果",而不是"要执行的动词"。
        步骤之间如果有数据依赖,填 dependsOn。
        不要指定使用什么工具。不要输出解释文字。
        可用能力边界:可以访问内部 wiki、可以调用 HTTP 接口读公开网页、
        可以进行文本分析与写作。不能访问付费数据库。
        """)
    Plan makePlan(@UserMessage String objective);
}

interface Replanner {
    @SystemMessage("""
        你是重规划器。给定原计划、已完成步骤、失败步骤及错误信息,
        输出修订后的完整计划(保留已完成步骤,标记为已完成)。
        最多 8 步。只输出 JSON。
        """)
    Plan revise(@UserMessage String context);
}
@Service
@RequiredArgsConstructor
public class PlanExecuteAgent {

    private final Planner planner;
    private final Replanner replanner;
    private final StepExecutor stepExecutor;      // 内部就是一个 ReAct 循环,但只做单步
    private final PlanRepository planRepo;
    private final ExecutorService pool = Executors.newFixedThreadPool(4);

    public PlanResult execute(String objective) {
        Plan plan = planner.makePlan(objective);
        planRepo.save(plan);

        Map<String, String> outputs = new ConcurrentHashMap<>();
        int guard = 0;

        while (true) {
            if (++guard > 12) throw new IllegalStateException("plan loop exceeded");

            List<PlanStep> ready = plan.steps().stream()
                    .filter(s -> planRepo.status(s.id()) == Status.PENDING)
                    .filter(s -> s.dependsOn().stream().allMatch(outputs::containsKey))
                    .toList();

            if (ready.isEmpty()) {
                boolean anyFailed = plan.steps().stream()
                        .anyMatch(s -> planRepo.status(s.id()) == Status.FAILED);
                if (!anyFailed) break;                      // 全部完成
                plan = replanner.revise(buildContext(plan, outputs));
                planRepo.save(plan);
                continue;
            }

            List<CompletableFuture<Void>> futures = ready.stream()
                    .map(s -> CompletableFuture.runAsync(() -> {
                        planRepo.markRunning(s.id());
                        try {
                            String ctx = s.dependsOn().stream()
                                    .map(id -> "【" + id + "的产出】\n" + clip(outputs.get(id), 800))
                                    .collect(Collectors.joining("\n"));
                            String out = stepExecutor.run(s.goal(), s.expectedOutput(), ctx);
                            outputs.put(s.id(), out);
                            planRepo.markDone(s.id(), out);
                        } catch (Exception e) {
                            planRepo.markFailed(s.id(), e.getMessage());
                        }
                    }, pool))
                    .toList();
            futures.forEach(CompletableFuture::join);
        }

        return new PlanResult(plan, outputs);
    }
}

一次真实的 Planner 输出(竞品周报任务,responseFormat = JSON):

{
  "steps": [
    {"id":"s1","goal":"拿到我们、竞品A、竞品B本周的功能更新条目","dependsOn":[],"expectedOutput":"三条更新列表,每条含日期+一句话"},
    {"id":"s2","goal":"从更新条目中提取可对比的功能维度(模型、上下文、定价、生态)","dependsOn":["s1"],"expectedOutput":"4个维度下的三方对照"},
    {"id":"s3","goal":"判断本周谁的功能更新对开发者价值最高,给出理由","dependsOn":["s2"],"expectedOutput":"排序结论+2条理由"},
    {"id":"s4","goal":"写成500字周报正文,含一段结论和下步建议","dependsOn":["s3"],"expectedOutput":"500字中文正文"}
  ]
}

注意 s1 的 goal 是「拿到三条更新列表」而不是「去访问三个网站」——前者可验收,后者不可。这个差别直接决定 Executor 能不能判断自己完成了。

✏️ 今日动手

把你昨天那个 3 步 ReAct 任务改造成 Plan-and-Execute:写 Planner / Replanner 两个 interface(LangChain4j AiServices 直接生成实现),跑通 4-5 步的计划执行。硬性要求:① 计划里至少有一对可以并行执行的步骤,用 CompletableFuture 跑起来,打印实际耗时对比串行;② 人为让 s2 抛异常,验证 Replanner 能产出修订计划而不是崩溃;③ 对比 D1 的 ReAct 方案,把 token 消耗和延迟列在同一张表里。

🔖 明日预告

计划能不能写好,取决于会不会拆。「分析这份财报」这种目标丢给 Planner,它大概率输出「第一步:分析财报」这种废话步骤。明天专门讲任务分解:怎么用结构化约束逼出真正可执行的原子步骤。