「吴恩达：AI Agent 工作流今年将有巨大进展，这是一个重要的趋势」中，吴恩达教授指出未来的一个重要趋势，AI Agent 工作流将在今年推动人工智能取得巨大进步，甚至可能超过下一代基础模型。  并呼吁所有从事人工智能工作的人都关注 AI Agent 工作流。在文中介绍了 AI Agent 工作流的四种设计模式 ：Reflection（反思）、Tool use（执行）、 Planning （规划）、Multi-agent collaboration（多智能体协作）。

AI Agent 工作流不是让大模型直接生成最终输出，而是多次提示 LLM，使其有机会逐步构建更高质量的输出。接下来，将重点讨论一下 Reflection（反思）

Reflection 是一种提示策略，用于提高 Agent 和类似人工智能系统的质量和成功率。它涉及提示 LLM 反思和批评其过去的行为，有时会结合其他外部信息，例如工具进行观察分析。

反思类比于我们经常谈论「系统1」和「系统2」思维，其中「系统1」是反应性的或本能的，而「系统2」则更有条理和反思性。如果正确应用，反思可以帮助 LLM 系统突破纯粹的「系统1」“思维”模式，并更接近于表现出类似「系统2」的行为。

反思需要时间，所有方法都牺牲了一些额外的计算（付出更多跟多的成本?）来获得更好质量的输出。虽然这可能不适合低延迟应用程序，但对于响应质量比速度更重要的知识密集型任务来说，这是值得的。

Basic Reflection 基本反思

这个简单的示例由两个 LLM 调用组成：生成器和反思器。生成器尝试直接响应用户的请求。反思器被提示扮演教师的角色，并对最初的反应提出建设性的批评。循环进行固定次数，并返回最终生成的输出。

我们可以在下面的 LangGraph^[1] 中定义循环：

from langgraph.graph import MessageGraph

builder = MessageGraph()
builder.add_node("generate", generation_node)
builder.add_node("reflect", reflection_node)
builder.set_entry_point("generate")


def should_continue(state: List[BaseMessage]):
    if len(state) > 6:
        return END
    return "reflect"


builder.add_conditional_edges("generate", should_continue)
builder.add_edge("reflect", "generate")
graph = builder.compile()

MessageGraph 表示一个状态图，其中“状态”只是一个消息列表。每次调用生成器或反思器节点时，它都会在状态末尾附加一条消息。最终结果从生成器节点返回。

这种简单类型的反思有时可以通过多次尝试改进其输出并让反思节点在批评输出时采用不同的角色来提高性能。

然而，由于反思步骤不基于任何外部过程（或信息），因此最终结果可能不会比原始结果好得多。

Reflexion 反思

反思^[2]是一种旨在通过口头反馈和自我反思来学习的架构。在反思中，Actor Agent 明确批评每个响应，并将其批评建立在外部数据的基础上。它被迫生成引用并明确列举生成的响应中多余和缺失的方面。这使得反思的内容更具建设性，并更好地引导生成器响应反馈。

Reflexion包含三个模块：Actor(行动者)、Evaluator(评估器)和Self-Reflection(自我反思)：

Actor

Actor 是建立在 LLM 之上的，它专门通过特定 Prompt 生成所需的文本和动作，这些 Prompt 是基于状态观察条件的。

Evaluator

Evaluator 组件主要是在评估 Actor 生成的输出质量方面发挥着至关重要的作用。它将生成的轨迹作为输入，并计算反映其在给定任务上表现的奖励分数。对于不同的任务使用了不同的需要设计不同语义空间的有效价值和奖励函数。

Self-reflection

Self-Reflection 在 Reflexion 框架中发挥着至关重要的作用，通过生成口头自我反思为未来的试验提供有价值的反馈。

Agent 循环的示意如下所示：

反思的主要组成部分是 Actor ，它是一个反思自己的反应并基于自我批评重新执行改进的 Agent。它的主要子组件包括：

1. Tools：Execute Tools
2. Initial responder: generate an initial response (and self-reflection)
3. Revisor：根据之前的反思，进行 re-respond

对于每个步骤，Responder 的任务是生成响应以及搜索查询形式的其他操作。然后提示 Revisor 反思当前状态。逻辑可以在 LangGraph 中定义如下：

from langgraph.graph import END, MessageGraph

MAX_ITERATIONS = 5
builder = MessageGraph()
builder.add_node("draft", first_responder.respond)
builder.add_node("execute_tools", execute_tools)
builder.add_node("revise", revisor.respond)
# draft -> execute_tools
builder.add_edge("draft", "execute_tools")
# execute_tools -> revise
builder.add_edge("execute_tools", "revise")

# Define looping logic:
def event_loop(state: List[BaseMessage]) -> str:
    # in our case, we'll just stop after N plans
    num_iterations = _get_num_iterations(state)
    if num_iterations > MAX_ITERATIONS:
        return END
    return "execute_tools"


# revise -> execute_tools OR end
builder.add_conditional_edges("revise", event_loop)
builder.set_entry_point("draft")
graph = builder.compile()

该 Agent 可以有效地使用明确的反映和基于外部工具或信息来提高最终响应的质量。然而，它只追求一个固定的轨迹，所以如果它犯了一个错误，这个错误可能会影响后续的决策。

Language Agent Tree Search

LATS^[3] 是一种通用的 LLM Agent 的搜索算法，它结合了反思/评估和搜索（特别是蒙特卡罗Monte-Carlo 树搜索），与 ReAct、Reflexion 甚至 Tree of Thoughts 等类似技术相比，可以实现更好的整体任务性能。它采用标准的强化学习 (RL) 任务框架，通过调用 LLM 替换 RL Agent、价值函数和优化器。这旨在帮助 Agent 适应复杂任务并解决问题，避免陷入重复循环。

搜索过程如下图所示：

搜索有四个主要步骤：

1. 选择：根据下面步骤 (2) 的总奖励选择最佳的下一步行动。要么做出响应（如果找到解决方案或达到最大搜索深度），要么继续搜索。
2. 扩展和模拟：生成 N（如：5）个潜在操作以并行执行并执行它们。
3. 反思+评估：观察这些行动的结果，并根据反思（以及可能的外部反馈）对决策进行评分
4. 反向传播：根据结果更新根轨迹的分数。

如果 Agent 具有紧密的反馈循环（通过高质量的环境奖励或可靠的反思分数），则搜索能够准确地区分不同的动作轨迹并选择最佳路径。最终的轨迹可以保存到外部存储器（或用于模型微调）以在将来改进模型。

“选择”步骤选择具有最高置信上限（UCT）的节点，这只是平衡预期奖励（第一项）和探索新路径的激励（第二项）。

在 LangGraph 实现中，将生成 + 反思步骤分别放在单个节点中，并检查每个循环上的树状态以查看任务是否已解决。graph 定义如下所示：

from langgraph.graph import END, StateGraph

class Node:
    def __init__(
        self,
        messages: List[BaseMessage],
        reflection: Reflection,
        parent: Optional[Node] = None,
    ):
        self.messages = messages
        self.parent = parent
        self.children = []
        self.value = 0
        self.visits = 0
    # Additional methods are defined here. Check the code for more!

class TreeState(TypedDict):
    # The full tree
    root: Node
    # The original input
    input: str

def should_loop(state: TreeState):
    """Determine whether to continue the tree search."""
    root = state["root"]
    if root.is_solved:
        return END
    if root.height > 5:
        return END
    return "expand"


builder = StateGraph(TreeState)
builder.add_node("start", generate_initial_response)
builder.add_node("expand", expand)
builder.set_entry_point("start")


builder.add_conditional_edges(
    "start",
    # Either expand/rollout or finish
    should_loop,
)
builder.add_conditional_edges(
    "expand",
    # Either continue to rollout or finish
    should_loop,
)

graph = builder.compile()

LATS 统一了其他 Agent 架构的推理、规划和反思组件，例如反思（Reflexion）、思想树（Tree of Thoughts）以及计划和执行Agent（plan-and-execute）。LATS 还通过反思和基于环境的反馈的反向传播来改进搜索过程。虽然它可能对奖励分数敏感，但通用算法可以灵活地应用于各种任务。

总结

上述所有技术都利用额外的 LLM 推理来增加生成更高质量输出或正确响应更复杂的推理任务的可能性。虽然这需要额外的时间，但当输出质量比响应时间更重要时，它可能是合适的，并且如果将轨迹保存到内存（或作为微调数据），则可以更新模型以避免将来重复错误。

参考资料：

1:??️LangGraph | ?️? Langchain (https://python.langchain.com/docs/langgraph)

2: Reflexion: Language Agents with Verbal Reinforcement Learning (https://arxiv.org/pdf/2303.11366.pdf)

3: Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models (https://arxiv.org/pdf/2310.04406.pdf)

4:reflection-agents (https://blog.langchain.dev/reflection-agents/)