AReaL：当异步强化学习遇上大模型Agent，训练效率狂飙2.77倍

一、为什么Agent训练需要强化学习？

如果说大语言模型是AI的"大脑"，那强化学习（Reinforcement Learning，RL）就是让这个大脑学会"思考"的教练。

传统的监督微调（SFT）让模型学会了模仿，但模仿有个致命问题：你永远无法超越模仿对象。想让AI Agent真正具备解决复杂问题的能力，光靠看答案是不够的，它需要：

1. 探索能力：尝试不同的解决方案，找到最优路径
2. 反馈机制：从成功和失败中学习，不断迭代策略
3. 长期规划：考虑多步决策的累积收益，而非贪图眼前

这正是强化学习的核心思想——让Agent在与环境的交互中，通过奖励信号不断优化自己的策略。

但问题来了：传统RL训练大模型，慢！太慢了！

同步RL的效率瓶颈

传统同步RL训练遵循严格的"收集-计算-更新"循环：

┌─────────────────────────────────────────────────────────┐
│  同步RL训练流程                                          │
│                                                         │
│  收集数据 → 等待所有Actor完成 → 计算优势 → 更新参数 → 重复 │
│    ↓              ↓                 ↓          ↓        │
│  浪费等待时间    GPU空转           计算瓶颈    同步开销    │
└─────────────────────────────────────────────────────────┘

举个具体例子：假设你有8块GPU，训练一个7B模型做数学推理。每轮需要：

• 生成64条推理链（每条平均512 token）
• 等待所有GPU完成生成
• 统一计算PPO损失
• 同步更新模型参数

这里面最大的浪费是什么？等待。当第1块GPU生成完推理链后，它要等第2、第3...直到第8块全部完成。这期间GPU利用率可能只有30-50%。

更糟糕的是，当任务变得复杂（比如多轮工具调用的Agent），单次交互可能需要几百个步骤，同步等待的时间会被无限放大。

二、异步RL：打破同步枷锁的关键突破

核心思想：边生成边训练

AReaL（Async RL）的核心创新非常简单，但极其有效：让数据生成和模型训练并行进行。

┌────────────────────────────────────────────────────────────┐
│  异步RL训练流程                                              │
│                                                            │
│  Actor 1: 生成轨迹 → 放入Buffer → 继续生成 → 放入Buffer      │
│  Actor 2: 生成轨迹 → 放入Buffer → 继续生成 → 放入Buffer      │
│  Actor N: 生成轨迹 → 放入Buffer → 继续生成 → 放入Buffer      │
│              ↓                                              │
│  Learner: 从Buffer取出数据 → 计算梯度 → 更新模型 → 持续训练  │
└────────────────────────────────────────────────────────────┘

关键变化：

1. 消除等待：Actor和Learner独立运行，谁都不需要等谁
2. 流水线并行：数据生成和模型训练同时进行
3. 动态调度：Buffer满就训练，不关心数据来源

异步带来的性能飞跃

AReaL官方报告显示，在相同的硬件配置下：

2.77倍是什么概念？原来需要训练7天的模型，现在只需要2.5天。对于大规模实验，这意味着：

• 原来一个月能跑4组实验 → 现在能跑11组
• 原来要花10万的算力成本 → 现在只要3.6万

稍微旧的数据也能用？

异步RL有个常见担忧：训练时用的数据可能是"旧"模型生成的（因为生成和训练并行），这会不会影响训练效果？

这正是AReaL需要解决的核心技术难题。它引入了**最大策略偏离度（max_head_offpolicyness）**参数来控制这个问题：

# 核心配置示例
config = {
    "max_head_offpolicyness": 0.2,  # 控制新旧策略的最大差异
    "buffer_size": 1024,             # 经验回放缓冲区大小
    "staleness_limit": 10,           # 数据最大"陈旧度"
}

当 max_head_offpolicyness=0 时，异步RL退化为同步模式；设置为合理的非零值，可以在效率和质量之间找到最佳平衡点。

三、AReaL架构深度剖析

整体架构

AReaL采用典型的Actor-Learner分离架构，但针对大规模异步训练做了深度优化：

┌─────────────────────────────────────────────────────────────────┐
│                       AReaL 系统架构                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐             │
│  │  Actor 1    │  │  Actor 2    │  │  Actor N    │  ← 数据生成    │
│  │  (GPU推理)   │  │  (GPU推理)   │  │  (GPU推理)   │             │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘             │
│         │                │                │                     │
│         ▼                ▼                ▼                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │           Shared Experience Buffer (经验池)               │   │
│  │  ┌──────┬──────┬──────┬──────┬──────┬──────┬──────┬─────┐ │   │
│  │  │ traj │ traj │ traj │ traj │ traj │ traj │ traj │ ... │ │   │
│  │  └──────┴──────┴──────┴──────┴──────┴──────┴──────┴─────┘ │   │
│  └────────────────────────────┬────────────────────────────┘   │
│                               │                                │
│                               ▼                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              Learner (训练节点)                           │   │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐       │   │
│  │  │  优势计算     │  │  策略更新    │  │  价值函数训练 │       │   │
│  │  │  (GRPO/PPO)  │  │  (梯度下降)   │  │  (Critic)    │       │   │
│  │  └─────────────┘  └─────────────┘  └─────────────┘       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

核心组件详解

1. Actor：数据生成引擎

Actor负责与环境交互，生成训练数据：

import torch
from areal import Actor, RolloutConfig

# 初始化Actor
actor = Actor(
    model_name="Qwen/Qwen2-7B-Instruct",
    backend="sglang",  # 支持sglang/vllm
    tensor_parallel_size=2,
)

# 配置采样参数
rollout_config = RolloutConfig(
    max_new_tokens=512,
    temperature=0.8,
    top_p=0.95,
    n_samples=4,  # 每个prompt生成4条轨迹
)

# 生成轨迹
trajectories = actor.generate(
    prompts=["计算 sqrt(2) + sqrt(3) 的近似值"],
    config=rollout_config,
)

2. Learner：策略优化核心

Learner负责从Buffer中取数据、计算损失、更新模型：

from areal import Learner, GRPOConfig

# 初始化Learner
learner = Learner(
    model_name="Qwen/Qwen2-7B-Instruct",
    ref_model_name="Qwen/Qwen2-7B-Instruct",  # 参考模型（KL散度）
    learning_rate=1e-5,
    batch_size=64,
)

# 配置GRPO算法
grpo_config = GRPOConfig(
    kl_coef=0.01,           # KL散度系数
    clip_ratio=0.2,          # PPO裁剪比率
    entropy_coef=0.01,      # 熵正则化系数
    max_grad_norm=1.0,       # 梯度裁剪
    group_size=4,           # GRPO分组大小
)

# 训练循环
for batch in buffer.sample(batch_size=64):
    loss = learner.compute_loss(batch, grpo_config)
    learner.step(loss)

3. Experience Buffer：经验回放中心

Buffer是Actor和Learner之间的桥梁：

from areal import AsyncReplayBuffer

buffer = AsyncReplayBuffer(
    max_size=10000,
    staleness_limit=10,  # 最大陈旧度
    priority_sampling=True,  # 优先采样高奖励数据
)

# Actor写入
buffer.push(trajectory)

# Learner读取
batch = buffer.sample(batch_size=64)

四、算法深度解析：从PPO到GRPO

AReaL支持多种主流RL算法，我们重点解析两个核心算法。

PPO：经典的稳健选择

PPO（Proximal Policy Optimization）是最经典的策略梯度算法之一，核心思想是限制策略更新的幅度，避免更新太激进导致性能崩溃。

PPO的目标函数：

$$L^{CLIP}(\theta) = \mathbb{E}_t \left[ \min\left( r_t(\theta) \hat{A}_t, \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) \hat{A}_t \right) \right]$$

其中：

• $r_t(\theta) = \frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{old}}(a_t|s_t)}$ 是新旧策略的概率比
• $\hat{A}_t$ 是优势函数估计值
• $\epsilon$ 是裁剪参数（通常0.1-0.2）

def ppo_loss(logits, old_logits, actions, advantages, clip_ratio=0.2):
    """
    PPO损失函数实现
    
    Args:
        logits: 当前策略的logits [batch, seq_len, vocab_size]
        old_logits: 旧策略的logits
        actions: 实际采取的动作 [batch, seq_len]
        advantages: 优势函数 [batch, seq_len]
        clip_ratio: 裁剪参数
    """
    # 计算新旧策略的概率比
    log_probs = F.log_softmax(logits, dim=-1)
    old_log_probs = F.log_softmax(old_logits, dim=-1)
    
    # 获取实际动作的概率
    action_log_probs = log_probs.gather(-1, actions.unsqueeze(-1)).squeeze(-1)
    old_action_log_probs = old_log_probs.gather(-1, actions.unsqueeze(-1)).squeeze(-1)
    
    ratio = torch.exp(action_log_probs - old_action_log_probs)
    
    # 裁剪目标
    clipped_ratio = torch.clamp(ratio, 1 - clip_ratio, 1 + clip_ratio)
    
    # 取最小值（保守更新）
    loss = -torch.min(ratio * advantages, clipped_ratio * advantages).mean()
    
    return loss

GRPO：Group Relative Policy Optimization

GRPO是AReaL的默认算法，它在PPO基础上做了关键改进：组内相对优势。

核心思想：与其单独估计每个动作的绝对优势，不如在组内比较相对表现。

假设同一个prompt生成了G条轨迹，GRPO定义：

$$\hat{A}_{i,g} = \frac{R_g - \mu_G}{\sigma_G}$$

其中：

• $R_g$ 是第g条轨迹的累积奖励
• $\mu_G$ 是组内平均奖励
• $\sigma_G$ 是组内标准差

这个设计有几个好处：

1. 消除奖励scale依赖：不同任务的奖励范围可能差异巨大，归一化后统一处理
2. 降低方差：组内比较比跨组比较更稳定
3. 天然支持比较式学习：符合人类"相对评价"的认知模式

def grpo_loss(logits, old_logits, actions, rewards, group_size=4, kl_coef=0.01):
    """
    GRPO损失函数实现
    
    Args:
        logits: 当前策略的logits [batch, seq_len, vocab_size]
        old_logits: 旧策略的logits
        actions: 实际采取的动作 [batch, seq_len]
        rewards: 每条轨迹的总奖励 [batch]
        group_size: 每组的轨迹数量
        kl_coef: KL散度系数
    """
    batch_size = logits.shape[0]
    num_groups = batch_size // group_size
    
    # 计算组内归一化优势
    rewards = rewards.view(num_groups, group_size)
    mean = rewards.mean(dim=1, keepdim=True)
    std = rewards.std(dim=1, keepdim=True) + 1e-8
    normalized_rewards = (rewards - mean) / std
    advantages = normalized_rewards.view(batch_size).unsqueeze(1).expand(-1, logits.shape[1])
    
    # PPO裁剪损失
    log_probs = F.log_softmax(logits, dim=-1)
    old_log_probs = F.log_softmax(old_logits, dim=-1)
    action_log_probs = log_probs.gather(-1, actions.unsqueeze(-1)).squeeze(-1)
    old_action_log_probs = old_log_probs.gather(-1, actions.unsqueeze(-1)).squeeze(-1)
    
    ratio = torch.exp(action_log_probs - old_action_log_probs)
    clipped_ratio = torch.clamp(ratio, 0.8, 1.2)
    policy_loss = -torch.min(ratio * advantages, clipped_ratio * advantages).mean()
    
    # KL散度损失（保持策略稳定）
    kl_loss = F.kl_div(
        log_probs.view(-1, log_probs.size(-1)),
        old_log_probs.view(-1, old_log_probs.size(-1)),
        reduction='batchmean'
    )
    
    return policy_loss + kl_coef * kl_loss

算法对比

五、代码实战：训练你的第一个数学推理Agent

让我们用AReaL训练一个数学推理模型。

环境准备

# 克隆仓库
git clone https://github.com/inclusionAI/AReaL
cd AReaL

# 安装依赖
pip install uv
uv sync --extra cuda

GSM8K数学推理训练

# gsm8k_rl.py
from areal import AReaLTrainer, GRPOConfig, DataConfig

# 数据配置
data_config = DataConfig(
    dataset_name="openai/gsm8k",
    split="train",
    max_prompt_length=512,
    max_response_length=1024,
)

# 算法配置
algo_config = GRPOConfig(
    learning_rate=1e-5,
    batch_size=64,
    group_size=4,  # 每个prompt生成4条轨迹
    kl_coef=0.01,
    clip_ratio=0.2,
    max_grad_norm=1.0,
    temperature=0.8,
)

# 异步训练配置
async_config = {
    "max_head_offpolicyness": 0.2,
    "buffer_size": 2048,
    "num_actors": 8,
    "num_learners": 1,
}

# 初始化训练器
trainer = AReaLTrainer(
    model_name="Qwen/Qwen2-7B-Instruct",
    ref_model_name="Qwen/Qwen2-7B-Instruct",
    data_config=data_config,
    algo_config=algo_config,
    async_config=async_config,
    output_dir="./output/gsm8k_grpo",
)

# 开始训练
trainer.train(
    num_epochs=3,
    eval_steps=100,
    save_steps=500,
)

定义奖励函数

数学推理的奖励函数设计是关键：

import re

def math_reward_fn(response: str, ground_truth: str) -> float:
    """
    数学问题奖励函数
    
    评估标准：
    1. 最终答案是否正确（核心）
    2. 推理过程是否清晰（辅助）
    3. 格式是否规范（辅助）
    """
    # 提取最终答案
    # GSM8K格式: "The answer is 42."
    answer_pattern = r"The answer is (-?\d+\.?\d*)"
    match = re.search(answer_pattern, response)
    
    if not match:
        # 格式错误，重罚
        return -1.0
    
    predicted = float(match.group(1))
    truth = float(ground_truth)
    
    # 答案正确性
    if abs(predicted - truth) < 1e-4:
        answer_reward = 1.0
    else:
        # 部分正确奖励
        relative_error = abs(predicted - truth) / (abs(truth) + 1e-8)
        answer_reward = max(0, 1 - relative_error)
    
    # 推理过程奖励（可选）
    step_count = response.count("Step") + response.count("步骤")
    format_reward = min(0.1 * step_count, 0.3)  # 最多0.3额外奖励
    
    return answer_reward + format_reward


# 注册奖励函数
trainer.register_reward_fn("math", math_reward_fn)

启动训练

单机训练：

python gsm8k_rl.py --config configs/gsm8k_grpo.yaml scheduler.type=local

多机分布式训练：

# 节点0（主节点）
python gsm8k_rl.py --config configs/gsm8k_grpo.yaml \
    cluster.n_nodes=4 \
    cluster.n_gpus_per_node=8 \
    scheduler.type=ray \
    scheduler.head_node=true

# 节点1-3（工作节点）
python gsm8k_rl.py --config configs/gsm8k_grpo.yaml \
    scheduler.type=ray \
    scheduler.head_address=<主节点IP>:6379

六、性能优化实战

异步训练参数调优

AReaL的异步训练有几个关键参数：

# async_config.yaml
async_training:
  # 最大策略偏离度：控制数据"陈旧度"容忍度
  # 值越大，效率越高，但可能影响稳定性
  max_head_offpolicyness: 0.2
  
  # 经验池大小：影响数据多样性
  buffer_size: 2048
  
  # 数据过期阈值：太旧的数据会被丢弃
  staleness_limit: 10
  
  # Actor数量：更多Actor意味着更高吞吐
  num_actors: 8
  
  # Learner数量：通常设为1（单learner多卡）
  num_learners: 1

调优建议：

推理后端选择

AReaL支持SGLang和vLLM两种推理后端：

# SGLang（推荐，默认）
actor = Actor(
    model_name="Qwen/Qwen2-7B-Instruct",
    backend="sglang",
    tensor_parallel_size=2,
)

# vLLM（备选）
actor = Actor(
    model_name="Qwen/Qwen2-7B-Instruct",
    backend="vllm",
    tensor_parallel_size=2,
)

性能对比（A100 80GB，7B模型）：

显存优化技巧

训练大模型，显存是第一瓶颈。几个关键技巧：

1. 使用LoRA降低训练参数量：

# lora_config.yaml
model:
  lora:
    enabled: true
    r: 16
    alpha: 32
    dropout: 0.05
    target_modules: ["q_proj", "v_proj", "k_proj", "o_proj"]

2. 启用梯度检查点：

training:
  gradient_checkpointing: true
  micro_batch_size: 1
  gradient_accumulation_steps: 8

3. 优化推理显存：

actor = Actor(
    model_name="Qwen/Qwen2-7B-Instruct",
    gpu_memory_utilization=0.85,  # 预留空间给训练
    max_model_len=4096,  # 限制最大序列长度
    enforce_eager=true,  # 禁用CUDA图（节省显存）
)

七、多模态与Agent场景

AReaL不止于文本，它支持完整的多模态训练。

视觉语言模型（VLM）训练

from areal import VLMActor, VLMConfig

# 初始化视觉编码器+语言模型
vlm_actor = VLMActor(
    model_name="Qwen/Qwen2-VL-7B-Instruct",
    vision_encoder="siglip-so400m-patch14-448",  # 视觉编码器
    backend="sglang",
)

# 视觉推理奖励函数
def vlm_math_reward(response: str, ground_truth: str, image_features) -> float:
    """
    视觉数学推理奖励
    例如：看图计算几何问题
    """
    # 1. 检查是否正确引用了图像信息
    image_refs = response.count("<image>")
    if image_refs == 0:
        return -0.5  # 惩罚忽略图像
    
    # 2. 检查答案正确性
    answer_match = re.search(r"The answer is (-?\d+\.?\d*)", response)
    if not answer_match:
        return -1.0
    
    predicted = float(answer_match.group(1))
    truth = float(ground_truth)
    
    return 1.0 if abs(predicted - truth) < 1e-4 else 0.0

Agent工作流训练

最强大的应用场景——训练真正的Agent：

from areal import AgentTrainer, AgentConfig

# 定义Agent工具集
tools = [
    {
        "name": "web_search",
        "description": "搜索互联网获取信息",
        "parameters": {
            "query": {"type": "string", "description": "搜索关键词"}
        }
    },
    {
        "name": "code_execute", 
        "description": "执行Python代码进行计算",
        "parameters": {
            "code": {"type": "string", "description": "Python代码"}
        }
    },
    {
        "name": "calculator",
        "description": "精确数学计算",
        "parameters": {
            "expression": {"type": "string", "description": "数学表达式"}
        }
    }
]

# Agent配置
agent_config = AgentConfig(
    tools=tools,
    max_turns=20,  # 最多20轮交互
    reward_shaping="trajectory",  # 轨迹级别奖励
)

# 初始化Agent训练器
agent_trainer = AgentTrainer(
    model_name="Qwen/Qwen2-7B-Instruct",
    agent_config=agent_config,
    async_config=async_config,
)

# 定义任务奖励（关键！）
def agent_task_reward(trajectory: List[dict], task: str, answer: str) -> float:
    """
    Agent任务奖励函数
    
    评估维度：
    1. 任务是否完成
    2. 工具使用是否合理
    3. 推理路径是否高效
    """
    total_reward = 0.0
    
    # 1. 任务完成奖励（核心）
    final_response = trajectory[-1]["content"]
    if verify_answer(final_response, answer):
        total_reward += 1.0
    
    # 2. 工具使用效率奖励
    tool_calls = [t for t in trajectory if t.get("tool_call")]
    if len(tool_calls) > 0:
        # 有效工具调用奖励
        total_reward += 0.1 * min(len(tool_calls), 5)
    
    # 3. 效率惩罚（步骤太多扣分）
    efficiency_penalty = -0.05 * max(0, len(trajectory) - 10)
    total_reward += efficiency_penalty
    
    return total_reward

# 开始Agent训练
agent_trainer.train(
    tasks="datasets/agent_tasks.json",
    num_epochs=10,
)

ASearcher：搜索Agent实战案例

AReaL团队开源了ASearcher，一个SOTA搜索Agent：

# 安装ASearcher
pip install asearcher

# 使用预训练模型
python -m asearcher.web \
    --model inclusionAI/ASearcher-Web-QwQ \
    --query "2026年诺贝尔物理学奖获得者是谁？"

ASearcher核心能力：

关键创新点：ASearcher通过异步RL训练，学会了"极端长程搜索"，单次搜索可以超过100轮工具调用——这是同步RL难以企及的。

八、昇腾NPU适配：国产算力的新选择

2026年1月，AReaL v1.0正式支持华为昇腾NPU：

# 安装昇腾版本
git clone -b ascend https://github.com/inclusionAI/AReaL
cd AReaL
pip install uv
uv sync --extra npu

昇腾 vs NVIDIA 性能对比

在相同模型配置下（Qwen2-7B，批量推理）：

性价比：昇腾达到NVIDIA的84%性能，但价格只有60%，性价比提升约40%。

九、生产级部署实践

Docker容器化部署

# Dockerfile.areal
FROM pytorch/pytorch:2.9.0-cuda12.4-cudnn9-runtime

# 安装AReaL
RUN git clone https://github.com/inclusionAI/AReaL /opt/areal && \
    cd /opt/areal && \
    pip install uv && \
    uv sync --extra cuda

# 设置环境变量
ENV PYTHONPATH=/opt/areal
ENV HF_HOME=/workspace/huggingface

WORKDIR /workspace
ENTRYPOINT ["python", "-m", "areal.cli"]

# docker-compose.yml
version: '3.8'
services:
  areal-trainer:
    build: .
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 8
              capabilities: [gpu]
    environment:
      - HF_TOKEN=${HF_TOKEN}
      - WANDB_API_KEY=${WANDB_API_KEY}
    volumes:
      - ./data:/workspace/data
      - ./output:/workspace/output
      - hf-cache:/workspace/huggingface
    command: >
      python examples/math/gsm8k_rl.py
      --config configs/gsm8k_grpo.yaml
      cluster.n_nodes=1
      cluster.n_gpus_per_node=8

volumes:
  hf-cache:

Kubernetes分布式部署

# areal-job.yaml
apiVersion: kubeflow.org/v1
kind: PyTorchJob
metadata:
  name: areal-gsm8k-training
spec:
  pytorchReplicaSpecs:
    Master:
      replicas: 1
      restartPolicy: OnFailure
      template:
        spec:
          containers:
            - name: pytorch
              image: areal/trainer:latest
              resources:
                limits:
                  nvidia.com/gpu: 8
              env:
                - name: RANK
                  value: "0"
              command: ["python", "examples/math/gsm8k_rl.py"]
              args:
                - --config=configs/gsm8k_grpo.yaml
                - cluster.n_nodes=4
                - scheduler.type=ray
    Worker:
      replicas: 3
      restartPolicy: OnFailure
      template:
        spec:
          containers:
            - name: pytorch
              image: areal/trainer:latest
              resources:
                limits:
                  nvidia.com/gpu: 8
              env:
                - name: MASTER_ADDR
                  valueFrom:
                    fieldRef:
                      fieldPath: status.podIP

十、总结与展望

核心收获

AReaL代表了大规模RL训练的未来方向：

1. 异步是必然趋势：同步训练的等待开销在大规模场景下无法接受
2. 灵活是生存之本：支持多种算法、多种后端、多种硬件
3. Agent是终极目标：从单一任务到复杂工作流，RL是必经之路

技术路线图

2024                    2025                    2026
  │                       │                       │
  ▼                       ▼                       ▼
┌─────┐               ┌─────────┐            ┌───────────┐
│ PPO │───────────→   │ Async RL │ ──────→   │ Agentic RL│
│ SFT │               │ (boba²)  │            │ (AReaL)   │
└─────┘               └─────────┘            └───────────┘
  │                       │                       │
  ▼                       ▼                       ▼
单任务推理           多任务高效训练          复杂Agent工作流

开源生态

写在最后

当OpenAI用RL训练出o1的推理能力，当Anthropic用RL让Claude学会自主决策，强化学习已经不再是学术玩具，而是通往AGI的必经之路。

AReaL的价值在于：它把这条路的门槛，从"OpenAI级别"降到了"每个人都能尝试"。

你不需要几千块H100，不需要顶级研究团队，只需要几块GPU和AReaL，就能训练出属于自己的推理Agent。

这，才是开源的意义。

参考资料：

1. AReaL GitHub: https://github.com/inclusionAI/AReaL
2. ASearcher论文: arXiv:2508.07976
3. EigenData论文: arXiv:2601.22607
4. GRPO论文: https://arxiv.org/abs/2402.03300
5. AReaL官方文档: https://inclusionai.github.io/AReaL/