1. 项目概述：Agent Lightning，一个“零代码改动”的AI智能体训练器

如果你正在构建或使用基于大语言模型的AI智能体，无论是用LangChain、AutoGen，还是自己手搓的OpenAI API调用，大概率都遇到过同一个瓶颈： 如何让这个智能体变得更好？ 传统的路径无非是手动调整提示词、收集数据做有监督微调，或者投入大量工程资源去搭建一个复杂的强化学习训练框架。前者依赖经验且难以规模化，后者则门槛极高，往往意味着你需要重写整个智能体的交互逻辑来适配训练流程。

这就是Agent Lightning要解决的问题。它把自己定位为“AI智能体的绝对训练器”，核心目标直白而有力： 让你能用强化学习等算法优化现有的智能体，而几乎不需要修改原有代码。 我花了几周时间深入测试了这个来自微软研究院的开源项目，它的设计理念非常巧妙——不是让你把智能体“塞进”一个训练框架，而是让训练框架“无侵入地”接入你的智能体工作流。你可以把它想象成给智能体装上一个“外挂学习模块”，智能体照常运行、处理任务、调用工具，而Agent Lightning在后台默默地收集每一次交互的轨迹（轨迹），然后利用这些数据驱动智能体进化。

它的野心不小，宣称支持 任何 智能体框架，甚至是无框架的裸代码。在实际测试中，我尝试了用LangChain构建的文档问答链和用纯Python脚本写的多步骤决策代理，接入过程确实如其所言，主要工作量就是在关键节点插入几行 agl.emit_xxx() 的调用，或者直接启用自动追踪。这种低侵入性对于已经上线的项目来说，吸引力是巨大的，意味着你可以对生产环境中的智能体进行持续的、数据驱动的优化，而无需推倒重来。

2. 核心架构解析：数据流与控制流的解耦艺术

Agent Lightning能实现“几乎零代码改动”的秘诀，在于其清晰的架构设计。它没有尝试接管或重构你的智能体，而是建立了一个 中心化的数据交换层 ，将智能体的“执行”与算法的“学习”彻底解耦。理解这个架构，是高效使用它的关键。

2.1 核心组件：Span、Store与Trainer

整个系统的运转围绕三个核心概念展开：

1. Span ：这是Agent Lightning定义的基本数据单元。它代表智能体执行过程中的一个 有意义的片段 。比如，一次向LLM发送的提示（ PromptSpan ），一次工具调用（ ToolCallSpan ），或者一次从环境中获得的奖励（ RewardSpan ）。你的智能体在运行时，通过 agl.emit_prompt 、 agl.emit_tool_call 等函数发射这些Span，或者由框架的自动追踪功能捕获生成。每个Span都带有丰富的上下文信息，如时间戳、关联的父Span ID、输入输出内容等，共同构成了一条完整的交互轨迹。

2. LightningStore ：这是整个系统的 中枢神经 。所有由智能体产生的Span，都会被发送到这里进行存储和管理。Store不仅仅是一个数据库，它更是一个 状态同步中心 。它还管理着“资源”，比如当前使用的提示词模板、策略模型的权重文件等。算法从Store中读取Span数据进行学习，然后将更新后的资源（如优化后的提示词）写回Store。这样，执行中的智能体就能实时或按需从Store拉取最新的资源，实现行为的更新。这种设计使得训练和推理可以异步进行，甚至可以在不同机器上分布式运行。

3. Trainer与Algorithm ：这是系统的“大脑”。Trainer负责组织训练流程：准备数据集（本质上是Span的集合）、启动运行器来执行智能体任务、从Store中获取数据喂给算法、处理算法产出的新资源并更新Store。而 Algorithm 则是具体的学习逻辑。Agent Lightning内置了如GRPO等强化学习算法，也支持自定义算法。算法的工作就是分析Span序列，评估智能体行动的好坏（基于奖励），然后计算出如何调整策略（可能是调整提示词，也可能是微调模型参数）以在未来获得更高奖励。

2.2 无侵入接入的工作原理

这种架构如何实现无侵入？关键在于 你的智能体代码与Agent Lightning的交互点非常有限且标准化 。

• 方式一：主动发射（推荐） ：在你原有的代码中，在关键位置插入几行 agl.emit_* 调用。例如，在调用LLM之前，用 agl.emit_prompt 记录下你构建的完整提示；在调用工具后，用 agl.emit_tool_call 记录工具名和参数。你的业务逻辑完全不变，只是多了一些“日志”语句。这些日志被Agent Lightning结构化为了Span。
• 方式二：自动追踪 ：对于某些流行框架（如LangChain），Agent Lightning提供了 Tracer 。你只需要在初始化智能体时，将Agent Lightning的Tracer作为一个回调处理器加入，它就能自动钩住框架的内部事件，帮你生成对应的Span。这几乎实现了真正的“零”代码改动。

无论哪种方式，你的智能体都感知不到后端的Trainer和Algorithm。它只是在执行任务，并“无意中”留下了完整的行为足迹。后端的训练系统则像一位教练，通过分析这些足迹来制定训练计划，并通过更新Store中的“战术板”（资源）来指导智能体下一次表现得更好。

注意 ：虽然宣传是“零代码改动”，但对于复杂或高度定制化的智能体，为了获得最佳的训练效果和奖励信号，你通常需要 主动地、有策略地设计Span的发射点 。自动追踪可能无法捕获所有你关心的语义边界。例如，一个复杂的规划-执行循环，你可能需要手动发射一个 PlanSpan 来明确标注规划阶段的开始和结束，这有助于算法更准确地理解智能体的决策阶段。

3. 从零开始：实战部署与第一个训练任务

理论说得再多，不如亲手跑通一个例子来得实在。下面我将带你完整走一遍使用Agent Lightning优化一个简单智能体的流程。我们以“使用LLM进行两位数加法运算”为例，这个任务看似简单，但非常适合演示从接入、训练到评估的全过程。

3.1 环境准备与安装

首先，确保你的Python环境在3.9以上。使用pip安装Agent Lightning非常简单：

# 安装稳定版
pip install agentlightning

# 如果你想体验最新的开发特性（可能不稳定），可以从Test PyPI安装夜间构建版
pip install --upgrade --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ --pre agentlightning

安装完成后，我建议你克隆官方仓库，里面的 examples 目录是绝佳的学习材料。

git clone https://github.com/microsoft/agent-lightning.git
cd agent-lightning

3.2 构建一个简单的“加法智能体”

我们创建一个文件 simple_math_agent.py 。这个智能体不使用任何外部框架，纯用OpenAI API。

import os
import openai
from typing import Dict, Any
import agentlightning as agl

# 1. 初始化Agent Lightning上下文。这通常在应用启动时做一次。
agl.init()

# 设置你的OpenAI API密钥
openai.api_key = os.getenv("OPENAI_API_KEY")

class SimpleMathAgent:
    def __init__(self, model: str = "gpt-3.5-turbo"):
        self.model = model
        # 初始化一个会话ID，用于关联同一任务的所有Span
        self.session_id = agl.generate_id()

    def add_two_numbers(self, a: int, b: int) -> str:
        """核心方法：让LLM计算两个数的和"""
        # 构建提示词
        prompt = f"请计算 {a} 和 {b} 的和，只输出最终数字，不要任何解释。"
        
        # 关键步骤1：发射PromptSpan，记录我们给LLM的输入
        prompt_span_id = agl.emit_prompt(
            session_id=self.session_id,
            prompt=prompt,
            # 可以附加额外的元数据，方便后续分析
            metadata={"operation": "addition", "operands": [a, b]}
        )
        
        try:
            # 调用LLM
            response = openai.chat.completions.create(
                model=self.model,
                messages=[{"role": "user", "content": prompt}],
                temperature=0
            )
            answer = response.choices[0].message.content.strip()
            
            # 关键步骤2：发射LLMSpan，记录LLM的输出，并关联到之前的PromptSpan
            agl.emit_llm(
                session_id=self.session_id,
                parent_span_id=prompt_span_id, # 建立父子关系，形成轨迹链
                response=answer,
                model=self.model,
                usage=response.usage.dict() if response.usage else None
            )
            
            # 尝试将回答解析为整数，用于计算奖励
            try:
                result = int(answer)
                correct = (result == a + b)
            except ValueError:
                correct = False
                
            # 关键步骤3：发射RewardSpan，为这次交互打分
            agl.emit_reward(
                session_id=self.session_id,
                parent_span_id=prompt_span_id,
                value=1.0 if correct else -1.0, # 简单奖励：正确+1，错误-1
                name="correctness"
            )
            
            return answer
            
        except Exception as e:
            agl.emit_error(session_id=self.session_id, parent_span_id=prompt_span_id, error=str(e))
            return f"Error: {e}"

if __name__ == "__main__":
    agent = SimpleMathAgent()
    print(agent.add_two_numbers(15, 27)) # 应该输出 42

代码解读与实操要点 ：

1. agl.init() ： 必须 在程序开始处调用，用于初始化Agent Lightning的运行时环境。
2. session_id ：一个任务或一轮对话的唯一标识。所有属于同一流程的Span应共享同一个 session_id ，这样Agent Lightning才能将它们串联成完整的轨迹。
3. emit_prompt ：在调用LLM 之前 发射。这是记录智能体“思考”起点的关键。
4. emit_llm ：在收到LLM回复后 立即 发射。通过 parent_span_id 关联到对应的 PromptSpan ，形成“提问-回答”对。
5. emit_reward ：在能判断结果好坏时发射。这里是立即根据答案正确性给了奖励。在复杂任务中，奖励可能来自外部系统、用户反馈或事后评估模型。
6. parent_span_id 的传递 ：这是构建轨迹链的核心。它确保了数据之间的因果关系，对于强化学习算法理解状态转移至关重要。

3.3 配置训练任务与启动训练

智能体已经能发射Span了，现在我们需要配置一个训练任务来学习如何优化它。创建一个训练配置文件 train_config.yaml ：

# train_config.yaml
task:
  name: "simple_math_training"
  # 指定运行我们智能体的入口点脚本和函数
  runner:
    type: "python"
    entrypoint: "simple_math_agent:SimpleMathAgent.add_two_numbers"
    # 给runner传入的参数，这里我们生成100个随机的加法题作为训练集
    args_generator:
      type: "list"
      values:
        - [12, 34]
        - [56, 78]
        - [90, 11]
        # ... 可以自动生成更多，这里简写
  # 定义如何从Span中构建强化学习需要的 (state, action, reward) 序列
  trajectory_builder:
    # 使用内置的“链式”构建器，它会沿着parent_span_id链接Span
    type: "chain"
    # 指定哪些Span类型构成一个“步骤”，通常是从Prompt到下一个Prompt之前
    step_pattern: ["prompt", "llm", "tool_call", "reward"]

algorithm:
  # 使用内置的GRPO (Generalized Reinforcement Learning via Policy Optimization) 算法
  name: "grpo"
  args:
    # 学习率，控制参数更新幅度
    learning_rate: 1e-4
    # 折扣因子，衡量未来奖励的重要性
    gamma: 0.99
    # 每轮训练使用的轨迹数量
    batch_size: 32

trainer:
  # 使用本地训练器
  type: "local"
  # 训练轮次
  epochs: 50
  # 每轮用多少条轨迹训练
  trajectories_per_epoch: 100
  # 资源更新策略：如何将算法学到的“新提示词”等资源应用到智能体
  resource_update_strategy: "replace" # 直接替换旧资源

# 存储配置，这里使用本地文件存储（生产环境可用数据库）
store:
  type: "file"
  path: "./lightning_store"

接下来，我们编写一个启动训练的脚本 train.py ：

import agentlightning as agl
from agentlightning.trainer import LocalTrainer
import yaml

def main():
    # 加载配置
    with open("train_config.yaml", "r") as f:
        config = yaml.safe_load(f)
    
    # 创建本地训练器
    trainer = LocalTrainer(config=config)
    
    # 启动训练！
    trainer.train()
    
    print("训练完成！优化后的资源已保存到Store中。")

if __name__ == "__main__":
    main()

运行这个脚本，你就会看到训练开始。训练器会反复执行以下循环：

1. 从 args_generator 中取出参数（如 [12, 34] ），调用你的 add_two_numbers 函数。
2. 你的函数运行，发射Span到LightningStore。
3. 训练器从Store收集一定数量的轨迹（ trajectories_per_epoch ）。
4. GRPO算法分析这些轨迹，计算策略梯度，试图找到能获得更高累计奖励的提示词优化方向（在这个例子中，算法可能会学习如何调整我们提示词的表述，虽然我们原始提示词很简单，但算法可能会探索不同的指令风格）。
5. 算法将优化后的“提示词模板”作为新资源写回Store。
6. 在下一轮训练中，你的智能体会从Store加载这个优化后的提示词模板，从而改变其行为。

实操心得 ：第一次运行时，最常遇到的问题是无法连接到Store或Runner启动失败。请务必检查 agl.init() 是否在智能体代码的最开始被调用。另外，确保 entrypoint 的格式是 “模块名:类名.方法名” 或 “模块名:函数名” ，并且你的Python路径包含该模块所在目录。

4. 算法核心与高级调优：不止于GRPO

Agent Lightning将算法抽象为一个可插拔的组件，GRPO只是其开箱即用的选项之一。理解不同算法的适用场景，是进行高级调优的关键。

4.1 内置算法概览

1. GRPO ：这是项目默认的强化学习算法，可以理解为针对序列决策任务（如智能体多轮对话）优化过的PPO变体。它直接优化策略（即LLM的生成行为），通过奖励信号来调整模型参数（或提示词嵌入）。 适合场景 ：当你希望智能体通过试错，学习复杂的、多步骤的任务策略时，例如学习如何更有效地使用工具、如何规划子任务。
2. 自动提示优化 ：这类算法不改变LLM的权重，而是专注于优化文本提示本身。它通过搜索或梯度方法，找到能引导LLM产生更高奖励输出的提示词。 适合场景 ：当你无法微调模型（如使用闭源API），或者希望优化结果具有可解释性（因为提示词是文本）时。它通常比RL训练更快、更轻量。
3. 有监督微调 ：利用收集到的高质量成功轨迹（Span序列）作为示范数据，直接对基础LLM进行有监督的指令微调。这可以看作是一种“模仿学习”。 适合场景 ：当你已经拥有或可以通过规则/人工标注产生大量“正确”操作轨迹时，用于让智能体快速学习基础技能。

4.2 奖励工程：训练成败的生命线

无论使用哪种算法， 奖励函数的设计都是最核心、最需要经验的工作 。在 simple_math_agent.py 中，我们使用了最简单的二值奖励（正确+1，错误-1）。但在真实场景中，奖励需要更精细地刻画“好”与“不好”。

• 稀疏奖励与稠密奖励 ：在“写SQL并执行”的任务中，只有最终查询结果正确才能获得奖励，这是 稀疏奖励 ，智能体很难学习。我们可以设计 稠密奖励 ：为每一步都提供小奖励，例如，成功连接到数据库+0.1，生成的SQL语法正确+0.2，查询结果部分匹配+0.5。这能更好地引导智能体学习。
• 奖励塑造 ：这是将稀疏奖励转化为稠密奖励的艺术。需要你对任务有深刻理解，将最终目标分解为一系列可衡量的子目标。Agent Lightning允许你在多个环节发射 RewardSpan ，从而实现复杂的奖励塑造。
• 避免奖励黑客 ：智能体可能会学会“欺骗”奖励系统，而不是真正解决问题。例如，在一个游戏中，如果奖励是“获得金币”，智能体可能学会卡Bug无限刷金币，而不是学习游戏规则。设计奖励时，要尽量让奖励与任务的真实目标对齐。

示例：为一个文本摘要智能体设计奖励

def evaluate_summary(original_text, generated_summary):
    rewards = {}
    # 1. 长度奖励（鼓励简洁）
    target_len = 100
    len_diff = abs(len(generated_summary) - target_len)
    rewards["length"] = -0.01 * len_diff # 越接近目标长度，惩罚越小
    
    # 2. 关键信息覆盖度（使用简单的词重叠或嵌入相似度）
    # 假设有一个函数能计算ROUGE或余弦相似度
    coverage_score = calculate_coverage(original_text, generated_summary)
    rewards["coverage"] = 2.0 * coverage_score
    
    # 3. 流畅度（使用一个小的语言模型打分）
    fluency_score = calculate_fluency(generated_summary)
    rewards["fluency"] = 1.0 * fluency_score
    
    # 4. 事实一致性（避免幻觉）
    consistency_score = check_fact_consistency(original_text, generated_summary)
    rewards["consistency"] = 3.0 * consistency_score # 给予最高权重
    
    # 发射多个奖励Span
    for name, value in rewards.items():
        agl.emit_reward(session_id=session_id, parent_span_id=llm_span_id, value=value, name=name)

这个例子展示了如何组合多个奖励信号来引导智能体生成高质量摘要。

4.3 自定义算法与资源

Agent Lightning的强大之处在于其扩展性。你可以实现自己的 Algorithm 类。

from agentlightning.core.algorithm import Algorithm
from agentlightning.core.store import LightningStore
from typing import List, Dict, Any

class MyCustomOptimizer(Algorithm):
    def __init__(self, config: Dict[str, Any]):
        super().__init__(config)
        self.learning_rate = config.get("learning_rate", 0.01)
        
    def learn(self, store: LightningStore, resource_ids: List[str]):
        """
        从store中读取轨迹数据，进行学习，并返回更新后的资源。
        """
        # 1. 从store获取最近的轨迹
        trajectories = store.get_trajectories(limit=100)
        
        # 2. 你的自定义学习逻辑（例如，遗传算法搜索最佳提示词）
        best_prompt = self.genetic_search(trajectories)
        
        # 3. 创建或更新资源（例如，一个优化后的提示词模板）
        updated_resources = {
            "optimized_prompt_template": {
                "content": best_prompt,
                "metadata": {"version": "2.0"}
            }
        }
        
        # 4. 将新资源发布回store
        new_resource_ids = store.post_resources(updated_resources)
        return new_resource_ids
    
    def genetic_search(self, trajectories):
        # 简化的遗传算法示例
        # 分析轨迹，提取提示词和对应奖励
        prompt_reward_pairs = []
        for traj in trajectories:
            prompt = self._extract_prompt(traj)
            total_reward = self._calculate_total_reward(traj)
            prompt_reward_pairs.append((prompt, total_reward))
        
        # 选择、交叉、变异...（此处省略具体实现）
        best_prompt = self._evolve(prompt_reward_pairs)
        return best_prompt

然后在配置文件中指定使用你的算法：

algorithm:
  name: "my_custom_optimizer" # 需要注册你的算法类
  args:
    learning_rate: 0.05

5. 生产级部署与监控避坑指南

将Agent Lightning用于实际项目时，会面临与开发测试环境不同的一系列挑战。以下是我在实际部署中总结的关键经验和常见问题。

5.1 存储与可扩展性

本地文件存储（ type: file ）适合原型验证和小规模实验。 生产环境必须使用更健壮的存储后端 。

• 推荐选择 ：
  • PostgreSQL ：关系型数据库，适合需要复杂查询分析轨迹数据的场景。Agent Lightning提供了相应的适配器。
  • Redis ：内存数据库，读写速度极快，适合高并发、需要快速存储和读取Span的在线学习场景。但需要注意数据持久化策略。
  • 向量数据库 ：如果你的Span内容（如提示词、回复）需要做语义检索来分析相似任务或进行聚类分析，可以考虑将Span的嵌入向量也存储起来。
• 配置示例 （以PostgreSQL为例）：

  store:
    type: "postgresql"
    host: "localhost"
    port: 5432
    database: "agent_lightning_db"
    user: "agl_user"
    password: "${DB_PASSWORD}" # 建议使用环境变量
    table_prefix: "agl_" # 表名前缀，方便管理
  

• 性能考量 ：Span的写入可能是高频操作。确保数据库连接池配置合理，并考虑对Span表进行分区（例如按日期或 session_id 哈希），以应对数据量增长。

5.2 训练稳定性与调试

强化学习训练 notoriously（众所周知）不稳定。以下技巧能帮你节省大量时间：

1. 从小任务开始 ：不要一上来就用最复杂的任务和最大的模型训练。先用一个极简的、奖励信号清晰的任务（比如我们的加法器）验证整个pipeline是通的。然后逐步增加任务复杂度。
2. 监控关键指标 ：Agent Lightning内置了Dashboard（可通过 agl-dashboard 命令启动），一定要用起来。重点关注：
   • 平均奖励/累计奖励 ：这是训练是否在进步的核心指标。理想情况下应该震荡上升。如果持续下降或剧烈波动，说明奖励设计或算法参数可能有问题。
   • 轨迹长度 ：智能体完成任务所需的平均步数。如果步数无故增加，可能陷入了无效循环。
   • 资源版本变化 ：观察提示词模板等资源是如何被算法修改的，这能提供直观的“学习”洞察。
3. 超参数调优 ：
   • learning_rate ：RL算法的学习率。太大容易震荡发散，太小学习缓慢。可以从 1e-5 到 1e-3 之间尝试。
   • batch_size ：每次更新参数时使用的轨迹数量。更大的batch通常更稳定，但需要更多内存和计算资源。
   • gamma ：折扣因子。越接近1，智能体越重视长期奖励；越接近0，越近视。对于多步任务（如对话），通常设 0.9 到 0.99 。
4. 使用检查点 ：在训练配置中启用模型保存。

   trainer:
     type: "local"
     checkpoint_dir: "./checkpoints"
     save_every_n_epochs: 10 # 每10轮保存一次
   

   这样当训练崩溃或你想回退到之前某个表现好的版本时，可以快速恢复。

5.3 常见问题排查速查表

问题现象	可能原因	排查步骤与解决方案
训练启动失败，提示 ModuleNotFoundError	Runner的 entrypoint 路径错误或依赖缺失。	1. 确认 entrypoint 字符串格式正确，模块在Python路径下。 2. 在训练脚本中手动导入一次你的智能体模块，确保无导入错误。 3. 检查智能体代码的依赖是否已在训练环境中安装。
Store中看不到Span数据	agl.init() 未调用，或Store连接配置错误，或Span未成功发射。	1. 确保智能体代码最开头调用了 agl.init() 。 2. 检查Store配置（数据库地址、端口、权限）。 3. 在智能体代码中增加日志，确认 agl.emit_* 函数被成功执行且无异常。
训练奖励没有提升，始终在随机水平	奖励函数设计不合理、任务太难、学习率不当或算法不适用。	1. 首先验证奖励函数 ：手动运行几个任务，检查奖励值是否符合预期。 2. 简化任务 ：用一个你知道智能体凭当前提示就能完美解决的任务测试，看奖励是否能学到满分。 3. 调整超参数 ：大幅降低学习率，观察变化；尝试增大 batch_size 。 4. 检查轨迹构建 ：确认 step_pattern 正确，轨迹被正确分割成 (state, action, reward) 序列。
训练过程中奖励突然崩溃（NaN或极大/极小值）	出现了梯度爆炸，常见于学习率过高或网络输出不稳定。	1. 立即降低学习率（例如除以10）。 2. 在算法配置中启用梯度裁剪（如果算法支持）。 3. 检查输入到模型的提示词或状态表示是否有异常值。
Dashboard无法打开或数据不更新	Dashboard服务未正确启动，或与Store后端不兼容。	1. 确认使用 agl-dashboard 命令启动，并指定正确的Store配置（ --store-config ）。 2. 检查Dashboard服务日志，看是否有连接Store的错误。 3. 确保Store类型（如PostgreSQL）有对应的Dashboard支持。
多智能体场景下，奖励归属混乱	多个智能体的Span使用了相同的 session_id ，或者奖励发射时 parent_span_id 关联错误。	1. 为每个独立的智能体实例或对话线程生成唯一的 session_id 。 2. 仔细设计Span的父子关系，确保奖励准确地关联到产生该行动的那个智能体的 LLMSpan 或 ToolCallSpan 上。

5.4 与现有MLOps流水线集成

Agent Lightning本质上是一个生成和消费轨迹数据的系统，它可以很好地嵌入现有的MLOps生态。

• 数据版本化 ：使用像DVC或LakeFS这样的工具，将每个训练周期产生的Span数据集和对应的资源（模型检查点、提示词）进行版本化管理。
• 实验追踪 ：将Agent Lightning的训练运行（包括配置、超参数、最终指标）记录到MLflow或Weights & Biases中，方便比较不同实验。
• 持续训练 ：在生产环境中，可以设置一个定时任务或事件驱动的工作流。当Store中积累了一定量的新交互数据（Span）后，自动触发一轮增量训练，实现智能体的持续在线学习。

将Agent Lightning引入你的项目，不是一次性的开发工作，而是建立一套 持续的智能体优化机制 。它降低了应用高级AI优化技术的门槛，让研发团队能将更多精力聚焦于任务定义、奖励设计和效果评估这些更具创造性的工作上。从我实际使用的体验来看，初期最大的投入在于如何设计一个好的奖励函数和如何有效地结构化Span数据，一旦这个基础打牢，后续的优化迭代就会变得非常顺畅。