AgentFlow框架深度研究：小模型如何超越大模型

QianXun (QianXun) • 2025年10月25日 15:48

                        ## 1. 技术实现细节：模块化协作与Flow-GRPO训练机制

AgentFlow框架的核心技术突破在于其创新的模块化系统架构和专为该系统设计的Flow-GRPO（Flow-based Group Refined Policy Optimization）训练算法。这一组合旨在解决传统单体大模型在处理复杂、多步推理任务时面临的诸多挑战，如上下文窗口限制、工具调用不可靠以及长时序决策的信用分配难题。AgentFlow通过将复杂的认知过程分解为多个专业化的智能体模块，并利用一种新颖的在线强化学习方法对关键决策模块进行实时优化，从而在系统层面实现了超越传统方法的性能。本章节将深入剖析AgentFlow的四大核心模块——规划器（Planner）、执行器（Executor）、验证器（Verifier）和演进式记忆（Evolving Memory）——之间的协作模式，并详细解读Flow-GRPO训练方法的具体步骤与原理。

### 1.1 核心架构：四大模块的协作模式

AgentFlow框架摒弃了单体大模型“一刀切”的处理方式，采用了一种结构化的多智能体协作模式。该模式由四个各司其职又紧密协同的模块构成：规划器（Planner）、执行器（Executor）、验证器（Verifier）和生成器（Generator）。这四个模块通过一个共享的“演进式记忆”（Evolving Memory）进行信息交换和状态同步，形成一个完整的、能够处理复杂任务的智能系统 。这种设计不仅提高了系统的可解释性和模块化程度，更重要的是，它为后续的在线强化学习训练提供了清晰的优化目标和稳定的训练环境。整个协作流程在一个多轮的交互循环中展开，每一轮都包含规划、执行、验证和记忆更新等关键步骤，直至任务完成并生成最终答案 。

| 模块 (Module) | 角色 (Role) | 核心职责 (Core Responsibility) | 输入 (Input) | 输出 (Output) |
| :--- | :--- | :--- | :--- | :--- |
| **规划器 (Planner)** | **大脑 / 指挥官** | 制定行动计划，选择工具，是**唯一可训练的模块** 。 | 用户查询、工具集、演进式记忆。 | 子目标、选定的工具、工具使用的上下文 。 |
| **执行器 (Executor)** | **双手 / 行动臂** | 忠实执行规划器的指令，调用具体工具并获取结果 。 | 规划器的行动计划（工具及参数）。 | 生成的具体命令、工具执行结果。 |
| **验证器 (Verifier)** | **质检员 / 反馈者** | 分析执行结果的有效性，提供反馈，控制流程继续或停止 。 | 用户查询、执行结果、演进式记忆。 | 分析报告、验证状态（成功/失败/继续）。 |
| **演进式记忆 (Evolving Memory)** | **中枢神经系统** | 记录所有交互信息，为所有模块提供共享的、动态更新的上下文 。 | 规划器行动、执行器结果、验证器反馈。 | 更新后的全局记忆状态。 |

*Table 1: AgentFlow框架核心模块及其协作关系。*

#### 1.1.1 规划器 (Planner)：决策与工具选择的核心

规划器（Planner）是AgentFlow框架中的“大脑”和核心决策单元，也是整个系统中**唯一被训练的模块** 。其主要职责是在每一轮交互中，根据用户的初始查询（Query）、可用的工具集（Toolset）以及当前的演进式记忆（Memory）状态，制定出下一步的行动计划。具体来说，规划器的输入包括对用户查询的分析、全局目标的设定、所需技能的识别，以及从记忆中提取的历史交互信息。基于这些输入，规划器需要做出三个关键决策：确定当前的子目标（Current Sub-Goal）、选择最合适的工具（Selected Tool），并为该工具的使用提供必要的上下文信息（Context for Tool Use）。例如，在处理一个复杂的科学问题时，规划器可能会决定首先通过搜索引擎查找相关背景知识，然后调用代码解释器进行数据计算，最后利用验证器来确认结果的准确性。规划器的决策质量直接决定了整个任务执行的效率和成功率，因此，通过Flow-GRPO算法对其进行优化，是AgentFlow实现性能突破的关键所在。

#### 1.1.2 执行器 (Executor)：工具调用与结果获取

执行器（Executor）是AgentFlow框架中的“双手”，负责将规划器制定的抽象计划转化为具体的行动。它的功能相对直接，主要接收来自规划器的指令，包括选定的工具和为该工具提供的上下文，然后调用相应的工具并执行操作 。执行器的输入是规划器生成的“当前子目标”、“选定的工具及其上下文”以及工具的元数据。其输出则是“生成的具体命令”（Generated Command）和“执行结果”（Execution Result）。例如，如果规划器决定使用Python代码解释器来解决一个数学问题，执行器就会负责生成并运行相应的Python代码，并捕获代码的输出结果。执行器模块在AgentFlow的训练过程中通常是冻结的，这意味着它依赖于预定义的工具接口和功能，其角色是忠实、准确地执行规划器的指令，并将执行结果反馈给验证器和演进式记忆，为后续的决策提供依据。

#### 1.1.3 验证器 (Verifier)：结果分析与反馈

验证器（Verifier）在AgentFlow框架中扮演着“质检员”的角色，负责对执行器产生的结果进行分析和评估，以确保其准确性和有效性。验证器的输入包括用户的原始查询、执行器产生的执行结果以及当前的演进式记忆 。基于这些信息，验证器会生成一份分析报告，内容包括对执行结果的分析、对当前记忆状态的分析，以及最终的验证状态（Verification Status）。这个验证状态可以是一个简单的“成功/失败”标志，也可以是一个更复杂的评估，例如指出结果中的潜在错误、评估信息的可靠性或建议下一步的行动方向。验证器的反馈对于系统的自我纠错和持续改进至关重要。它不仅为演进式记忆提供了关键的评估信息，帮助系统从错误中学习，也为Flow-GRPO算法提供了重要的中间信号，尽管最终的奖励信号是基于整个任务的成功与否，但验证器的反馈有助于在训练过程中提供更丰富的上下文信息，从而加速规划器的学习过程。

#### 1.1.4 演进式记忆 (Evolving Memory)：全局信息的共享与更新

演进式记忆（Evolving Memory）是AgentFlow框架的“中枢神经系统”，是实现多模块高效协作和上下文感知的关键。它是一个共享的、动态更新的信息存储库，记录了从任务开始到结束的所有关键交互信息，包括规划器的决策、执行器的行动、验证器的反馈以及工具调用的结果 。在每一轮交互中，记忆模块会根据当前的记忆状态、规划器的行动、执行器的结果和验证器的反馈进行更新，其更新函数可以表示为 `M_{t+1} = f_mem(M_t, a_t, e_t, v_t)` 。这种设计确保了所有模块都能访问到完整、一致的历史上下文，从而做出更明智的决策。例如，规划器可以根据记忆中记录的前几次失败的尝试，调整其策略，探索新的解决方案路径。演进式记忆不仅解决了传统单体模型中因上下文窗口有限而导致的信息丢失问题，还为Flow-GRPO算法提供了必要的轨迹信息，使得算法能够对整个决策过程进行回溯和评估，从而实现有效的信用分配。

### 1.2 Flow-GRPO：解决长时序信用分配难题的训练方法

Flow-GRPO（Flow-based Group Refined Policy Optimization）是AgentFlow框架的核心技术创新，是一种专为解决多智能体、长时序、稀疏奖励环境下的信用分配问题而设计的在线强化学习算法 。传统的强化学习方法在处理这类问题时往往表现不佳，因为奖励信号（例如，任务最终是否成功）只在整个交互过程结束时才出现，这使得算法难以判断早期决策对最终结果的具体贡献。Flow-GRPO通过一种巧妙的“奖励广播”机制，将复杂的、多轮的强化学习问题转化为一系列简单的、单轮的策略更新问题，从而极大地降低了训练的难度和复杂性 。

#### 1.2.1 核心思想：将多轮优化转化为单轮更新

Flow-GRPO算法的核心思想在于其独特的信用分配策略。它摒弃了为每一步决策手动设计复杂奖励函数的传统做法，而是采用了一种更为简洁和鲁棒的方法：**将整个任务轨迹的最终结果（成功或失败）作为唯一的奖励信号，并将其“广播”到该轨迹中的每一个决策步骤** 。具体来说，如果一个任务最终成功完成，那么规划器在该任务执行过程中做出的所有决策都会被视为“好”的决策，并获得一个正的奖励信号；反之，如果任务失败，所有决策都会被视为“坏”的决策，并获得一个负的奖励信号 。这种设计将一个长时序的、稀疏奖励的优化问题，有效地分解为一系列独立的、单轮的优化问题。在每一轮中，规划器都可以根据当前的上下文和最终的成败信号来独立地更新其策略，而无需考虑复杂的跨步依赖关系。这种方法不仅简化了优化过程，还使得算法能够从稀疏的、高层次的反馈中学习到有效的长期策略 。

#### 1.2.2 奖励广播机制：用最终成败信号指导每一步决策

奖励广播机制是Flow-GRPO算法实现高效信用分配的关键。在AgentFlow的训练流程中，当一个任务执行完毕后，系统会根据最终的答案是否正确来生成一个全局的、可验证的奖励信号 `R(o, q, y*)`，其中 `o` 是生成的答案，`q` 是用户查询，`y*` 是标准答案 。然后，这个单一的奖励值会被分配给该任务轨迹中的每一个行动 `a_t`，即 `R(a_t) = R(o, q, y*)`，对于所有的 `t = 1, ..., T` 。这种机制确保了规划器在每一步决策时，都能接收到与最终目标一致的明确信号。例如，在一个需要多步推理的数学问题中，即使规划器在前几步做出了正确的决策，但如果最后一步出错导致答案错误，那么所有步骤的决策都会被给予负向反馈。这会促使规划器学习到，不仅要关注眼前的子目标，更要确保每一步都为最终的成功做出贡献，从而培养出更强的全局规划能力和鲁棒性。

#### 1.2.3 组归一化优势：提升训练稳定性

为了进一步提升训练的稳定性和效率，Flow-GRPO算法引入了**组归一化优势（Group-normalized advantages）** 的概念。这一技术借鉴了Group Relative Policy Optimization (GRPO) 的思想，通过对一组样本的奖励进行归一化处理，来减少奖励尺度变化带来的不稳定性 。在AgentFlow的训练过程中，系统会针对同一个查询生成多个不同的任务执行轨迹（即一组样本）。然后，Flow-GRPO会计算这组轨迹中所有决策的平均奖励，并用每个决策的奖励与这个平均奖励的差值作为其优势（advantage）。这个优势值经过组内标准差的归一化后，被用于更新规划器的策略。这种组归一化的方法可以有效地平衡不同任务之间的难度差异，防止某些高难度任务的巨大负向奖励或某些简单任务的巨大正向奖励主导了整个训练过程，从而使得训练更加平稳，收敛速度更快 。

#### 1.2.4 训练流程：在交互“流”中实时优化规划器

AgentFlow的训练过程是一个完全在线的、在交互“流”中进行的实时优化过程。整个训练算法可以概括为以下三个主要步骤，如算法1所示 ：

1.  **在交互“流”中生成轨迹（In-the-Flow Rollout Generation）** ：对于训练数据集中的每一个查询-答案对 `(q, y*)`，系统会启动一个AgentFlow实例。规划器 `π_θ` 会根据查询 `q`、工具集 `K` 和当前的演进式记忆 `M_t` 来规划行动 `a_t`。执行器 `E` 和验证器 `V` 随后会执行该行动并验证结果。记忆 `M_t` 会根据行动、结果和验证反馈进行更新。这个过程会重复进行，直到满足终止条件（例如，达到最大轮次或规划器决定生成最终答案）。最后，生成器 `G` 会根据最终的记忆状态 `M_T` 生成最终答案 `o` 。

2.  **奖励计算（Reward Computation）** ：根据生成的最终答案 `o` 和标准答案 `y*` 的比较结果，计算出一个全局的奖励信号 `R(o, q, y*)`。然后，将这个奖励信号广播给该轨迹中的所有行动 `a_t`，即 `R(a_t) = R(o, q, y*)` 。

3.  **策略更新（Policy Update）** ：使用计算出的奖励和Flow-GRPO的目标函数（论文中的公式5）来更新规划器的策略参数 `θ`。这个目标函数通常会包含一个策略梯度项和一个KL散度正则化项，以确保新策略在获得更高奖励的同时，不会偏离参考策略太远，从而保证训练的稳定性 。

通过反复执行这三个步骤，AgentFlow的规划器能够在与环境的不断交互中，逐步学习到更优的决策策略，从而提升其在各种复杂任务上的表现。

## 2. 应用场景与优势：超越单体大模型的系统性创新

AgentFlow框架的设计初衷是为了解决传统单体大模型在应对复杂、多步、需要与外部工具交互的推理任务时所暴露出的局限性。通过其独特的模块化架构和创新的训练方法，AgentFlow在多个应用场景中展现出显著的优势，不仅在性能上超越了同等规模甚至更大规模的单体模型，更在系统的可解释性、鲁棒性和可扩展性方面树立了新的标杆。本章节将详细分析AgentFlow在各类任务上的具体应用场景，并深入阐述其相较于传统方法的核心优势。

### 2.1 应用场景：复杂推理与工具调用任务

AgentFlow框架特别适用于那些无法通过单一模型直接回答，而是需要分解为多个子任务、调用多种外部工具、并进行多步推理才能解决的复杂问题。这些问题广泛存在于科学研究、数据分析、信息检索和软件开发等领域。

#### 2.1.1 搜索与信息整合任务

在需要广泛搜索和整合信息的任务中，AgentFlow的优势尤为突出。例如，当用户提出一个需要跨多个领域知识才能回答的复杂问题时，单体大模型可能会因为知识截止日期或内部知识的局限性而无法给出准确答案。而AgentFlow的规划器可以主动地将问题分解为多个子查询，并依次调用搜索引擎（如Google Search）、百科全书（如Wikipedia）等工具来获取最新、最相关的信息 。验证器会对搜索结果的可靠性进行评估，而演进式记忆则负责整合来自不同来源的信息，形成一个连贯的知识图谱。实验结果表明，AgentFlow在搜索任务上的性能比基线模型提升了**14.9%** ，这充分证明了其在信息检索和整合方面的强大能力。

#### 2.1.2 数学与科学计算任务

数学和科学计算是另一类对推理能力和工具调用精度要求极高的应用场景。这类任务通常涉及复杂的公式推导、数值计算和数据分析，单纯依靠语言模型的内部知识很难保证结果的准确性。AgentFlow可以通过调用代码解释器（如Python Coder）来执行精确的计算，并利用验证器来检查计算过程和结果的正确性 。例如，在解决一个物理问题时，规划器可以先生成描述问题的数学模型，然后调用代码解释器进行求解，最后由验证器分析结果的物理意义是否合理。这种“思考-计算-验证”的循环模式，使得AgentFlow在处理数学和科学任务时，其准确性和可靠性远超单体大模型。实验数据显示，AgentFlow在数学任务上的性能提升了**14.5%**，在科学任务上提升了**4.1%** 。

#### 2.1.3 多步智能体推理任务

多步智能体推理任务是指那些需要模拟一个智能体在环境中进行一系列决策和行动才能达成目标的任务，例如自动化软件开发、智能客服对话管理或复杂的业务流程自动化。在这类任务中，AgentFlow的模块化架构展现了其独特的价值。规划器负责制定每一步的行动策略，执行器负责与环境（如代码库、API接口）进行交互，验证器则负责评估行动的效果。整个过程中的所有信息都被记录在演进式记忆中，为规划器提供了丰富的上下文，使其能够根据环境的反馈动态调整策略。这种结构化的协作方式，使得AgentFlow能够处理那些需要长期规划和自适应能力的复杂任务。实验结果也证实了这一点，AgentFlow在智能体任务上的性能提升了**14.0%** 。

### 2.2 核心优势：系统性超越单体大模型

AgentFlow相较于传统单体大模型的优势是系统性的，它源于其创新的架构设计，而非仅仅是模型参数的增加。这些优势主要体现在结构化协作、动态规划能力以及工具调用的可靠性等方面。

#### 2.2.1 结构化协作 vs. 单体黑箱

单体大模型通常被视为一个“黑箱”，其内部的决策过程难以理解和干预。用户输入一个问题，模型直接给出一个答案，中间的具体推理步骤和工具调用过程对用户来说是不可见的。这种黑箱特性不仅降低了系统的可解释性，也使得调试和优化变得异常困难。相比之下，AgentFlow的模块化设计将整个推理过程分解为一系列清晰、可追踪的步骤。规划器的决策、执行器的行动、验证器的反馈都记录在案，用户可以清晰地看到系统是如何一步步解决问题的 。这种结构化的协作模式不仅提高了系统的透明度和可解释性，也为“人在回路”（Human-in-the-Loop）的交互提供了可能，用户可以在关键节点进行干预和指导，从而进一步提升系统的性能和可靠性 。

#### 2.2.2 动态规划与自适应能力

单体大模型在处理复杂任务时，往往采用一种静态的、一次性的生成方式。它根据输入的提示（Prompt）生成一个完整的解决方案，但在这个过程中很难根据中间结果进行动态调整。如果初始的生成方向出现偏差，模型很难自我纠正。AgentFlow则通过其多轮的交互循环，实现了真正的动态规划和自适应能力。规划器在每一步都可以根据演进式记忆中的最新信息（包括前一步的执行结果和验证反馈）来重新评估当前的状况，并制定出最优的下一步行动 。这种“边做边学”的能力，使得AgentFlow能够灵活地应对各种意外情况和复杂约束。例如，如果一个工具调用失败或返回了意外的结果，规划器可以立即调整策略，尝试使用其他工具或采用不同的方法，而不是像单体模型那样陷入死胡同。

#### 2.2.3 工具调用的可靠性与效率提升

工具调用是连接大模型与外部世界、扩展其能力边界的关键。然而，单体大模型在工具调用方面常常表现出不可靠性，例如选择错误的工具、生成格式错误的参数，或者进行不必要的、冗余的工具调用。AgentFlow通过其专业化的模块分工，显著提升了工具调用的可靠性和效率。规划器专门负责选择最合适的工具，而执行器则负责生成正确的调用命令。验证器的存在则为工具调用的结果提供了一层额外的保障。更重要的是，通过Flow-GRPO算法的训练，规划器能够学习到在不同情境下选择最优工具的策略，从而避免了冗余和错误的工具调用。实验分析表明，经过训练后，AgentFlow能够将错误和冗余的工具调用减少高达**28%** ，这不仅提升了任务的成功率，也显著降低了计算成本和时间开销。

## 3. 实验结果与分析：小模型为何能超越大模型

AgentFlow框架最引人注目的成果之一，便是其在多个基准测试中，使用一个仅有70亿参数（7B）的基座模型（Qwen2.5-7B-Instruct），性能却超越了参数量远大于它的顶尖专有模型，如GPT-4o（约2000亿参数）。这一“以小博大”的现象，并非偶然，而是其系统性创新的必然结果。本章节将详细拆解AgentFlow的实验结果，并深入分析其背后的原因，揭示为何精巧的系统设计能够战胜单纯的参数堆砌。

### 3.1 基准测试表现：全面领先

为了全面评估AgentFlow的性能，研究人员在10个涵盖不同推理领域的基准测试上进行了实验，包括搜索、智能体推理、数学和科学计算等。实验结果一致表明，AgentFlow在各项任务上均取得了显著的性能提升，并全面超越了现有的顶尖基线模型。

#### 3.1.1 整体性能：在10个基准测试中超越顶尖基线

AgentFlow在总共10个不同的基准测试中，均表现出优于其他顶尖模型的性能。这些测试旨在评估模型在复杂推理、工具使用和知识整合等方面的综合能力。实验设置中，AgentFlow的四个核心模块（规划器、执行器、验证器、生成器）均基于Qwen2.5-7B-Instruct模型构建 。这种统一的基座模型选择，使得实验结果能够更纯粹地反映出AgentFlow框架本身所带来的性能增益，而非模型基础能力的差异。全面的领先结果表明，AgentFlow的模块化协作模式和Flow-GRPO训练方法具有强大的泛化能力，能够适应多种不同类型的复杂任务，展现出其作为一种通用问题求解框架的巨大潜力。

#### 3.1.2 具体任务提升：搜索、智能体、数学、科学任务

在具体的任务类别上，AgentFlow的性能提升尤为明显。根据官方发布的数据，AgentFlow在各类任务上相较于基线模型的平均准确率提升如下表所示 ：

| 任务类别 | 平均准确率提升 |
| :--- | :--- |
| 搜索 (Search) | **+14.9%** |
| 智能体推理 (Agentic) | **+14.0%** |
| 数学 (Math) | **+14.5%** |
| 科学 (Science) | **+4.1%** |

*Table 2: AgentFlow在各类任务上的平均性能提升。*

从上表可以看出，AgentFlow在搜索、智能体推理和数学任务上的提升幅度均超过了14个百分点，这是一个非常显著的改进。这表明AgentFlow在处理需要信息检索、多步规划和精确计算的任务时，其优势最为突出。即使在科学任务上，其提升也达到了4.1%，证明了其在处理需要专业知识和严谨逻辑的领域同样有效。这些量化的数据强有力地证明了AgentFlow框架在解决实际问题方面的优越性。

#### 3.1.3 与顶尖模型的对比：超越GPT-4o等大型专有模型

最令人印象深刻的是，AgentFlow（Qwen2.5-7B-Backbone）在多项任务上的表现，甚至超过了参数量约为其30倍的顶尖专有模型GPT-4o 。这一结果颠覆了过去“模型越大，性能越强”的传统认知。它清晰地表明，在解决复杂推理任务时，一个经过精心设计的、能够有效利用工具并进行结构化协作的系统，其潜力远未被充分挖掘。AgentFlow的成功，为AI领域指明了一个新的发展方向：与其一味地追求模型参数的规模化，不如更多地关注系统层面的创新，通过更智能的架构和训练方法来激发模型的潜能。这一对比结果，不仅是AgentFlow框架的胜利，更是多智能体系统和强化学习在AI领域应用前景的有力证明。

### 3.2 小模型超越大模型的原因分析

AgentFlow能够以小博大，其根本原因在于系统性的设计优势，而非单一技术的突破。这种优势主要体现在系统设计优于参数堆砌、专业化分工提升效率以及强化学习优化决策策略三个方面。

#### 3.2.1 系统设计优于参数堆砌

传统的AI发展路径在很大程度上依赖于“规模定律”（Scaling Law），即通过增加模型参数量、数据量和计算量来提升性能。然而，这种方法面临着边际效益递减和成本急剧上升的挑战。AgentFlow则走上了一条不同的道路，它通过精巧的系统设计，实现了“1+1>2”的效果。它将一个复杂的任务分解为多个更简单的子任务，并由专门的模块来处理。这种模块化的架构，使得每个模块可以专注于自己擅长的领域，从而提高了整个系统的效率和准确性。例如，规划器可以专注于逻辑推理和决策，而无需关心具体的工具实现细节；执行器则可以专注于准确地调用工具，而无需理解整个任务的宏观目标。这种分工协作的模式，使得系统能够以更低的成本（更小的模型）实现更高的性能，证明了在AI领域，智慧的设计有时比蛮力的堆砌更为重要。

#### 3.2.2 专业化分工提升效率

AgentFlow的四大模块（规划器、执行器、验证器、生成器）各自承担着明确的、专业化的职责，这种分工极大地提升了系统的整体运行效率 。在单体大模型中，所有这些功能（规划、执行、验证、生成）都混杂在一个巨大的神经网络中，模型需要在生成每一个token时，都同时考虑所有这些方面，这无疑增加了模型的认知负荷和出错概率。而在AgentFlow中，规划器只需要关心“下一步该做什么”，执行器只需要关心“如何正确地执行”，验证器只需要关心“结果是否正确”。这种清晰的职责划分，不仅降低了每个模块的复杂性，也使得系统更容易进行调试和优化。例如，如果发现工具调用经常出错，可以针对性地优化执行器或验证器，而无需对整个庞大的模型进行重新训练。这种专业化的分工，使得AgentFlow能够以更高的效率和更低的错误率来完成复杂任务。

#### 3.2.3 强化学习优化决策策略

AgentFlow成功的另一个关键，是其采用了Flow-GRPO这一创新的强化学习算法，对核心的规划器模块进行了在线优化 。传统的监督学习方法通常依赖于大量标注好的“思考链”（Chain-of-Thought）数据来训练模型，这种方法不仅成本高昂，而且难以覆盖所有可能的推理路径。Flow-GRPO则通过一种“边做边学”的方式，让规划器在与环境的实时交互中学习最优的决策策略。它将一个长时序的、稀疏奖励的复杂问题，转化为一系列简单的、单轮的优化问题，极大地降低了训练的难度 。通过这种方式，规划器能够学习到在不同情境下，选择何种工具、采取何种策略才能最大化最终任务成功的概率。这种通过强化学习获得的决策能力，是AgentFlow能够超越那些仅依靠预训练知识、缺乏动态学习能力的单体大模型的核心原因之一。

## 4. 未来发展与挑战

尽管AgentFlow框架在解决复杂推理任务方面取得了显著的突破，并展示了以小博大的巨大潜力，但作为一个前沿的研究方向，它仍然面临着一些固有的局限性和挑战。同时，这些局限性也为未来的研究指明了清晰的发展方向。本章节将探讨AgentFlow当前面临的主要挑战，并展望其未来的发展前景。

### 4.1 当前局限性与挑战

AgentFlow的当前实现虽然在性能上取得了巨大成功，但在系统设计的完备性、训练效率和奖励机制的精细度方面，仍有提升空间。

#### 4.1.1 模块优化局限：仅规划器参与训练

在AgentFlow的当前版本中，只有核心的规划器（Planner）模块通过Flow-GRPO算法进行了在线训练，而执行器（Executor）、验证器（Verifier）和生成器（Generator）等其他模块在训练过程中是保持冻结的 。这种设计简化了训练流程，并避免了多模块联合优化可能带来的不稳定性。然而，这也意味着系统的其他部分无法从与环境的交互中进行学习和改进。例如，验证器的能力是固定的，它可能无法识别出一些新颖的或复杂的错误模式；执行器也无法学习如何更高效地调用工具或处理异常情况。未来的一个关键发展方向是探索如何对所有模块进行联合优化，让系统能够端到端地进行学习和进化，从而进一步提升整体的协调能力和性能上限 。

#### 4.1.2 训练成本：多轮在线强化学习的计算开销

AgentFlow采用的在线强化学习方法，虽然有效，但其计算开销不容小觑。训练过程需要模型与环境进行大量的多轮交互（rollouts）来收集训练数据，这个过程相比于传统的离线监督学习要耗时得多 。每一次训练迭代都需要完整地运行一个或多个任务实例，这涉及到多次大模型的推理调用，尤其是在处理长时序任务时，计算成本会急剧增加。尽管Flow-GRPO算法通过其奖励广播机制在一定程度上提升了训练效率，但如何进一步降低训练成本，使其能够更高效地扩展到更大规模的模型和更复杂的任务，仍然是一个亟待解决的挑战。未来的研究可以探索更高效的采样策略、模型蒸馏或迁移学习等方法，以降低AgentFlow的训练门槛。

#### 4.1.3 奖励设计：依赖单一结果奖励

Flow-GRPO算法目前主要依赖于一个基于最终任务成败的单一、稀疏的奖励信号 。这种设计虽然简洁且避免了手动设计复杂奖励函数的麻烦，但也存在一定的局限性。首先，它无法对任务执行过程中的中间步骤进行精细的评估。例如，一个任务可能因为最后一步的微小错误而失败，但前面的许多步骤可能都是正确且有价值的，而当前的奖励机制会将这些步骤都标记为“失败”，这可能会误导规划器的学习。其次，对于一些没有明确对错答案的开放性任务（如创意写作、开放式问答），设计一个可靠的、可自动验证的最终结果奖励本身就非常困难。因此，未来的研究需要探索更精细、更多样化的奖励设计方法，例如引入基于过程的奖励（process-based rewards）、人类反馈（human feedback）或更复杂的、能够评估中间步骤质量的奖励模型 。

### 4.2 未来发展方向

面对上述挑战，AgentFlow的未来发展可以从框架扩展、系统优化和奖励机制改进等多个维度展开，以期构建一个更强大、更通用、更高效的智能体系统。

#### 4.2.1 框架扩展：多模态与开放式领域

目前的AgentFlow主要专注于基于文本的推理任务。未来的一个重要方向是将其扩展到多模态领域，例如视觉-语言任务 。这意味着系统需要能够处理和整合来自图像、视频、音频等多种模态的信息，并能够调用相应的多模态工具（如图像识别、视频分析模型）。这将极大地拓宽AgentFlow的应用范围，使其能够处理更贴近真实世界的复杂问题，如机器人控制、自动驾驶、多媒体内容创作等。此外，将AgentFlow应用于更开放的、没有明确终点的领域，如持续学习和终身学习，也是一个充满潜力的研究方向。

#### 4.2.2 系统优化：联合优化所有模块

如前所述，当前仅优化规划器的模式限制了系统的整体进化潜力。未来的一个核心研究课题是探索如何对AgentFlow的所有模块（规划器、执行器、验证器、生成器）进行联合优化 。这需要一个更复杂的训练框架，能够处理多模块之间的相互依赖和潜在的冲突。可能的解决方案包括采用多智能体强化学习（Multi-Agent Reinforcement Learning）的方法，将每个模块视为一个独立的智能体，并设计合适的协作和通信机制来引导它们共同学习。实现所有模块的联合优化，有望使AgentFlow系统达到一个全新的智能水平，实现真正的端到端自适应和进化。

#### 4.2.3 奖励机制改进：引入更细粒度的反馈

为了克服单一稀疏奖励的局限性，未来的研究需要设计更精细、更多样化的奖励机制 。这可能包括：
*   **过程奖励（Process Rewards）** ：为任务执行过程中的关键中间步骤设计可自动验证的奖励，以引导模型学习更优的推理路径。
*   **人类反馈（Human Feedback）** ：引入基于人类偏好的奖励模型（如RLHF），让系统能够学习人类的价值观和偏好，从而更好地处理开放性、主观性强的任务。
*   **自适应奖励塑形（Adaptive Reward Shaping）** ：设计能够根据学习进度动态调整的奖励函数，以加速训练过程并避免陷入局部最优。
通过引入这些更细粒度的反馈信号，AgentFlow将能够学习到更鲁棒、更通用的问题求解策略，从而在更广泛的任务中表现出色。

讨论回复

1 条回复

QianXun (QianXun) #1

10-25 15:49

                                        <!DOCTYPE html>
<html lang="zh-CN">

  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AgentFlow框架深度研究：小模型如何超越大模型</title>
    <script src="https://cdn.tailwindcss.com"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/js/all.min.js"></script>
    <link href="https://fonts.googleapis.com/css2?family=Crimson+Text:ital,wght@0,400;0,600;1,400&family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
    <style>
        :root {
            --color-primary: #1e293b;
            --color-secondary: #475569;
            --color-accent: #059669;
            --color-muted: #64748b;
            --color-background: #f8fafc;
            --color-surface: #ffffff;
            --color-border: #e2e8f0;
            --color-highlight: #fef3c7;
        }
        
        body {
            font-family: 'Inter', sans-serif;
            line-height: 1.7;
            color: var(--color-primary);
            background-color: var(--color-background);
        }
        
        .serif {
            font-family: 'Crimson Text', serif;
        }
        
        .toc {
            position: fixed;
            left: 0;
            top: 0;
            width: 280px;
            height: 100vh;
            background: var(--color-surface);
            border-right: 1px solid var(--color-border);
            overflow-y: auto;
            z-index: 50;
            padding: 2rem 1.5rem;
            box-shadow: 2px 0 10px rgba(0,0,0,0.05);
        }
        
        .main-content {
            margin-left: 280px;
            min-height: 100vh;
        }
        
        .hero-section {
            background: linear-gradient(135deg, #0f172a 0%, #1e293b 50%, #334155 100%);
            color: white;
            position: relative;
            overflow: hidden;
        }
        
        .hero-overlay {
            position: absolute;
            inset: 0;
            background: rgba(0,0,0,0.4);
            z-index: 1;
        }
        
        .hero-content {
            position: relative;
            z-index: 2;
        }
        
        .bento-grid {
            display: grid;
            grid-template-columns: 2fr 1fr;
            gap: 2rem;
            align-items: start;
        }
        
        .chart-container {
            background: var(--color-surface);
            border-radius: 12px;
            padding: 2rem;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
            border: 1px solid var(--color-border);
            margin: 2rem 0;
        }
        
        .citation {
            color: var(--color-accent);
            text-decoration: none;
            font-weight: 500;
            border-bottom: 1px dotted var(--color-accent);
            transition: all 0.2s ease;
        }
        
        .citation:hover {
            background-color: var(--color-highlight);
            padding: 0 2px;
            border-radius: 3px;
        }
        
        .highlight-box {
            background: linear-gradient(135deg, var(--color-highlight) 0%, #fde68a 100%);
            border-left: 4px solid var(--color-accent);
            padding: 1.5rem;
            margin: 2rem 0;
            border-radius: 0 8px 8px 0;
        }
        
        .module-card {
            background: var(--color-surface);
            border-radius: 12px;
            padding: 1.5rem;
            border: 1px solid var(--color-border);
            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
            transition: all 0.3s ease;
        }
        
        .module-card:hover {
            box-shadow: 0 8px 25px rgba(0,0,0,0.1);
            transform: translateY(-2px);
        }
        
        .toc a {
            display: block;
            padding: 0.5rem 0;
            color: var(--color-secondary);
            text-decoration: none;
            border-left: 3px solid transparent;
            padding-left: 1rem;
            margin-left: -1rem;
            transition: all 0.2s ease;
        }
        
        .toc a:hover,
        .toc a.active {
            color: var(--color-accent);
            border-left-color: var(--color-accent);
            background-color: rgba(5, 150, 105, 0.05);
        }
        
        .section-divider {
            height: 1px;
            background: linear-gradient(90deg, transparent 0%, var(--color-border) 50%, transparent 100%);
            margin: 4rem 0;
        }
        
        .performance-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 1.5rem;
            margin: 2rem 0;
        }
        
        .performance-card {
            background: var(--color-surface);
            border-radius: 8px;
            padding: 1.5rem;
            text-align: center;
            border: 1px solid var(--color-border);
            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
        }
        
        /* Mermaid diagram styling */
        .mermaid-container {
            display: flex;
            justify-content: center;
            min-height: 300px;
            max-height: 800px;
            background: var(--color-surface);
            border: 2px solid var(--color-border);
            border-radius: 12px;
            padding: 30px;
            margin: 30px 0;
            box-shadow: 0 8px 25px rgba(0, 0, 0, 0.08);
            position: relative;
            overflow: hidden;
        }

        .mermaid-container .mermaid {
            width: 100%;
            max-width: 100%;
            height: 100%;
            cursor: grab;
            transition: transform 0.3s ease;
            transform-origin: center center;
            display: flex;
            justify-content: center;
            align-items: center;
            touch-action: none; /* 防止触摸设备上的默认行为 */
            -webkit-user-select: none; /* 防止文本选择 */
            -moz-user-select: none;
            -ms-user-select: none;
            user-select: none;
        }

        .mermaid-container .mermaid svg {
            max-width: 100%;
            height: 100%;
            display: block;
            margin: 0 auto;
        }

        .mermaid-container .mermaid:active {
            cursor: grabbing;
        }

        .mermaid-container.zoomed .mermaid {
            height: 100%;
            width: 100%;
            cursor: grab;
        }

        .mermaid-controls {
            position: absolute;
            top: 15px;
            right: 15px;
            display: flex;
            gap: 10px;
            z-index: 20;
            background: rgba(255, 255, 255, 0.95);
            padding: 8px;
            border-radius: 8px;
            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
        }

        .mermaid-control-btn {
            background: #ffffff;
            border: 1px solid var(--color-border);
            border-radius: 6px;
            padding: 10px;
            cursor: pointer;
            transition: all 0.2s ease;
            color: var(--color-primary);
            font-size: 14px;
            min-width: 36px;
            height: 36px;
            text-align: center;
            display: flex;
            align-items: center;
            justify-content: center;
        }

        .mermaid-control-btn:hover {
            background: #f8fafc;
            border-color: #3b82f6;
            color: #3b82f6;
            transform: translateY(-1px);
        }

        .mermaid-control-btn:active {
            transform: scale(0.95);
        }

        /* Enhanced mermaid node styling for better contrast */
        .mermaid .node rect,
        .mermaid .node circle,
        .mermaid .node ellipse,
        .mermaid .node polygon {
            stroke-width: 2px !important;
        }
        
        .mermaid .node text {
            font-weight: 500 !important;
            font-size: 14px !important;
        }
        
        .mermaid .edgeLabel {
            background-color: var(--color-surface) !important;
            border: 1px solid var(--color-border) !important;
            border-radius: 4px !important;
            padding: 2px 6px !important;
            font-size: 12px !important;
        }
        
        <span class="mention-invalid">@media</span> (max-width: 1024px) {
            .toc {
                display: none;
            }
            .main-content {
                margin-left: 0;
            }
            .bento-grid {
                grid-template-columns: 1fr;
            }

            .mermaid-control-btn:not(.reset-zoom) {
                display: none;
            }
            .mermaid-controls {
                top: auto;
                bottom: 15px;
                right: 15px;
            }
        }

        <span class="mention-invalid">@media</span> (max-width: 767px) {
            .bento-grid > div:first-child h1 {
                font-size: 2.25rem;
                line-height: 2.5rem;
            }
            .bento-grid > div:first-child p {
                font-size: 1.125rem;
            }
            .performance-grid,
            .grid.md\:grid-cols-2,
            .grid.md\:grid-cols-3,
            .grid.md\:grid-cols-4 {
                grid-template-columns: 1fr;
            }
            section {
                padding-left: 1rem;
                padding-right: 1rem;
            }
            .bento-grid {
                gap: 1rem;
            }
        }
    </style>
  <base target="_blank">
</head>

  <body>
    <!-- Table of Contents -->
    <nav class="toc">
      <h3 class="text-lg font-semibold mb-4 text-gray-800">目录</h3>
      <a href="#hero" class="active">概述</a>
      <a href="#technical-details">技术实现细节</a>
      <a href="#core-architecture">核心架构</a>
      <a href="#flow-grpo">Flow-GRPO训练</a>
      <a href="#applications">应用场景与优势</a>
      <a href="#performance">实验结果</a>
      <a href="#analysis">原因分析</a>
      <a href="#future">未来发展与挑战</a>
      <a href="#limitations">当前局限</a>
      <a href="#directions">发展方向</a>
    </nav>

    <!-- Main Content -->
    <main class="main-content">
      <!-- Hero Section -->
      <section id="hero" class="hero-section py-16 px-8">
        <div class="hero-overlay"></div>
        <div class="hero-content max-w-6xl mx-auto">
          <div class="bento-grid">
            <div class="space-y-6">
              <div class="inline-block px-4 py-2 bg-white/20 backdrop-blur-sm rounded-full text-sm font-medium">
                深度研究 · 技术创新
              </div>
              <h1 class="serif text-5xl font-bold leading-tight italic">
                AgentFlow框架：
                <span class="text-emerald-300">小模型如何超越大模型</span>
              </h1>
              <p class="text-xl text-gray-200 leading-relaxed max-w-3xl break-words">
                通过创新的模块化协作模式和Flow-GRPO在线强化学习算法，AgentFlow实现了7B参数模型在复杂推理任务上超越GPT-4o等顶尖大模型的突破性成果。
              </p>
            </div>

            <div class="bg-white/10 backdrop-blur-sm rounded-2xl p-6 border border-white/20">
              <h3 class="text-lg font-semibold mb-4 text-emerald-200">核心亮点</h3>
              <div class="space-y-4 text-sm">
                <div class="flex items-center space-x-3">
                  <i class="fas fa-cogs text-emerald-400"></i>
                  <span>模块化四组件架构</span>
                </div>
                <div class="flex items-center space-x-3">
                  <i class="fas fa-brain text-emerald-400"></i>
                  <span>Flow-GRPO训练算法</span>
                </div>
                <div class="flex items-center space-x-3">
                  <i class="fas fa-chart-line text-emerald-400"></i>
                  <span>14.9%性能提升</span>
                </div>
                <div class="flex items-center space-x-3">
                  <i class="fas fa-microchip text-emerald-400"></i>
                  <span>7B vs 200B参数对比</span>
                </div>
              </div>
            </div>
          </div>

          <!-- Key Metrics Grid -->
          <div class="grid grid-cols-2 md:grid-cols-4 gap-6 mt-12">
            <div class="bg-white/10 backdrop-blur-sm rounded-xl p-4 text-center border border-white/20">
              <div class="text-3xl font-bold text-emerald-300">14.9%</div>
              <div class="text-sm text-gray-300">搜索任务提升</div>
            </div>
            <div class="bg-white/10 backdrop-blur-sm rounded-xl p-4 text-center border border-white/20">
              <div class="text-3xl font-bold text-emerald-300">14.0%</div>
              <div class="text-sm text-gray-300">智能体推理提升</div>
            </div>
            <div class="bg-white/10 backdrop-blur-sm rounded-xl p-4 text-center border border-white/20">
              <div class="text-3xl font-bold text-emerald-300">28%</div>
              <div class="text-sm text-gray-300">错误调用减少</div>
            </div>
            <div class="bg-white/10 backdrop-blur-sm rounded-xl p-4 text-center border border-white/20">
              <div class="text-3xl font-bold text-emerald-300">7B</div>
              <div class="text-sm text-gray-300">参数规模</div>
            </div>
          </div>
        </div>
      </section>

      <!-- Technical Implementation Details -->
      <section id="technical-details" class="py-16 px-8 bg-white">
        <div class="max-w-6xl mx-auto">
          <h2 class="serif text-4xl font-bold mb-8 text-center">技术实现细节</h2>

          <div class="prose prose-lg max-w-none">
            <p class="text-xl text-gray-600 text-center mb-12">
              AgentFlow框架的核心技术突破在于其创新的模块化系统架构和专为该系统设计的Flow-GRPO训练算法。
            </p>

            <!-- Core Architecture -->
            <div id="core-architecture" class="mb-16">
              <h3 class="serif text-3xl font-semibold mb-6">核心架构：四大模块的协作模式</h3>

              <!-- Mermaid Diagram -->
              <div class="mermaid-container">
                <div class="mermaid-controls">
                  <button class="mermaid-control-btn zoom-in" title="放大">
                    <i class="fas fa-search-plus"></i>
                  </button>
                  <button class="mermaid-control-btn zoom-out" title="缩小">
                    <i class="fas fa-search-minus"></i>
                  </button>
                  <button class="mermaid-control-btn reset-zoom" title="重置">
                    <i class="fas fa-expand-arrows-alt"></i>
                  </button>
                  <button class="mermaid-control-btn fullscreen" title="全屏查看">
                    <i class="fas fa-expand"></i>
                  </button>
                </div>
                <div class="mermaid">
                  graph LR
                  A["用户查询 Query"] --> B["规划器 Planner"]
                  B --> C["执行器 Executor"]
                  C --> D["验证器 Verifier"]
                  D --> E{"验证结果"}
                  E -->|"继续"| B
                  E -->|"完成"| F["生成器 Generator"]
                  F --> G["最终答案"]

                  H["演进式记忆 Evolving Memory"] -.-> B
                  H -.-> C
                  H -.-> D
                  H -.-> F

                  style B fill:#e0f2fe,stroke:#0277bd,stroke-width:3px,color:#01579b
                  style C fill:#f3e5f5,stroke:#7b1fa2,stroke-width:3px,color:#4a148c
                  style D fill:#e8f5e8,stroke:#2e7d32,stroke-width:3px,color:#1b5e20
                  style F fill:#fff3e0,stroke:#ef6c00,stroke-width:3px,color:#e65100
                  style H fill:#fce4ec,stroke:#c2185b,stroke-width:3px,color:#880e4f
                  style A fill:#f8fafc,stroke:#475569,stroke-width:2px,color:#1e293b
                  style G fill:#f8fafc,stroke:#475569,stroke-width:2px,color:#1e293b
                  style E fill:#f8fafc,stroke:#475569,stroke-width:2px,color:#1e293b
                </div>
              </div>

              <div class="grid md:grid-cols-2 gap-6 mb-8">
                <div class="module-card">
                  <div class="flex items-center mb-4">
                    <i class="fas fa-brain text-2xl text-blue-600 mr-3"></i>
                    <h4 class="text-xl font-semibold">规划器 (Planner)</h4>
                  </div>
                  <p class="text-gray-600 mb-3"><strong>角色：</strong>大脑 / 指挥官</p>
                  <p class="text-gray-600 mb-3"><strong>职责：</strong>制定行动计划，选择工具，是<strong>唯一可训练的模块</strong>
                    <a href="https://medium.com/<span class="mention-invalid">@huguosuo</span>/in-the-flow-agentic-system-optimization-for-effective-planning-and-tool-use-d204898f02e6" class="citation">[100]</a>。
                  </p>
                </div>

                <div class="module-card">
                  <div class="flex items-center mb-4">
                    <i class="fas fa-hands text-2xl text-purple-600 mr-3"></i>
                    <h4 class="text-xl font-semibold">执行器 (Executor)</h4>
                  </div>
                  <p class="text-gray-600 mb-3"><strong>角色：</strong>双手 / 行动臂</p>
                  <p class="text-gray-600 mb-3"><strong>职责：</strong>忠实执行规划器的指令，调用具体工具并获取结果
                    <a href="https://arxiv.org/pdf/2510.05592" class="citation">[97]</a>。
                  </p>
                </div>

                <div class="module-card">
                  <div class="flex items-center mb-4">
                    <i class="fas fa-check-circle text-2xl text-green-600 mr-3"></i>
                    <h4 class="text-xl font-semibold">验证器 (Verifier)</h4>
                  </div>
                  <p class="text-gray-600 mb-3"><strong>角色：</strong>质检员 / 反馈者</p>
                  <p class="text-gray-600 mb-3"><strong>职责：</strong>分析执行结果的有效性，提供反馈，控制流程继续或停止
                    <a href="https://arxiv.org/pdf/2510.05592" class="citation">[97]</a>。
                  </p>
                </div>

                <div class="module-card">
                  <div class="flex items-center mb-4">
                    <i class="fas fa-database text-2xl text-red-600 mr-3"></i>
                    <h4 class="text-xl font-semibold">演进式记忆</h4>
                  </div>
                  <p class="text-gray-600 mb-3"><strong>角色：</strong>中枢神经系统</p>
                  <p class="text-gray-600 mb-3"><strong>职责：</strong>记录所有交互信息，为所有模块提供共享的、动态更新的上下文
                    <a href="https://medium.com/<span class="mention-invalid">@huguosuo</span>/in-the-flow-agentic-system-optimization-for-effective-planning-and-tool-use-d204898f02e6" class="citation">[100]</a>。
                  </p>
                </div>
              </div>

              <div class="highlight-box">
                <h4 class="font-semibold mb-3">协作流程公式</h4>
                <p class="font-mono text-center text-lg">M_{t+1} = f_mem(M_t, a_t, e_t, v_t)</p>
                <p class="text-sm mt-2 text-gray-600">记忆更新函数，其中M_t是当前记忆状态，a_t是规划器行动，e_t是执行器结果，v_t是验证器反馈<a href="https://arxiv.org/pdf/2510.05592" class="citation">[97]</a>。</p>
              </div>
            </div>

            <!-- Flow-GRPO Training -->
            <div id="flow-grpo" class="mb-16">
              <h3 class="serif text-3xl font-semibold mb-6">Flow-GRPO：解决长时序信用分配难题的训练方法</h3>

              <div class="bg-gray-50 rounded-xl p-8 mb-8">
                <h4 class="text-xl font-semibold mb-4">核心思想：将多轮优化转化为单轮更新</h4>
                <p class="mb-4">Flow-GRPO算法的核心在于其独特的信用分配策略。它采用了一种简洁而鲁棒的方法：<strong>将整个任务轨迹的最终结果（成功或失败）作为唯一的奖励信号，并将其"广播"到该轨迹中的每一个决策步骤</strong>
                  <a href="https://zhuanlan.zhihu.com/p/1960844370321347350" class="citation">[98]</a>。
                </p>

                <div class="bg-white rounded-lg p-6 border-l-4 border-emerald-500">
                  <h5 class="font-semibold mb-2">奖励广播机制</h5>
                  <p class="font-mono mb-2">R(a_t) = R(o, q, y*), ∀t = 1,...,T</p>
                  <p class="text-sm text-gray-600">其中R(o, q, y*)是基于最终答案的全局奖励信号<a href="https://arxiv.org/pdf/2510.05592" class="citation">[97]</a>
                  </p>
                </div>
              </div>

              <!-- Training Algorithm -->
              <div class="module-card">
                <h4 class="text-xl font-semibold mb-4">训练流程</h4>
                <ol class="list-decimal list-inside space-y-3 text-gray-600">
                  <li><strong>在交互"流"中生成轨迹：</strong>对于每个查询-答案对，启动AgentFlow实例，生成完整的任务执行轨迹
                    <a href="https://arxiv.org/pdf/2510.05592" class="citation">[97]</a>。
                  </li>
                  <li><strong>奖励计算：</strong>根据最终答案与标准答案的比较结果，计算全局奖励信号，并广播给轨迹中的所有行动。</li>
                  <li><strong>策略更新：</strong>使用Flow-GRPO目标函数更新规划器的策略参数，确保训练稳定性。</li>
                </ol>
              </div>
            </div>
          </div>
        </div>
      </section>

      <div class="section-divider"></div>

      <!-- Applications and Advantages -->
      <section id="applications" class="py-16 px-8 bg-gray-50">
        <div class="max-w-6xl mx-auto">
          <h2 class="serif text-4xl font-bold mb-8 text-center">应用场景与优势</h2>

          <div class="mb-12">
            <h3 class="serif text-3xl font-semibold mb-6">应用场景：复杂推理与工具调用任务</h3>

            <div class="grid md:grid-cols-3 gap-8">
              <div class="module-card">
                <div class="flex items-center mb-4">
                  <i class="fas fa-search text-2xl text-blue-600 mr-3"></i>
                  <h4 class="text-xl font-semibold">搜索与信息整合</h4>
                </div>
                <p class="text-gray-600 mb-4">AgentFlow能够主动将复杂问题分解为多个子查询，调用搜索引擎和百科全书获取最新信息，性能提升<strong>14.9%</strong>
                  <a href="https://github.com/lupantech/AgentFlow" class="citation">[78]</a>。
                </p>
              </div>

              <div class="module-card">
                <div class="flex items-center mb-4">
                  <i class="fas fa-calculator text-2xl text-green-600 mr-3"></i>
                  <h4 class="text-xl font-semibold">数学与科学计算</h4>
                </div>
                <p class="text-gray-600 mb-4">通过调用代码解释器执行精确计算，并利用验证器检查结果正确性，数学任务提升<strong>14.5%</strong>，科学任务提升<strong>4.1%</strong>
                  <a href="https://github.com/lupantech/AgentFlow" class="citation">[78]</a>。
                </p>
              </div>

              <div class="module-card">
                <div class="flex items-center mb-4">
                  <i class="fas fa-robot text-2xl text-purple-600 mr-3"></i>
                  <h4 class="text-xl font-semibold">多步智能体推理</h4>
                </div>
                <p class="text-gray-600 mb-4">在需要长期规划和自适应能力的任务中，AgentFlow通过结构化协作实现性能提升<strong>14.0%</strong>
                  <a href="https://github.com/lupantech/AgentFlow" class="citation">[78]</a>。
                </p>
              </div>
            </div>
          </div>

          <div>
            <h3 class="serif text-3xl font-semibold mb-6">核心优势：系统性超越单体大模型</h3>

            <div class="space-y-8">
              <div class="highlight-box">
                <h4 class="font-semibold mb-3">结构化协作 vs. 单体黑箱</h4>
                <p>AgentFlow的模块化设计将整个推理过程分解为清晰、可追踪的步骤，提高了系统的透明度和可解释性，支持"人在回路"的交互模式<a href="https://medium.com/<span class="mention-invalid">@huguosuo</span>/in-the-flow-agentic-system-optimization-for-effective-planning-and-tool-use-d204898f02e6" class="citation">[100]</a>。</p>
              </div>

              <div class="highlight-box">
                <h4 class="font-semibold mb-3">动态规划与自适应能力</h4>
                <p>通过多轮交互循环，AgentFlow实现了真正的动态规划和"边做边学"的能力，能够灵活应对各种意外情况和复杂约束<a href="https://medium.com/<span class="mention-invalid">@huguosuo</span>/in-the-flow-agentic-system-optimization-for-effective-planning-and-tool-use-d204898f02e6" class="citation">[100]</a>。</p>
              </div>

              <div class="highlight-box">
                <h4 class="font-semibold mb-3">工具调用的可靠性与效率提升</h4>
                <p>通过专业化分工和Flow-GRPO训练，AgentFlow将错误和冗余的工具调用减少高达<strong>28%</strong>
                  <a href="https://medium.com/<span class="mention-invalid">@huguosuo</span>/in-the-flow-agentic-system-optimization-for-effective-planning-and-tool-use-d204898f02e6" class="citation">[100]</a>。
                </p>
              </div>
            </div>
          </div>
        </div>
      </section>

      <div class="section-divider"></div>

      <!-- Experimental Results -->
      <section id="performance" class="py-16 px-8 bg-white">
        <div class="max-w-6xl mx-auto">
          <h2 class="serif text-4xl font-bold mb-8 text-center">实验结果与分析</h2>

          <!-- Performance Overview -->
          <div class="mb-12">
            <h3 class="serif text-3xl font-semibold mb-6">基准测试表现：全面领先</h3>

            <div class="performance-grid">
              <div class="performance-card">
                <div class="text-3xl font-bold text-emerald-600 mb-2">10/10</div>
                <div class="text-sm text-gray-600 mb-4">基准测试数量</div>
                <div class="text-xs text-gray-500">全面超越顶尖基线</div>
              </div>

              <div class="performance-card">
                <div class="text-3xl font-bold text-blue-600 mb-2">14.9%</div>
                <div class="text-sm text-gray-600 mb-4">搜索任务提升</div>
                <div class="text-xs text-gray-500">信息检索能力</div>
              </div>

              <div class="performance-card">
                <div class="text-3xl font-bold text-purple-600 mb-2">14.0%</div>
                <div class="text-sm text-gray-600 mb-4">智能体推理提升</div>
                <div class="text-xs text-gray-500">多步规划能力</div>
              </div>

              <div class="performance-card">
                <div class="text-3xl font-bold text-green-600 mb-2">7B</div>
                <div class="text-sm text-gray-600 mb-4">参数规模</div>
                <div class="text-xs text-gray-500">vs GPT-4o (200B)</div>
              </div>
            </div>
          </div>

          <!-- Performance Comparison Chart -->
          <div class="chart-container">
            <h4 class="text-xl font-semibold mb-4 text-center">AgentFlow vs 基线模型性能对比</h4>
            <img src="https://kimi-img.moonshot.cn/pub/icon/spinner.svg" alt="AgentFlow框架性能对比图表，显示在搜索、智能体推理、数学和科学任务上的准确率提升" class="w-full" size="medium" aspect="wide" style="photo" query="AgentFlow性能对比图表" referrerpolicy="no-referrer" />
          </div>

          <!-- Detailed Task Performance -->
          <div class="mb-12">
            <h3 class="serif text-3xl font-semibold mb-6">具体任务提升</h3>

            <div class="grid md:grid-cols-2 gap-8">
              <div class="module-card">
                <h4 class="text-lg font-semibold mb-4">搜索任务 (+14.9%)</h4>
                <p class="text-gray-600 mb-4">在信息检索和整合方面表现出色，能够有效分解复杂查询并整合多源信息。</p>
                <div class="w-full bg-gray-200 rounded-full h-2">
                  <div class="bg-emerald-500 h-2 rounded-full" style="width: 85%"></div>
                </div>
              </div>

              <div class="module-card">
                <h4 class="text-lg font-semibold mb-4">数学任务 (+14.5%)</h4>
                <p class="text-gray-600 mb-4">通过代码解释器执行精确计算，结合验证器确保结果准确性。</p>
                <div class="w-full bg-gray-200 rounded-full h-2">
                  <div class="bg-blue-500 h-2 rounded-full" style="width: 84%"></div>
                </div>
              </div>

              <div class="module-card">
                <h4 class="text-lg font-semibold mb-4">智能体任务 (+14.0%)</h4>
                <p class="text-gray-600 mb-4">在多步推理和规划任务中展现强大能力，支持动态策略调整。</p>
                <div class="w-full bg-gray-200 rounded-full h-2">
                  <div class="bg-purple-500 h-2 rounded-full" style="width: 83%"></div>
                </div>
              </div>

              <div class="module-card">
                <h4 class="text-lg font-semibold mb-4">科学任务 (+4.1%)</h4>
                <p class="text-gray-600 mb-4">在需要专业知识和严谨逻辑的领域同样表现优异。</p>
                <div class="w-full bg-gray-200 rounded-full h-2">
                  <div class="bg-green-500 h-2 rounded-full" style="width: 73%"></div>
                </div>
              </div>
            </div>
          </div>

          <!-- Analysis Section -->
          <div id="analysis">
            <h3 class="serif text-3xl font-semibold mb-6">小模型超越大模型的原因分析</h3>

            <div class="space-y-8">
              <div class="module-card">
                <h4 class="text-xl font-semibold mb-4">系统设计优于参数堆砌</h4>
                <p class="mb-4">AgentFlow通过精巧的系统设计实现了"1+1>2"的效果，将复杂任务分解为专业模块处理，证明了智慧设计比蛮力堆砌更为重要。</p>
                <div class="bg-blue-50 border-l-4 border-blue-500 p-4 rounded-r">
                  <p class="text-sm"><strong>关键洞察：</strong>模块化架构使每个模块专注于自己擅长的领域，提高了整个系统的效率和准确性。</p>
                </div>
              </div>

              <div class="module-card">
                <h4 class="text-xl font-semibold mb-4">专业化分工提升效率</h4>
                <p class="mb-4">四大模块各自承担专业化职责，清晰的职责划分降低了每个模块的复杂性，使得系统更容易调试和优化<a href="https://medium.com/<span class="mention-invalid">@huguosuo</span>/in-the-flow-agentic-system-optimization-for-effective-planning-and-tool-use-d204898f02e6" class="citation">[100]</a>。</p>
                <div class="bg-green-50 border-l-4 border-green-500 p-4 rounded-r">
                  <p class="text-sm"><strong>效率提升：</strong>规划器专注决策，执行器专注行动，验证器专注质量检查，生成器专注结果输出。</p>
                </div>
              </div>

              <div class="module-card">
                <h4 class="text-xl font-semibold mb-4">强化学习优化决策策略</h4>
                <p class="mb-4">Flow-GRPO算法通过"边做边学"的方式，让规划器在实时交互中学习最优决策策略，这是超越单体大模型的核心原因<a href="https://arxiv.org/pdf/2510.05592" class="citation">[97]</a>。</p>
                <div class="bg-purple-50 border-l-4 border-purple-500 p-4 rounded-r">
                  <p class="text-sm"><strong>创新优势：</strong>将长时序稀疏奖励问题转化为单轮优化问题，极大降低了训练难度。</p>
                </div>
              </div>
            </div>
          </div>
        </div>
      </section>

      <div class="section-divider"></div>

      <!-- Future Development and Challenges -->
      <section id="future" class="py-16 px-8 bg-gray-50">
        <div class="max-w-6xl mx-auto">
          <h2 class="serif text-4xl font-bold mb-8 text-center">未来发展与挑战</h2>

          <!-- Current Limitations -->
          <div id="limitations" class="mb-16">
            <h3 class="serif text-3xl font-semibold mb-6">当前局限性与挑战</h3>

            <div class="grid md:grid-cols-3 gap-8">
              <div class="module-card">
                <div class="flex items-center mb-4">
                  <i class="fas fa-exclamation-triangle text-2xl text-orange-600 mr-3"></i>
                  <h4 class="text-xl font-semibold">模块优化局限</h4>
                </div>
                <p class="text-gray-600 mb-4">当前仅规划器参与训练，其他模块保持冻结，限制了系统的整体进化潜力<a href="https://medium.com/<span class="mention-invalid">@huguosuo</span>/in-the-flow-agentic-system-optimization-for-effective-planning-and-tool-use-d204898f02e6" class="citation">[100]</a>。</p>
              </div>

              <div class="module-card">
                <div class="flex items-center mb-4">
                  <i class="fas fa-clock text-2xl text-red-600 mr-3"></i>
                  <h4 class="text-xl font-semibold">训练成本高昂</h4>
                </div>
                <p class="text-gray-600 mb-4">在线强化学习需要大量多轮交互，计算开销大，训练时间长<a href="https://medium.com/<span class="mention-invalid">@huguosuo</span>/in-the-flow-agentic-system-optimization-for-effective-planning-and-tool-use-d204898f02e6" class="citation">[100]</a>。</p>
              </div>

              <div class="module-card">
                <div class="flex items-center mb-4">
                  <i class="fas fa-award text-2xl text-blue-600 mr-3"></i>
                  <h4 class="text-xl font-semibold">奖励设计单一</h4>
                </div>
                <p class="text-gray-600 mb-4">依赖单一结果奖励，无法对中间步骤进行精细评估，限制了对开放性任务的处理能力<a href="https://zhuanlan.zhihu.com/p/1960844370321347350" class="citation">[98]</a>。</p>
              </div>
            </div>
          </div>

          <!-- Future Directions -->
          <div id="directions">
            <h3 class="serif text-3xl font-semibold mb-6">未来发展方向</h3>

            <div class="space-y-8">
              <div class="module-card">
                <div class="flex items-center mb-4">
                  <i class="fas fa-expand-arrows-alt text-2xl text-emerald-600 mr-3"></i>
                  <h4 class="text-xl font-semibold">框架扩展：多模态与开放式领域</h4>
                </div>
                <p class="text-gray-600 mb-4">将AgentFlow扩展到多模态领域，处理视觉-语言任务，应用于机器人控制、自动驾驶等更复杂的真实世界问题<a href="https://medium.com/<span class="mention-invalid">@huguosuo</span>/in-the-flow-agentic-system-optimization-for-effective-planning-and-tool-use-d204898f02e6" class="citation">[100]</a>。</p>
                <div class="bg-emerald-50 border-l-4 border-emerald-500 p-4 rounded-r">
                  <p class="text-sm"><strong>应用前景：</strong>多媒体内容创作、持续学习、终身学习等开放领域。</p>
                </div>
              </div>

              <div class="module-card">
                <div class="flex items-center mb-4">
                  <i class="fas fa-cogs text-2xl text-blue-600 mr-3"></i>
                  <h4 class="text-xl font-semibold">系统优化：联合优化所有模块</h4>
                </div>
                <p class="text-gray-600 mb-4">探索对所有模块进行联合优化，采用多智能体强化学习方法，实现真正的端到端自适应和进化<a href="https://medium.com/<span class="mention-invalid">@huguosuo</span>/in-the-flow-agentic-system-optimization-for-effective-planning-and-tool-use-d204898f02e6" class="citation">[100]</a>。</p>
                <div class="bg-blue-50 border-l-4 border-blue-500 p-4 rounded-r">
                  <p class="text-sm"><strong>技术挑战：</strong>需要处理多模块之间的相互依赖和潜在冲突，设计合适的协作机制。</p>
                </div>
              </div>

              <div class="module-card">
                <div class="flex items-center mb-4">
                  <i class="fas fa-layer-group text-2xl text-purple-600 mr-3"></i>
                  <h4 class="text-xl font-semibold">奖励机制改进：引入更细粒度的反馈</h4>
                </div>
                <p class="text-gray-600 mb-4">设计更精细、更多样化的奖励机制，包括过程奖励、人类反馈、自适应奖励塑形等<a href="https://medium.com/<span class="mention-invalid">@huguosuo</span>/in-the-flow-agentic-system-optimization-for-effective-planning-and-tool-use-d204898f02e6" class="citation">[100]</a>。</p>
                <div class="bg-purple-50 border-l-4 border-purple-500 p-4 rounded-r">
                  <p class="text-sm"><strong>创新方向：</strong>评估中间步骤质量，学习人类价值观，加速训练过程。</p>
                </div>
              </div>
            </div>
          </div>
        </div>
      </section>

      <!-- Footer -->
      <footer class="bg-slate-900 text-white py-12 px-8">
        <div class="max-w-6xl mx-auto text-center">
          <h3 class="serif text-2xl font-semibold mb-4">AgentFlow：重新定义AI系统的未来</h3>
          <p class="text-gray-300 mb-6">通过创新的模块化架构和Flow-GRPO训练算法，AgentFlow证明了精巧的系统设计比单纯的参数堆砌更为有效。</p>
          <div class="flex justify-center space-x-8 text-sm text-gray-400">
            <span>技术创新 · 性能突破 · 系统优化</span>
          </div>
        </div>
      </footer>
    </main>

    <script>
        // Initialize Mermaid with enhanced styling
        mermaid.initialize({ 
            startOnLoad: true,
            theme: 'base',
            themeVariables: {
                primaryColor: '#f8fafc',
                primaryTextColor: '#1e293b',
                primaryBorderColor: '#334155',
                lineColor: '#475569',
                secondaryColor: '#e2e8f0',
                tertiaryColor: '#f1f5f9',
                background: '#ffffff',
                mainBkg: '#f8fafc',
                secondBkg: '#e2e8f0',
                tertiaryBkg: '#f1f5f9',
                nodeBorder: '#334155',
                clusterBkg: '#f8fafc',
                defaultLinkColor: '#475569',
                titleColor: '#1e293b',
                edgeLabelBackground: '#ffffff',
                nodeTextColor: '#1e293b'
            },
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis',
                padding: 20
            },
            fontFamily: 'Inter, sans-serif'
        });

        // Initialize Mermaid Controls for zoom and pan
        function initializeMermaidControls() {
            const containers = document.querySelectorAll('.mermaid-container');

            containers.forEach(container => {
            const mermaidElement = container.querySelector('.mermaid');
            let scale = 1;
            let isDragging = false;
            let startX, startY, translateX = 0, translateY = 0;

            // 触摸相关状态
            let isTouch = false;
            let touchStartTime = 0;
            let initialDistance = 0;
            let initialScale = 1;
            let isPinching = false;

            // Zoom controls
            const zoomInBtn = container.querySelector('.zoom-in');
            const zoomOutBtn = container.querySelector('.zoom-out');
            const resetBtn = container.querySelector('.reset-zoom');
            const fullscreenBtn = container.querySelector('.fullscreen');

            function updateTransform() {
                mermaidElement.style.transform = `translate(${translateX}px, ${translateY}px) scale(${scale})`;

                if (scale > 1) {
                container.classList.add('zoomed');
                } else {
                container.classList.remove('zoomed');
                }

                mermaidElement.style.cursor = isDragging ? 'grabbing' : 'grab';
            }

            if (zoomInBtn) {
                zoomInBtn.addEventListener('click', () => {
                scale = Math.min(scale * 1.25, 4);
                updateTransform();
                });
            }

            if (zoomOutBtn) {
                zoomOutBtn.addEventListener('click', () => {
                scale = Math.max(scale / 1.25, 0.3);
                if (scale <= 1) {
                    translateX = 0;
                    translateY = 0;
                }
                updateTransform();
                });
            }

            if (resetBtn) {
                resetBtn.addEventListener('click', () => {
                scale = 1;
                translateX = 0;
                translateY = 0;
                updateTransform();
                });
            }

            if (fullscreenBtn) {
                fullscreenBtn.addEventListener('click', () => {
                if (container.requestFullscreen) {
                    container.requestFullscreen();
                } else if (container.webkitRequestFullscreen) {
                    container.webkitRequestFullscreen();
                } else if (container.msRequestFullscreen) {
                    container.msRequestFullscreen();
                }
                });
            }

            // Mouse Events
            mermaidElement.addEventListener('mousedown', (e) => {
                if (isTouch) return; // 如果是触摸设备，忽略鼠标事件

                isDragging = true;
                startX = e.clientX - translateX;
                startY = e.clientY - translateY;
                mermaidElement.style.cursor = 'grabbing';
                updateTransform();
                e.preventDefault();
            });

            document.addEventListener('mousemove', (e) => {
                if (isDragging && !isTouch) {
                translateX = e.clientX - startX;
                translateY = e.clientY - startY;
                updateTransform();
                }
            });

            document.addEventListener('mouseup', () => {
                if (isDragging && !isTouch) {
                isDragging = false;
                mermaidElement.style.cursor = 'grab';
                updateTransform();
                }
            });

            document.addEventListener('mouseleave', () => {
                if (isDragging && !isTouch) {
                isDragging = false;
                mermaidElement.style.cursor = 'grab';
                updateTransform();
                }
            });

            // 获取两点之间的距离
            function getTouchDistance(touch1, touch2) {
                return Math.hypot(
                touch2.clientX - touch1.clientX,
                touch2.clientY - touch1.clientY
                );
            }

            // Touch Events - 触摸事件处理
            mermaidElement.addEventListener('touchstart', (e) => {
                isTouch = true;
                touchStartTime = Date.now();

                if (e.touches.length === 1) {
                // 单指拖动
                isPinching = false;
                isDragging = true;

                const touch = e.touches[0];
                startX = touch.clientX - translateX;
                startY = touch.clientY - translateY;

                } else if (e.touches.length === 2) {
                // 双指缩放
                isPinching = true;
                isDragging = false;

                const touch1 = e.touches[0];
                const touch2 = e.touches[1];
                initialDistance = getTouchDistance(touch1, touch2);
                initialScale = scale;
                }

                e.preventDefault();
            }, { passive: false });

            mermaidElement.addEventListener('touchmove', (e) => {
                if (e.touches.length === 1 && isDragging && !isPinching) {
                // 单指拖动
                const touch = e.touches[0];
                translateX = touch.clientX - startX;
                translateY = touch.clientY - startY;
                updateTransform();

                } else if (e.touches.length === 2 && isPinching) {
                // 双指缩放
                const touch1 = e.touches[0];
                const touch2 = e.touches[1];
                const currentDistance = getTouchDistance(touch1, touch2);

                if (initialDistance > 0) {
                    const newScale = Math.min(Math.max(
                    initialScale * (currentDistance / initialDistance),
                    0.3
                    ), 4);
                    scale = newScale;
                    updateTransform();
                }
                }

                e.preventDefault();
            }, { passive: false });

            mermaidElement.addEventListener('touchend', (e) => {
                // 重置状态
                if (e.touches.length === 0) {
                isDragging = false;
                isPinching = false;
                initialDistance = 0;

                // 延迟重置isTouch，避免鼠标事件立即触发
                setTimeout(() => {
                    isTouch = false;
                }, 100);
                } else if (e.touches.length === 1 && isPinching) {
                // 从双指变为单指，切换为拖动模式
                isPinching = false;
                isDragging = true;

                const touch = e.touches[0];
                startX = touch.clientX - translateX;
                startY = touch.clientY - translateY;
                }

                updateTransform();
            });

            mermaidElement.addEventListener('touchcancel', (e) => {
                isDragging = false;
                isPinching = false;
                initialDistance = 0;

                setTimeout(() => {
                isTouch = false;
                }, 100);

                updateTransform();
            });

            // Enhanced wheel zoom with better center point handling
            container.addEventListener('wheel', (e) => {
                e.preventDefault();
                const rect = container.getBoundingClientRect();
                const centerX = rect.width / 2;
                const centerY = rect.height / 2;

                const delta = e.deltaY > 0 ? 0.9 : 1.1;
                const newScale = Math.min(Math.max(scale * delta, 0.3), 4);

                // Adjust translation to zoom towards center
                if (newScale !== scale) {
                const scaleDiff = newScale / scale;
                translateX = translateX * scaleDiff;
                translateY = translateY * scaleDiff;
                scale = newScale;

                if (scale <= 1) {
                    translateX = 0;
                    translateY = 0;
                }

                updateTransform();
                }
            });

            // Initialize display
            updateTransform();
            });
        }

        // Initialize mermaid controls after mermaid renders
        setTimeout(initializeMermaidControls, 1000);

        // Smooth scrolling for anchor links
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                const target = document.querySelector(this.getAttribute('href'));
                if (target) {
                    target.scrollIntoView({
                        behavior: 'smooth',
                        block: 'start'
                    });
                }
            });
        });

        // Update active TOC item on scroll
        window.addEventListener('scroll', () => {
            const sections = document.querySelectorAll('section[id], div[id]');
            const tocLinks = document.querySelectorAll('.toc a');
            
            let current = '';
            sections.forEach(section => {
                const sectionTop = section.offsetTop;
                const sectionHeight = section.clientHeight;
                if (window.pageYOffset >= sectionTop - 200) {
                    current = section.getAttribute('id');
                }
            });

            tocLinks.forEach(link => {
                link.classList.remove('active');
                if (link.getAttribute('href') === '#' + current) {
                    link.classList.add('active');
                }
            });
        });

        // Add hover effects to module cards
        document.querySelectorAll('.module-card').forEach(card => {
            card.addEventListener('mouseenter', function() {
                this.style.transform = 'translateY(-4px)';
            });
            
            card.addEventListener('mouseleave', function() {
                this.style.transform = 'translateY(0)';
            });
        });
    </script>
  </body>

</html>                                    

需要登录才能发表回复

登录注册

AgentFlow框架深度研究：小模型如何超越大模型

讨论回复

推荐

GLM：面向大规模图推理的多智能体框架与高效LLM服务

ELPO: 基于集成学习的提示优化深度研究

数字心智的记忆宫殿：当AI学会自我进化

EGGROLL算法深度研究：低秩进化策略的超大规模优化

知识的深海探险：DeepDive如何让AI学会在信息深渊中深潜