AReaL 2.0 深度解析：蚂蚁联合清华港科大开源的 Agent 自演进引擎——在线强化学习如何让智能体「越用越强」的完整实战指南

引言：Agent 的下一个范式跃迁

2026 年 7 月 2 日，蚂蚁集团联合香港科技大学、清华大学正式开源了 AReaL 2.0——一套面向真实生产环境的 Agent 在线强化学习（Online RL）基础设施。这不是又一个训练框架的版本更新，而是 Agent 范式的一次关键跃迁：从「能完成任务」到「在完成任务的过程中持续变强」。

Anthropic 内部的一个数据极具说明意义：几乎 100% 的工程师都在同时运行 100 多个带有自我改进循环的 Agent。Claude Code 创造者 Boris Cherny 在访谈中透露，这些 Agent 在每次运行中不断变得更好。Anthropic 更是发布了《When AI builds itself》深度报告，指出 AI 正在接管自身的研发流程，未来将迈向递归自我改进。

但现实是，绝大多数 Agent 并不具备这种「自演进」能力。它们每天产生海量交互轨迹——成功路径、失败步骤、用户修正、工具调用结果——这些数据大多只被当作日志用于排查问题，很少被系统化地转化为下一轮能力提升。AReaL 2.0 瞄准的正是这个缺口：将 Agent 从「执行闭环」推向「学习闭环」。

本文将从架构设计、核心组件、代码实战、性能基准四个维度，深度解析 AReaL 2.0 的技术实现。

一、为什么 Agent 需要「自演进」？

1.1 当前 Agent 的能力天花板

今天的 AI Agent 已经能够调用工具、执行多步规划、处理复杂工作流。从 Claude Code 到 OpenAI Codex，从 LangChain 到 CrewAI，Agent 在软件工程、客服、科研助理等场景中展现出惊人的能力。但它们有一个根本性缺陷：不会从经验中学习。

一个典型的 Agent 工作流是这样的：

用户输入 → Agent 规划 → 调用工具 → 获取结果 → 返回输出

每次交互都是独立的。Agent 不会记住「上次用这个方法失败了」，也不会积累「这类任务用这种策略更有效」的经验。它就像一个每天失忆的程序员，虽然能力很强，但从不积累经验。

1.2 执行闭环 vs 学习闭环

AReaL 团队将 Agent 的发展阶段分为两个闭环：

执行闭环（Execution Loop）：Agent 接收任务 → 规划步骤 → 调用工具 → 完成任务 → 返回结果。这是当前所有 Agent 框架的核心。

学习闭环（Learning Loop）：Agent 在执行闭环的基础上，将交互轨迹转化为训练信号 → 更新底层模型 → 在下一次执行中表现更好。这是 AReaL 2.0 要打通的链路。

两者的关系不是替代，而是叠加。学习闭环运行在执行闭环之上，通过观察 Agent 的真实行为来持续优化其能力。

1.3 为什么离线 RL 不够？

传统做法是构建离线训练环境：把 Agent 的行为抽象为仿真任务，在离线数据上做 RL 训练。这种方法存在三个根本问题：

1. 分布偏移（Distribution Shift）：离线训练环境与线上真实行为之间存在差距。在仿真环境中训练出的策略，部署到真实环境后可能表现迥异。
2. 环境构建成本：为每个 Agent 场景构建高质量的仿真环境，工程成本极高。软件工程 Agent 需要代码仓库、测试套件、CI/CD 流水线；客服 Agent 需要模拟用户对话、知识库、CRM 系统。
3. 经验浪费：线上 Agent 每天产生大量有价值的交互轨迹，这些数据被白白浪费。

AReaL 2.0 的核心洞察是：与其构建离线仿真环境，不如直接从线上真实交互中学习。

二、AReaL 2.0 架构解析

2.1 三根支柱

AReaL 2.0 的自演进体系建立在三根支柱之上：

支柱一：Agent Trajectory Data Protocol（ATDP）

ATDP 是面向学习的智能体轨迹协议。普通日志记录「用户问了什么、模型答了什么、调用了哪个工具」，对调试有用，但对训练远远不够。

ATDP 要求以步骤为单位记录完整决策过程：

{
  "step_id": "step_001",
  "observation": {
    "user_input": "修复这个 bug",
    "context": ["file:main.py", "error:TypeError at line 42"],
    "memory": ["之前用 try-catch 包裹过类似错误"]
  },
  "internal_state": {
    "reasoning": "错误类型是 TypeError，可能是类型转换问题",
    "confidence": 0.85
  },
  "action": {
    "tool": "code_edit",
    "params": {"file": "main.py", "line": 42, "change": "int(x) → str(x)"}
  },
  "result": {
    "success": true,
    "output": "修改成功",
    "latency_ms": 230
  },
  "reward_signal": {
    "test_passed": true,
    "user_feedback": "positive",
    "timestamp": "2026-07-06T10:30:00Z"
  },
  "metadata": {
    "model_version": "claude-4-opus",
    "tool_version": "code_edit_v2.1",
    "tenant_id": "team_alpha",
    "token_cost": {"input": 1200, "output": 350}
  }
}

这种结构化轨迹让系统能够回答关键问题：到底是哪一次检索、哪一个工具调用、哪条 prompt 片段影响到了任务成败？

支柱二：Agentic Data Proxy

Data Proxy 是部署在 Agent 关键边界上的学习数据层，同时负责：

• 拦截与采集：在 Agent 与模型、工具、检索系统之间拦截请求和响应
• 脱敏与权限控制：在数据进入训练队列之前完成治理
• 轨迹持久化：将交互数据存储为可回放的训练样本
• 奖励收集：从用户反馈、任务结果、系统指标中提取奖励信号

class AgenticDataProxy:
    def __init__(self, config):
        self.trajectory_store = TrajectoryStore(config.storage)
        self.privacy_filter = PrivacyFilter(config.privacy_rules)
        self.reward_extractor = RewardExtractor(config.reward_config)
    
    async def intercept_request(self, request: AgentRequest) -> AgentRequest:
        """拦截 Agent 请求，记录观察"""
        self.trajectory_store.append_observation(
            session_id=request.session_id,
            step_id=request.step_id,
            observation=request.to_observation()
        )
        return request
    
    async def intercept_response(self, response: AgentResponse) -> AgentResponse:
        """拦截 Agent 响应，记录动作和结果"""
        trajectory = self.trajectory_store.get_current(request.session_id)
        trajectory.append_action(response.to_action())
        trajectory.append_result(response.to_result())
        
        # 提取奖励信号
        reward = self.reward_extractor.extract(response)
        if reward is not None:
            trajectory.append_reward(reward)
        
        # 隐私过滤后持久化
        filtered = self.privacy_filter.apply(trajectory)
        await self.trajectory_store.persist(filtered)
        
        return response

支柱三：Agent Evolution Control Plane

Control Plane 决定「是否更新、更新哪里」。一个真实 Agent 由模型、prompt harness、记忆、工具、路由策略和安全规则共同组成，不同类型的失败对应不同的修复入口：

Control Plane 根据轨迹统计、用户修正率、工具失败簇、评估器得分、成本信号、安全约束和分布漂移，判断本次演进应落在哪个层面。

2.2 微服务化架构

AReaL 2.0 将训练、推理、权重更新等能力拆分为可独立使用、可组合、可扩展的服务组件：

┌─────────────────────────────────────────────────────────────┐
│                    Agent Service Layer                       │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐       │
│  │ Gateway │→│ Router  │→│Data Proxy│→│  Worker  │       │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘       │
│       ↑              ↑            ↑            ↑            │
│       │              │            │            │            │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐       │
│  │Controller│  │Controller│  │Controller│  │Controller│       │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘       │
└─────────────────────────────────────────────────────────────┘
       ↓              ↓            ↓            ↓
┌─────────────────────────────────────────────────────────────┐
│                    Training Service Layer                    │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐       │
│  │ Gateway │→│ Router  │→│Data Proxy│→│  Worker  │       │
│  │(训练入口)│  │(数据分配)│  │(轨迹加载)│  │(Megatron)│       │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘       │
└─────────────────────────────────────────────────────────────┘

每个组件在不同微服务中承担不同角色：

• Gateway：链路入口。在 Agent 服务中承接外部请求（HTTP/WebSocket），在推理服务中承接转接的会话，在训练服务中导入轨迹数据。
• Router：分配和维持会话关系。维护 session 与 Data Proxy 之间的绑定，确保同一任务的不同轮次落到同一数据代理。
• Data Proxy：会话状态和轨迹管理。保存 session 历史，整理请求发送给 Worker。
• Agent-Compute Worker：执行计算。在 Agent 服务中调用运行逻辑，在推理服务中执行 SGLang/vLLM 推理，在训练服务中执行 Megatron/FSDP 训练。

2.3 Online RL 工作流

完整的 Online RL 工作流如下：

1. Agent 接收真实用户任务
2. Gateway 路由请求到 Agent-Compute Worker
3. Worker 执行 Agent 逻辑，调用 LLM 推理
4. Data Proxy 拦截并记录完整轨迹（ATDP 格式）
5. 任务完成后，奖励信号绑定到轨迹
6. 满足训练条件时，轨迹进入训练队列
7. 训练 Worker 执行 RL 更新（支持 GRPO/PPO/KPop 等算法）
8. 新权重灰度发布到推理服务
9. Agent 使用更新后的模型继续服务

关键设计：Agent 的业务逻辑完全不变。开发者只需将 Agent 原本的 LLM 推理后端替换为 AReaL 2.0 管理的入口，就可以将真实交互纳入 RL 闭环。

三、代码实战

3.1 环境准备

# 克隆仓库
git clone https://github.com/areal-project/AReaL.git
cd AReaL

# 安装依赖（推荐 uv）
uv sync

# 或使用 pip
pip install -e .

3.2 最小示例：接入 Hermes Agent

AReaL 2.0 提供了 Hermes Agent 的完整接入示例。核心思路极其简洁——只需替换 base_url：

# 原始 Hermes Agent 配置
import openai

client = openai.OpenAI(
    base_url="https://api.anthropic.com/v1",  # 原始推理后端
    api_key="sk-xxx"
)

# 替换为 AReaL 2.0 的推理入口
client = openai.OpenAI(
    base_url="http://areal-gateway:8080/v1",  # AReaL 网关
    api_key="areal-xxx"
)

# Agent 逻辑完全不变
response = client.chat.completions.create(
    model="claude-4-opus",
    messages=[
        {"role": "system", "content": "你是一个编程助手。"},
        {"role": "user", "content": "帮我修复 main.py 中的 bug"}
    ],
    tools=[{
        "type": "function",
        "function": {
            "name": "code_edit",
            "description": "编辑代码文件",
            "parameters": {
                "type": "object",
                "properties": {
                    "file": {"type": "string"},
                    "line": {"type": "integer"},
                    "change": {"type": "string"}
                }
            }
        }
    }]
)

就这么简单。Agent 的规划逻辑、工具调用、沙箱环境、记忆模块完全不需要改动。AReaL 2.0 在后台默默记录交互轨迹，并在满足条件时触发 RL 训练。

3.3 软件工程 Agent RL 训练

AReaL 2.0 提供了面向 SWE（Software Engineering）Agent 的端到端训练流程：

# examples/swe/swe_agent_rl.yaml
agent:
  type: "swe_agent"
  base_model: "Qwen/Qwen3-235B-A22B"
  sandbox:
    type: "docker"
    image: "areal/swe-sandbox:latest"
    max_concurrent: 10000
    
training:
  algorithm: "grpo"
  batch_size: 128
  learning_rate: 1e-6
  kl_penalty: 0.02
  kpop:
    enabled: true
    metric: "binary_kl"
    threshold: 0.1

data:
  source: "online"  # 从线上 Agent 交互中获取
  proxy:
    privacy_filter: true
    reward_extraction:
      - type: "test_pass_rate"
      - type: "user_feedback"
      - type: "code_quality_score"

rollout:
  max_steps: 50
  timeout_seconds: 300
  parallel_envs: 512

训练流程的核心步骤：

from areal import AReaLTrainer, OnlineRLConfig

config = OnlineRLConfig.from_yaml("examples/swe/swe_agent_rl.yaml")
trainer = AReaLTrainer(config)

# 启动在线 RL 训练
# Agent 的真实交互会自动被采集并用于训练
trainer.train(
    total_steps=800,
    eval_interval=50,
    checkpoint_interval=100
)

3.4 KPop 稳定化策略

AReaL 2.0 引入了 KPop（双向二元 KL 散度 token 掩码）策略，解决 RL 训练后期容易崩溃的问题：

from areal.algorithms import KPopConfig, GRPOTrainer

kpop_config = KPopConfig(
    metric="binary_kl",           # 使用双向 KL 散度
    threshold=0.1,                 # KL 散度阈值
    direction="bidirectional",     # 双向过滤
    token_level=True               # Token 级自适应过滤
)

trainer = GRPOTrainer(
    model=model,
    kpop=kpop_config,
    # 其他配置...
)

# KPop 的核心思想：
# 当训练引擎和推理引擎之间的 logp 差异过大时，
# 自动过滤掉这些 token，防止训练信号过于嘈杂

3.5 自定义奖励函数

from areal.rewards import RewardFunction

class CodeQualityReward(RewardFunction):
    """基于代码质量的奖励函数"""
    
    def __init__(self):
        self.metrics = {
            "test_pass": 1.0,      # 测试通过
            "lint_clean": 0.3,     # 代码风格
            "type_check": 0.2,     # 类型检查
            "no_regression": 0.5   # 无回归
        }
    
    def compute(self, trajectory, result) -> float:
        reward = 0.0
        
        # 测试通过率
        if result.get("tests_passed"):
            reward += self.metrics["test_pass"]
        
        # 代码质量
        if result.get("lint_score", 0) > 0.9:
            reward += self.metrics["lint_clean"]
        
        # 类型检查
        if result.get("type_check_clean"):
            reward += self.metrics["type_check"]
        
        # 无回归（原有测试仍然通过）
        if result.get("no_regression"):
            reward += self.metrics["no_regression"]
        
        return reward

# 注册自定义奖励函数
trainer.register_reward("code_quality", CodeQualityReward())

3.6 防止 Reward Hacking

AReaL 2.0 在训练 Claude Code 类黑盒 Agent 时，采用了多种防 reward hacking 措施：

from areal.security import AntiHackingConfig

anti_hacking = AntiHackingConfig(
    # 禁用 git 操作，防止 Agent 通过 git 查看答案
    blocked_commands=["git log", "git show", "git diff HEAD~"],
    
    # Token-in-Token-out 对齐方式
    alignment="token_in_token_out",
    
    # 轨迹验证
    trajectory_validation={
        "max_tool_calls": 50,
        "require_reasoning": True,
        "ban_shortcuts": ["grep -r 'solution'", "cat test_answer*"]
    }
)

四、从 Hermes 到 Claude Code：实战范例

4.1 Hermes Agent 接入范例

Hermes 是 AReaL 团队展示的第一个接入范例，核心价值在于低侵入式接入：

# examples/hermes/hermes_online_rl.py
from areal import OnlineRLServer, AgentBridge

# 创建 Online RL 服务
server = OnlineRLServer(
    gateway_port=8080,
    router_strategy="session_affinity",
    data_proxy_config={
        "storage": "redis://localhost:6379",
        "privacy_filter": True,
        "trajectory_format": "atdp"
    }
)

# 桥接现有 Agent
bridge = AgentBridge(
    agent_type="hermes",
    # 只需替换推理后端
    inference_endpoint="http://areal-gateway:8080/v1",
    # Agent 的其他组件完全不动
    tools=["code_edit", "file_read", "terminal", "search"],
    memory_backend="chromadb"
)

# 启动服务
server.start()
bridge.connect()

# Agent 现在会自动参与在线 RL
# 后台会采集轨迹、提取奖励、触发训练

4.2 Claude Code Agent RL 训练

更接近生产的是 Claude Code Agent 的 RL 训练流程：

# examples/swe/claude_code_rl.py
from areal import SWERLTrainer, SWEConfig

config = SWEConfig(
    # 数据筛选：只保留至少有一个外部模型能解出的问题
    data_filter="at_least_one_solver",
    
    # 种子 issue 改写：让问题表述更清晰
    issue_rewrite=True,
    
    # 大规模并发 sandbox
    sandbox={
        "type": "distributed",
        "max_instances": 10000,
        "fork_startup_ms": 50,  # 毫秒级 fork 启动
        "image_preheat": True
    },
    
    # KPop 稳定化策略
    kpop={"enabled": True, "metric": "binary_kl"},
    
    # 防 reward hacking
    anti_hacking={
        "blocked_git_ops": ["log", "show", "diff"],
        "alignment": "token_in_token_out"
    }
)

trainer = SWERLTrainer(config)

# 800 步训练实现稳定涨分
trainer.train(total_steps=800)

训练结果：模型在经过 800 步训练后实现稳定涨分，验证了 AReaL 2.0 在软件工程 Agent 训练上的可行性。

五、性能基准与对比

5.1 AReaL-SEA 模型性能

AReaL 团队此前发布的 AReaL-SEA（Self-Evolving Agent）在 τ²-bench 上的表现：

AReaL-SEA-235B 在经过 RL 训练后，性能逼近 Gemini 3.0 Pro，超越 GPT-5。

5.2 训练效率

AReaL 2.0 的全异步 RL 训练范式带来显著的效率提升：

5.3 与其他方案对比

六、生态与社区

6.1 PyTorch 基金会生态项目

2026 年 5 月，AReaL 从蚂蚁 inclusionAI 孵化成为独立社区，加入 PyTorch 基金会 Ecosystem 项目。这意味着：

• 更开放的治理结构
• 更广泛的社区参与
• 与 PyTorch 生态的深度集成

6.2 华为昇腾 NPU 适配

华为云团队为 AReaL 提供了国产昇腾 NPU 的端到端适配：

# 在昇腾 NPU 上安装 AReaL
pip install areal[npu]

# 配置 NPU 训练
export ASCEND_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
python -m areal.train --config swe_agent_rl.yaml --device npu

6.3 MindLab 低算力方案

MindLab 提供了基于 LoRA 的低算力场景解决方案：

# 使用 LoRA 进行低算力 RL 训练
training:
  method: "lora"
  lora_rank: 64
  lora_alpha: 128
  target_modules: ["q_proj", "v_proj", "k_proj", "o_proj"]
  # 只需 4 张 A100 即可训练 235B 模型
  gpus: 4

七、实战部署指南

7.1 Docker Compose 一键部署

# docker-compose.yml
version: '3.8'
services:
  areal-gateway:
    image: areal/gateway:latest
    ports:
      - "8080:8080"
    environment:
      - ROUTER_STRATEGY=session_affinity
      - DATA_PROXY_REDIS=redis://redis:6379
    
  areal-router:
    image: areal/router:latest
    environment:
      - GATEWAY_URL=http://areal-gateway:8080
    
  areal-data-proxy:
    image: areal/data-proxy:latest
    environment:
      - REDIS_URL=redis://redis:6379
      - PRIVACY_FILTER=true
      - TRAJECTORY_FORMAT=atdp
    
  areal-worker:
    image: areal/worker:latest
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    environment:
      - INFERENCE_BACKEND=vllm
      - MODEL_NAME=Qwen/Qwen3-235B-A22B
    
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

7.2 接入现有 Agent 的检查清单

1. ✅ 确认 Agent 使用 OpenAI 兼容 API 调用 LLM
2. ✅ 部署 AReaL Gateway 服务
3. ✅ 将 Agent 的 base_url 指向 AReaL Gateway
4. ✅ 配置 Data Proxy 的隐私过滤规则
5. ✅ 定义奖励函数（基于任务结果/用户反馈）
6. ✅ 设置训练触发条件（轨迹数量/时间间隔）
7. ✅ 配置灰度发布策略

八、总结与展望

AReaL 2.0 解决的是 Agent 从「会做事」到「越做越好」的关键跃迁。它的核心贡献不在于提出了新的 RL 算法，而在于将 Online RL 工程化、微服务化、可接入化。

三个关键设计决策值得深思：

1. 最小侵入原则：只替换 base_url，Agent 业务逻辑零改动。这大幅降低了 Agent 自演进的工程门槛。
2. 治理优先原则：数据在进入训练队列之前就完成脱敏、权限控制、质量筛选。企业级场景必须如此。
3. 解耦再组合原则：训练、推理、数据采集三大能力拆分为独立微服务，按需组合。这让同一套基础设施能适配从 4 GPU 到万卡集群的各种规模。

展望未来，AReaL 团队正在探索两个方向：

• AReaL-AutoPilot：让 Agent 参与 RL 方案的自动生成，包括自动搜索最优并行策略、自动监控训练曲线健康状态。
• 统一芯片适配标准：为不同芯片厂商提供统一的 RL infra 适配接口，包括算子精度对齐、权重传输统一格式。

Agent 的自演进时代已经到来。AReaL 2.0 提供了一条可复用的工程路径，让「越用越强」从少数团队的定制化工程，变成所有开发者都可以接入的基础设施。

项目资源

• GitHub：https://github.com/areal-project/AReaL
• 论文（v2.0）：https://arxiv.org/pdf/2607.01120
• 论文（v1.0）：https://arxiv.org/pdf/2505.24298
• 文档：https://areal-project.github.io/AReaL/
• 模型：https://huggingface.co/collections/inclusionAI/