Microsoft Agent Lightning 深度实战：零代码变更强化学习——让 AI Agent 在真实交互中自我进化（2026 完全指南）

你花了两周把一个 AI Agent 调得能跑通主流程，结果一上生产就各种边界翻车。传统的做法是：人工分析失败 case → 手搓 few-shot → 再跑 → 再翻车。Microsoft Agent Lightning 把这个循环自动化了——而且不改一行业务代码。

一、背景：AI Agent 的"训练鸿沟"困境

2025-2026 年，AI Agent 从 Demo 走向生产，所有人都踩到了同一个坑：

开发环境和生产环境是完全不同的两个分布。

你在测试集上跑得好好的 Agent，一碰到真实用户的奇葩输入就开始胡说八道。根本原因是：大多数 Agent 系统是纯提示词工程（Prompt Engineering）+ 少样本示例（Few-shot） 堆出来的，没有任何基于真实交互的优化机制。

传统解决方案有三个，但都有严重缺陷：

Microsoft Agent Lightning 的核心洞察：Agent 的"运行逻辑"和"学习机制"应该彻底解耦。让业务代码继续用 LangChain / OpenAI SDK / CrewAI 随便写，训练框架在旁边默默收集交互轨迹，然后在后台做强化学习，最后把优化结果塞回 Agent——全程不需要你改业务逻辑。

二、Agent Lightning 架构深度解析

2.1 整体架构：客户端-服务器分离设计

Agent Lightning 的架构分为两层：

┌─────────────────────────────────────────────────────┐
│           你的 Agent 代码（无需修改）                  │
│    LangChain / OpenAI Agent SDK / AutoGen / ...     │
└──────────────────┬──────────────────────────────────┘
                   │ LitAgent 封装（零代码变更）
                   ▼
┌─────────────────────────────────────────────────────┐
│         Agent Lightning 客户端（Python SDK）          │
│   • 透明拦截 LLM 调用                               │
│   • 记录完整交互轨迹（Span）                          │
│   • 发送轨迹数据到训练服务器                          │
└──────────────────┬──────────────────────────────────┘
                   │ HTTP/gRPC
                   ▼
┌─────────────────────────────────────────────────────┐
│        Agent Lightning 训练服务器                     │
│   • 接收并存储交互轨迹                               │
│   • LightningRL 算法引擎（信用分配）                  │
│   • 策略优化：RL / 自动提示优化 / SFT                 │
│   • 将优化结果推送回 Agent                            │
└─────────────────────────────────────────────────────┘

关键设计决策：客户端只做"记录"，不做"训练"。训练全部在服务器端，用微软的 verl（Volcano Engine RL） 训练基础设施。这意味着你的 Agent 进程不需要加载训练框架的巨大依赖，推理和训练完全解耦。

2.2 LitAgent 封装接口

Agent Lightning 要求你把 Agent 逻辑封装进一个 LitAgent 接口。注意——封装不等于重写。看一个最小示例：

# 你原来的 Agent 代码
from openai import OpenAI

client = OpenAI()

def my_agent(query: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "你是一个有用的助手"},
            {"role": "user", "content": query}
        ]
    )
    return response.choices[0].message.content

# 用 Agent Lightning 封装（只加 5 行）
from agent_lightning import LitAgent, LitEnv

class MyAgent(LitAgent):
    def __init__(self):
        super().__init__()
        self.client = OpenAI()
    
    def forward(self, query: str) -> str:
        # 原来的逻辑完全不动
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": "你是一个有用的助手"},
                {"role": "user", "content": query}
            ]
        )
        return response.choices[0].message.content
    
    def reward(self, query: str, response: str) -> float:
        # 定义奖励函数 —— 这是唯一需要"新增"的逻辑
        # 可以用规则、可以用 Reward Model、可以用人类反馈
        if "抱歉" in response or "cannot" in response.lower():
            return -1.0
        return 1.0

只看这个例子就能看懂 Agent Lightning 的设计哲学：forward() 里放你原来的代码，reward() 里定义"什么算好结果"。业务逻辑的改动被压到了最小。

2.3 Span 数据模型：完整交互轨迹记录

Agent Lightning 的核心数据结构是 Span（灵感来自 OpenTelemetry 的 Trace 概念）。一个 Span 记录一次完整的 Agent 交互：

@dataclass
class Span:
    span_id: str            # 唯一标识
    trace_id: str           # 一次会话的所有 Span 共享同一个 trace_id
    parent_span_id: Optional[str]  # 支持嵌套调用（Agent 调用 Sub-Agent）
    
    # 输入
    messages: List[Dict]    # 完整对话历史
    tools_called: List[Dict]  # 工具调用记录
    
    # 输出
    response: str
    tool_results: List[Dict]
    
    # 奖励信号（可能延迟到达）
    reward: Optional[float] = None
    reward_details: Optional[Dict] = None
    
    # 元数据
    timestamp: float
    model_name: str
    token_usage: Dict

为什么 Span 设计这么重要？ 因为强化学习的信用分配（Credit Assignment）问题需要一个完整的交互轨迹才能解决。如果只知道"最终结果的奖励是 +1"，但不知道中间哪一步导致了好结果，RL 算法就无法有效学习。Span 的树状结构让 Agent Lightning 能做 Tree-based Credit Assignment——精确追踪每一步对最终结果的贡献。

三、LightningRL 算法引擎：三种优化策略

Agent Lightning 的算法层支持三种优化策略，可以独立使用，也可以组合。

3.1 策略一：强化学习（RL）—— 从交互中学习策略

这是 Agent Lightning 的核心能力。底层使用微软的 verl 框架，支持多种 RL 算法：

PPO（Proximal Policy Optimization）

适用于：Agent 的行为空间连续、需要精细策略调整的场景。

# Agent Lightning 中的 PPO 配置
from agent_lightning.algorithms import PPOConfig

ppo_config = PPOConfig(
    learning_rate=1e-5,
    clip_ratio=0.2,        # PPO-Clip 的核心超参
    value_loss_coef=0.5,
    entropy_coef=0.01,     # 鼓励探索
    max_grad_norm=1.0,
    gae_lambda=0.95,       # GAE 折扣因子
    gamma=0.99,            # 奖励折扣
)

# 启动训练
trainer = Trainer(
    agent=my_agent,
    algorithm="ppo",
    algorithm_config=ppo_config,
    server_url="http://localhost:8080",
)
trainer.train(num_iterations=1000)

GRPO（Group Relative Policy Optimization）

这是 DeepSeek 在 R1 模型中使用的 RL 算法的变体，Agent Lightning 也支持了。GRPO 不需要 Value Network，通过"组内相对比较"来计算优势函数，训练更稳定，资源消耗更低。

from agent_lightning.algorithms import GRPOConfig

grpo_config = GRPOConfig(
    group_size=8,          # 每个 prompt 采样 8 个回复
    temperature=0.8,
    top_p=0.95,
    kl_coef=0.04,          # KL 惩罚，防止策略偏离太远
)

实战经验：对于大多数 Agent 场景，GRPO 比 PPO 更合适——因为 Agent 的交互轨迹通常比较长，Value Network 的估计误差会被放大，而 GRPO 直接消掉了 Value Network。

3.2 策略二：自动提示优化（Auto Prompt Optimization）

这是 Agent Lightning 最实用的功能之一——不需要动模型参数，只优化提示词。

原理：把 Prompt 的每个部分（system message、few-shot examples、tool descriptions）视为"可优化变量"，用 RL 的梯度信号来搜索更好的 Prompt 组合。

from agent_lightning.algorithms import PromptOptimizationConfig

prompt_config = PromptOptimizationConfig(
    # 指定哪些部分可以被优化
    optimizable_sections=["system_message", "few_shot_examples"],
    
    # 优化方法：evolutionary / gradient_based
    method="evolutionary",
    population_size=50,
    num_generations=20,
    
    # 评估：用验证集计算平均奖励
    eval_samples=100,
)

# 优化后的 Prompt 会直接写回你的 Agent 代码
trainer = Trainer(
    agent=my_agent,
    algorithm="prompt_optimization",
    algorithm_config=prompt_config,
)
best_prompt = trainer.optimize()
print(f"优化后的 system message: {best_prompt.system_message}")

这个功能的威力在于：很多 Agent 的失败 case 其实只需要微调提示词就能解决，根本不需要重新训练模型。自动提示优化把"人工试 Prompt"这个过程自动化了。

3.3 策略三：监督微调（SFT）—— 利用高质量轨迹

当你的 Agent 产生了一些特别好的交互轨迹（高奖励），你可以把这些轨迹当成"专家示范"，做监督微调：

from agent_lightning.algorithms import SFTConfig

sft_config = SFTConfig(
    # 只使用奖励 > threshold 的轨迹
    reward_threshold=0.8,
    
    # SFT 超参
    learning_rate=5e-6,
    num_epochs=3,
    batch_size=32,
    
    # 只微调 Adapter，不动底座模型
    lora_rank=16,
    lora_alpha=32,
    lora_dropout=0.05,
)

三种策略的组合使用：实际应用中，最佳实践是先跑 SFT（利用已有的高质量数据快速提升基线），再跑 GRPO（进一步优化策略），最后用自动提示优化做"精修"。

四、代码实战：从零搭建一个可自我进化的 Customer Support Agent

下面用一个完整的实战案例，展示 Agent Lightning 的完整工作流。

4.1 场景定义

我们要构建一个客户服务 Agent，需要：

• 理解用户问题
• 调用内部知识库工具
• 给出准确回复
• 在真实交互中持续改进

4.2 Step 1：封装原有 Agent

import os
from typing import List, Dict, Optional
from agent_lightning import LitAgent, LitEnv
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# 工具定义
tools = [
    {
        "type": "function",
        "function": {
            "name": "search_knowledge_base",
            "description": "在知识库中搜索相关文档",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "搜索关键词"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "create_ticket",
            "description": "创建工单，转人工处理",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {"type": "string"},
                    "description": {"type": "string"}
                },
                "required": ["user_id", "description"]
            }
        }
    }
]

class SupportAgent(LitAgent):
    def __init__(self):
        super().__init__()
        self.client = client
        self.conversation_history: List[Dict] = []
    
    def forward(self, user_message: str, user_id: str) -> Dict:
        """主推理逻辑——原来的代码几乎不用改"""
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })
        
        # 第一轮：让 LLM 决定是否需要调用工具
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": self._build_system_prompt()},
                *self.conversation_history
            ],
            tools=tools,
            tool_choice="auto",
        )
        
        response_message = response.choices[0].message
        
        # 处理工具调用
        if response_message.tool_calls:
            tool_results = self._execute_tool_calls(
                response_message.tool_calls, user_id
            )
            
            # 把工具结果喂回 LLM，生成最终回复
            self.conversation_history.append({
                "role": "assistant",
                "content": None,
                "tool_calls": response_message.tool_calls
            })
            
            for result in tool_results:
                self.conversation_history.append({
                    "role": "tool",
                    "tool_call_id": result["tool_call_id"],
                    "content": result["content"]
                })
            
            final_response = self.client.chat.completions.create(
                model="gpt-4o",
                messages=[
                    {"role": "system", "content": self._build_system_prompt()},
                    *self.conversation_history
                ],
            )
            
            final_text = final_response.choices[0].message.content
            self.conversation_history.append({
                "role": "assistant",
                "content": final_text
            })
            
            return {
                "response": final_text,
                "tool_calls": response_message.tool_calls,
                "tool_results": tool_results
            }
        
        # 不需要工具调用，直接回复
        final_text = response_message.content
        self.conversation_history.append({
            "role": "assistant",
            "content": final_text
        })
        
        return {"response": final_text, "tool_calls": [], "tool_results": []}
    
    def _build_system_prompt(self) -> str:
        return """你是一个专业的客户服务助手。
规则：
1. 优先使用知识库工具搜索答案
2. 如果知识库没有相关信息，礼貌地引导用户创建工单
3. 回复要专业、简洁、有帮助
4. 不要编造信息"""
    
    def _execute_tool_calls(self, tool_calls, user_id: str) -> List[Dict]:
        results = []
        for tool_call in tool_calls:
            func_name = tool_call.function.name
            args = json.loads(tool_call.function.arguments)
            
            if func_name == "search_knowledge_base":
                result = self._search_kb(args["query"])
            elif func_name == "create_ticket":
                result = self._create_ticket(user_id, args["description"])
            else:
                result = f"未知工具: {func_name}"
            
            results.append({
                "tool_call_id": tool_call.id,
                "content": result
            })
        return results
    
    def _search_kb(self, query: str) -> str:
        # 模拟知识库搜索
        kb_data = {
            "退款政策": "本店支持7天无理由退款，商品需保持原包装。",
            "配送时间": "标准配送2-3个工作日，加急配送24小时内。",
            "账号问题": "账号问题请联系技术支持：support@example.com"
        }
        return kb_data.get(query, "未找到相关信息")
    
    def _create_ticket(self, user_id: str, description: str) -> str:
        ticket_id = f"TICKET-{hash(user_id + description) % 100000}"
        return f"工单已创建，ID: {ticket_id}。人工客服将在24小时内回复。"
    
    def reward(self, user_message: str, output: Dict) -> float:
        """奖励函数——这是训练信号的核心"""
        response_text = output["response"]
        
        # 规则 1：成功调用了知识库工具 → 正向奖励
        tool_names = [tc["function"]["name"] for tc in output["tool_calls"]]
        r = 0.0
        
        if "search_knowledge_base" in tool_names:
            r += 0.5  # 主动查知识库是正确行为
        
        # 规则 2：回复中包含"未找到"但没转人工 → 负向奖励
        if "未找到" in response_text and "create_ticket" not in tool_names:
            r -= 0.8  # 应该转人工却没有转
        
        # 规则 3：成功解决用户问题（通过外部评价或用户反馈获取）
        # 这里是简化版，实际应该接入用户反馈系统
        if hasattr(self, '_user_feedback'):
            r += self._user_feedback * 2.0
        
        # 规则 4：回复长度合理
        if 50 < len(response_text) < 500:
            r += 0.2
        
        return r

4.3 Step 2：启动训练服务器

# 安装 Agent Lightning
pip install agent-lightning

# 启动训练服务器（默认端口 8080）
agent-lightning-server \
    --model gpt-4o \
    --algorithm grpo \
    --reward-model none \  # 使用规则奖励，不依赖 RM
    --output-dir ./checkpoints \
    --device cuda:0

4.4 Step 3：连接 Agent 到训练服务器

# train_support_agent.py
from agent_lightning import Trainer

# 实例化 Agent（业务逻辑）
agent = SupportAgent()

# 连接训练服务器
trainer = Trainer(
    agent=agent,
    server_url="http://localhost:8080",
    algorithm="grpo",
    algorithm_config={
        "group_size": 8,
        "kl_coef": 0.04,
        "temperature": 0.8,
    }
)

# 开始训练（会在真实交互中持续学习）
trainer.train(
    num_iterations=500,
    samples_per_iteration=32,  # 每个 iteration 收集 32 条交互轨迹
    eval_every=50,             # 每 50 个 iteration 评估一次
)

4.5 Step 4：在生产中部署优化后的 Agent

训练完成后，有两种部署方式：

方式 A：导出优化后的 Prompt

# 导出自动优化后的 system prompt
optimized_prompt = trainer.export_optimized_prompt()
print(optimized_prompt)

# 输出示例（Agent Lightning 自动进化出的 system prompt）：
"""
你是客户支持专家，擅长准确、高效地解决用户问题。
核心原则：
1. 【关键】收到问题后，必须先搜索知识库（search_knowledge_base）
   即便你"觉得"自己知道答案，也要先查知识库确认
2. 只有在知识库明确无结果时，才创建工单
3. 回复时引用知识库的具体条款，增加可信度
4. 避免使用"可能"、"也许"等不确定表述
"""

方式 B：加载微调后的 Adapter

# 加载训练好的 LoRA Adapter
trainer.export_lora_adapter("./adapters/support-agent-v1")

# 生产部署时加载
from peft import PeftModel
import torch
from transformers import AutoModelForCausalLM

base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
model = PeftModel.from_pretrained(base_model, "./adapters/support-agent-v1")

五、深度技术剖析：Agent Lightning 如何解决信用分配问题

5.1 问题本质：长轨迹的信用分配

一个典型的 Agent 交互可能包含 10-20 轮工具调用，最终只有一个奖励信号（比如用户点了"满意"或"不满意"）。信用分配问题就是：这 20 步里，哪几步做对了？哪几步做错了？

传统 RL 用 TD（Temporal Difference）学习 或 MC（Monte Carlo）回报 来分配信用，但在 LLM Agent 场景下有两个特殊困难：

1. 稀疏奖励：用户可能只在对话结束时给反馈，中间步骤没有监督信号
2. 工具调用的因果复杂性：一个错误的工具调用可能在 3 步之后才暴露出问题

5.2 Agent Lightning 的解决方案：Tree-based Credit Assignment

Agent Lightning 利用 Span 的树状结构，实现了一种 基于注意力的信用分配机制：

# 伪代码：LightningRL 的信用分配核心逻辑
def compute_advantages(spans: List[Span], rewards: List[float]) -> List[float]:
    """
    对每个 Span 计算优势函数（Advantage）
    核心思路：用 Transformer 注意力机制来建模 Span 之间的依赖关系
    """
    # 1. 把所有 Span 编码成向量序列
    span_embeddings = [encode_span(s) for s in spans]  # (T, D)
    
    # 2. 用轻量级 Transformer 计算 Span 之间的注意力权重
    #    Q: 每个 Span 对其他 Span 的影响程度
    attention_weights = transformer_attention(span_embeddings)  # (T, T)
    
    # 3. 从最终奖励反向传播注意力权重，计算每个 Span 的贡献
    advantages = []
    for t, span in enumerate(spans):
        # 只看 t 时刻之后的 Span（因果关系）
        future_attention = attention_weights[t, t:]  # (T-t,)
        future_rewards = rewards[t:]                  # (T-t,)
        
        # 加权平均：注意力权重高的后续 Span 的奖励，更多地归功于当前 Span
        advantage_t = sum(w * r for w, r in zip(future_attention, future_rewards))
        advantages.append(advantage_t)
    
    return advantages

这个设计的精妙之处：它不要求人工标注每一步的奖励，而是通过数据驱动的注意力机制，自动学习"哪一步导致了最终结果"。

5.3 与 RLHF 的根本区别

六、生产级部署：性能优化与工程实践

6.1 训练服务器的水平扩展

当你的 Agent 有上千个并发用户时，单个训练服务器会成为瓶颈。Agent Lightning 支持训练服务器的水平扩展：

# agent-lightning-cluster.yml
apiVersion: v1
kind: Service
metadata:
  name: agent-lightning-server
spec:
  clusterIP: None
  ports:
    - port: 8080
      name: grpc
  selector:
    app: agent-lightning-server
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: agent-lightning-server
spec:
  serviceName: agent-lightning-server
  replicas: 3  # 3 个训练服务器实例
  template:
    spec:
      containers:
      - name: server
        image: mcr.microsoft.com/agent-lightning:latest
        args:
          - "--shard-id=$(POD_NAME)"  # 每个实例处理不同的 Agent 分片
          - "--num-shards=3"
        env:
          - name: POD_NAME
            valueFrom:
              fieldRef:
                fieldPath: metadata.name

6.2 体验回放缓冲区（Replay Buffer）优化

Agent Lightning 使用体验回放缓冲区来存储交互轨迹。对于生产环境，有几个关键优化：

from agent_lightning.buffer import PrioritizedReplayBuffer

# 使用优先级回放缓冲区
# 高奖励和高不确定性的轨迹有更高的采样优先级
buffer = PrioritizedReplayBuffer(
    capacity=100000,
    alpha=0.6,   # 优先级指数
    beta=0.4,    # 重要性采样修正
    dynamic_sampling=True,  # 动态调整采样分布
)

trainer = Trainer(
    agent=agent,
    replay_buffer=buffer,
    # 只从最高优先级的 20% 轨迹中采样
    top_k_sampling=0.2,
)

6.3 防止策略崩溃（Policy Collapse）

RL 训练中最常见的生产事故是策略崩溃——Agent 突然开始输出无意义内容。Agent Lightning 提供多层防护：

from agent_lightning.safety import SafetyConfig

safety_config = SafetyConfig(
    # 1. KL 散度约束：策略更新不能偏离参考策略太远
    kl_threshold=0.05,
    
    # 2. 回复长度约束
    min_response_length=10,
    max_response_length=2000,
    
    # 3. 敏感性过滤：拒绝生成包含敏感词的回复
    sensitive_words_path="/path/to/sensitive_words.txt",
    
    # 4. 回滚机制：如果新策略在验证集上表现下降 > 20%，自动回滚
    auto_rollback=True,
    rollback_threshold=0.2,
)

trainer = Trainer(
    agent=agent,
    safety_config=safety_config,
)

七、与其他 Agent 训练框架的对比

Agent Lightning 的核心竞争优势：它是唯一一个真正做到"零代码变更"的框架，而且支持在线学习（在真实交互中持续改进）。

八、实战经验总结与最佳实践

8.1 奖励函数设计的原则

奖励函数是 RL 训练的核心，设计不好会导致策略学到"钻空子"的行为。几个原则：

1. 稀疏 + 密集奖励结合：最终用户反馈是稀疏奖励，中间步骤的正确性检查是密集奖励
2. 避免奖励 hacking：如果你的奖励函数只看好不好看，Agent 会学会生成"看起来不错但实际没用"的回复
3. 用真实业务指标：不要用"LLM 评价 LLM"的方式来做奖励，直接用业务指标（转化率、用户满意度、解决率）

# 好的奖励函数：结合多个信号
def reward(self, query, output):
    r = 0.0
    
    # 信号 1：用户是否满意（最真实的信号）
    if self._has_user_feedback(query):
        r += self._get_user_feedback(query) * 3.0  # 权重最高
    
    # 信号 2：是否成功解决了问题（通过工具调用结果判断）
    if self._issue_resolved(output):
        r += 1.0
    
    # 信号 3：回复效率（步数越少越好）
    num_steps = len(output.get("tool_calls", []))
    r -= 0.1 * num_steps  # 每多一步扣 0.1
    
    # 信号 4：格式正确性
    if self._is_well_formatted(output["response"]):
        r += 0.2
    
    return r

8.2 训练节奏建议

8.3 监控指标

除了标准的 RL 指标（平均奖励、策略熵、KL 散度），Agent Lightning 用户还应该监控：

# 在 Trainer 中配置监控
trainer = Trainer(
    agent=agent,
    metrics=[
        "avg_reward",           # 平均奖励
        "reward_std",           # 奖励标准差（衡量稳定性）
        "avg_tool_calls",       # 平均工具调用次数
        "task_success_rate",    # 任务成功率
        "avg_response_length",  # 平均回复长度
        "kl_divergence",        # KL 散度（防止策略突变）
        "reward_hacking_score", # 奖励 hacking 检测（自定义指标）
    ],
    metrics_endpoint="http://prometheus:9090/metrics"
)

九、总结与展望

Microsoft Agent Lightning 解决了一个长期以来被忽视的问题：AI Agent 在部署后如何持续改进？

传统的 ML 训练范式是"离线训练 → 部署 → 冻结"，但 Agent 面对的是开放、动态的真实世界，冻结的策略注定会退化。Agent Lightning 把"运行"和"学习"解耦，让 Agent 在服務真实用户的同时，从他们的反馈中持续学习——这才是真正的"智能体"。

关键技术要点回顾：

1. 零代码变更：通过 LitAgent 封装接口，不侵入业务逻辑
2. Span 数据模型：完整记录交互轨迹，支持树状信用分配
3. 三种优化策略：RL（GRPO/PPO）、自动提示优化、SFT，可组合使用
4. 在线学习：在真实分布上持续训练，无分布偏移问题
5. 生产级工程：水平扩展、优先级回放、多层安全防护

未来方向：

• 多 Agent 协作场景下的 RL：当多个 Agent 互相交互时，如何设计奖励函数？
• 跨用户的隐私保护学习：如何让 Agent 从所有用户的交互中学习，但不泄露任何用户的隐私数据？
• 与 RAG 的深度融合：检索增强生成和 RL 的结合——让 Agent 学会"更好地检索"

参考资源

• GitHub: https://github.com/microsoft/agent-lightning
• 论文：Microsoft Research，待正式发表
• verl 训练框架：https://github.com/volcengine/verl
• Agent Lightning 文档：https://agent-lightning.readthedocs.io

作者：程序员茄子 | 首发于 程序员茄子 | 2026-05-30