Heterogeneous Agent Collaborative Reinforcement Learning

Paper: arXiv:2603.02604 Project: zzx-peter.github.io/hacrl Code: none — no public official implementation is documented. Code search: 代码搜索未找到开源实现（指作者/官方发布的 public implementation；已检查 arXiv/PDF/source、project page、HuggingFace author comment、title/acronym/arXiv ID GitHub 搜索与 plausible author/project-owner probes；发现 Fred990807/HACRL 为 HuggingFace 社区评论中的 unofficial implementation，不作为本文 github_ref）。

1. Motivation (研究动机)

当前 RLVR（Reinforcement Learning with Verifiable Rewards）在训练 reasoning LLM 时通常采用 GRPO / GSPO 这类 group-based on-policy optimization：同一个模型对同一个 prompt 采样 $G$ 条 response，用 verifier 得到 reward，再只用自己的 rollout 更新自己。这个范式有两个直接浪费：第一，每个 agent 都在同一类题目上重复采样，其他 agent 已经生成并验证过的中间结果被丢弃；第二，多个模型可能有互补能力，例如强模型给出更稳定的高 reward 解法，弱模型偶尔探索到不同 reasoning path，但孤立训练无法交换这些信号。

论文要解决的具体问题是：在多个 heterogeneous LLM agents 都需要针对同一 RLVR 任务提升时，如何让它们在训练阶段共享 verified rollouts，并且在推理阶段仍然可以独立部署。这个目标不同于 LLM-based MARL：MARL 往往训练多个 agent 在执行时协作或通信，而 HACRL 的推理形态仍是单 agent 独立回答。它也不同于 distillation：distillation 通常是 teacher-to-student 单向迁移，且常假设 teacher/student 关系固定；HACRL 希望每个 agent 同时是 learner 和 knowledge provider。

这个问题值得研究，是因为 RLVR 的主要成本来自 rollout sampling 和 verifier evaluation。如果一个 agent 的 rollout 可以被其他 agents 原则性地复用，训练成本不需要按 agent 数线性增加；同时，不同模型大小、不同 tokenizer、不同 fine-tuning state 之间的互补探索也可能提升最终 reasoning accuracy。论文实验证明 HACPO 在三类异构设置下都能提升参与 agent，并且相对 GSPO$\times 2$ 这个 rollout 加倍 baseline 仍有平均收益，说明收益不是简单来自“看了更多样本”。

2. Idea (核心思想)

核心 insight：HACRL 把“同一个 verifier 已经判过的 rollout”视为多 agent 之间可共享的训练资产，但共享不能 naive replay；每个 agent 必须按自身能力水平和 policy distribution 对外来 rollout 重新校准 advantage 与 importance weight。

HACPO 的创新不是让 agents 在推理时对话，而是在训练时把所有 agents 的 response/reward pool 变成 collaborative optimization signal：self rollouts 走类似 GSPO 的 on-policy objective，cross-agent rollouts 走 capability-aware baseline、capability-scaled advantage、exponential importance sampling 和 stepwise clipping 组合成的 heterogeneous objective。

与 GSPO 的根本差异：GSPO 只对单一 agent 的 own-policy trajectory 做 sequence-level policy optimization；HACPO 为每个 agent 额外引入 $J_{\mathrm{hete}}$，让它学习其他 heterogeneous agents 的 verified rollouts。与 naive rollout sharing 的差异：HACPO 不直接把其他模型样本当同分布数据，而是显式处理 capability discrepancy 与 policy distribution shift。

3. Method (方法)

3.1 HACRL problem definition：协同优化、独立执行

论文将 heterogeneous agents 分成三类：

• Heterogeneous State：架构与参数维度相同，但协同训练开始时权重不同，例如 Qwen3-4B 与 Qwen3-4B-Instruct。
• Heterogeneous Size：同一模型家族、设计原则相同，但参数规模不同，例如 Qwen3-1.7B-Base 与 Qwen3-4B-Base。
• Heterogeneous Model：架构、tokenizer 或训练目标不同，例如 Qwen3-4B-Base 与 Llama3.2-3B-Instruct。

给定 prompt $x\sim \mathcal{D}$，每个 agent $k$ 独立从自己的 policy 采样 $G$ 条 response，并由 verifier 给出 reward。HACRL 对每个 agent 的目标写成 self term 与 cross-agent term 的和： $ J^{(k)}

J_{\mathrm{homo}}^{(k)}!\left(Y^{(k)}t(x), \mathcal R^{(k)}t(x)\right) + J{\mathrm{hete}}^{(k)}!\left({Y^{(j)}t(x), \mathcal R^{(j)}t(x)}{j \neq k}\right). $这里$J{\mathrm{homo}}^{(k)}$使用agent$k$自己生成的rollout，$J{\mathrm{hete}}^{(k)}$ 使用其他 agents 的 rollout。关键设计约束是：训练时共享 response/reward，推理时不需要其他 agents 存在。

3.2 Overall framework

Figure 1 解读：图中每个 heterogeneous agent 仍然各自生成 response 并接受 verifiable reward，但 HACPO 不再把这些 rollouts 封闭在各自 agent 内部。所有 agents 的 verified rollouts 被汇入共享训练信号；self-generated samples 形成 vanilla RL optimization 分支，cross-agent samples 则经过四个修正模块：agent-capability-aware advantage estimation 解决 reward baseline 不可比，model capability discrepancy coefficient 调节外来样本梯度强度，exponential importance sampling 处理 policy/tokenizer mismatch，stepwise clipping 抑制训练 batch 后期被 cross-agent ratio 主导。

直觉上，HACPO 把多 agent 训练看成“同题不同解法”的学习小组：强 agent 的高质量解法值得弱 agent 更积极学习，但弱 agent 的成功样本也可能包含强 agent 没探索到的 reasoning path；同时，任何外来解法都不是当前 policy 原生采样，所以必须被 importance ratio 与 clipping 限制，避免把跨模型分布偏移误当成 on-policy signal。

3.3 Agent-Capability-Aware Advantage Estimation

在普通 group-relative advantage 中，一个 response 的 advantage 由它相对本 agent 同组样本的 reward 决定。若直接把所有 agents 的 reward 混在一起，强 agent 会把 baseline 拉高，弱 agent 的正确 response 可能被低估；弱 agent 的低 reward 样本又会把强 agent 的 baseline 拉低。HACPO 因此为每个 target agent $k$ 构造 capability-adjusted baseline： $ A_{t,i}^{(k)}\left(y_{t,i}^{(k)}\right)

\frac{R!\left(y_{t,i}^{(k)}\right)-\mu_t^{(k)}}{\mathrm{std}{\mathcal{R}t(x)}}, \quad \mu_t^{(k)}=rac{1}{nG}\sum{j=1}^{n}\sum_{i=1}^{G}\omega_t^{(k,j)}R!\left(y_{t,i}^{(j)}\right). $capabilityratio定义为：$ \omega_t^{(k,j)}=\frac{P_t^{(k)}}{P_t^{(j)}}, \quad P_t^{(k)}=rac{1}{|\mathcal B_t|G}\sum_{x\in\mathcal B_t}\sum_{i=1}^{G}R\left(y_{t,i}^{(k)}\right). P_t^{(k)}$是agent$k$在当前batch上的meanreward。若agent$j$比agent$k$强，则$\omega_t^{(k,j)}<1$，在给弱agent估baseline时会把强agentreward按比例校准；反过来，给强agent估baseline时来自弱agent的reward会被放大到强agent的能力尺度。论文的理论分析聚焦centeredreward$\bar A=R(y)-\mu_t^{(k)}$，证明oraclecapability-awarebaseline的期望等于agent$k$ 的真实 expected reward；batch-level empirical ratio 则通过 Hoeffding inequality 与 union bound 得到 high-probability error bound。

3.4 Model Capability Discrepancy Coefficient

同一个 $\omega$ 在 HACPO 中有第二个角色：不仅用于 baseline calibration，也用于 gradient modulation。若 agent $k$ 更新时使用 agent $j$ 生成的 response，effective advantage 为： ${\tilde{A}}_{t,i}^{(k)}\left(y_{t,i}^{(j)}\right)=\{\begin{array}{ll}{A}_{t,i}^{(k)}\left(y_{t,i}^{(j)}\right),& j=k,\\ {\omega }_t^{(j,k)}\cdot A_{t,i}^{(k)}\left(y_{t,i}^{(j)}\right),& j\ne k.\end{array}$ 注意 cross-agent 分支使用的是 ${\omega }_t^{(j,k)}=P_t^{(j)}/P_t^{(k)}$：当 provider agent $j$ 比 target agent $k$ 更强时，${\omega }_t^{(j,k)}>1$，外来样本的 advantage 被放大；当 provider 更弱时，外来样本被保守缩小。这样 weaker agent 可以从 stronger agent 学得更快，而 stronger agent 仍可吸收 weaker agent 的少量探索信号，但不会被低质量样本主导。

3.5 Exponential Importance Sampling

跨 agent rollout 最大的问题是 policy distribution mismatch。HACPO 沿用 GSPO 的 sequence-level ratio，但扩展到 agent $j$ 的 response 被 agent $k$ 学习的情形： $s_{t,i}^{(k,j)}=\frac{{\pi }_{\theta }^{(k)}{\left(y_{t,i}^{(j)}\right)}^{1/L_k}}{{\pi }_{{\theta }_{\mathrm{old}}}^{(j)}{\left(y_{t,i}^{(j)}\right)}^{1/L_j}}.$ $L_k$ 和 $L_j$ 分别是同一 response 在 target tokenizer 与 source tokenizer 下的长度。对于 Qwen/Llama 这类 tokenizer 不兼容组合，论文做法是先 detokenize 成 text，再用 target agent 的 tokenizer 重新 tokenize；在 MATH training set 上，相同 reasoning 平均约 700 tokens，不同 tokenizer 产生的 token 数差异约 4%，sequence-level normalization 使这个差异相对可控。

直接使用 $s_{t,i}^{(k,j)}$ 太激进，因为 heterogeneous agents 之间的分布差距可能远大于同一 agent 的 on-policy update drift。HACPO 进一步加入 non-gradient exponential reweighting： ${\tilde{s}}_{t,i}^{(k,j)}=s_{t,i}^{(k,j)}\cdot {\left(\mathrm{sg}\left[s_{t,i}^{(k,j)}\right]\right)}^{\alpha },k\ne j,s_{t,i}^{(k,j)}<\mathrm{1.0.}$ $\mathrm{sg}[\cdot ]$ 是 stop-gradient，$\alpha \ge 0$ 控制保守程度。若外来 response 在 target policy 下概率很低，则 $s<1$，乘上 $s^{\alpha }$ 会进一步减弱它；若 $\alpha$ 太大，训练更稳定但有效 cross-agent signal 变少。

3.6 Stepwise Clipping

self-agent ratio $s^{(k,k)}$ 通常围绕 1.0 小幅波动，因此 GSPO 可使用很窄 clipping range，例如 $[0.9997,1.0004]$。cross-agent ratio $s^{(k,j)}$ 则长期低于 1.0 且在训练 step 内波动不规则。HACPO 因此采用 asymmetric clipping：上界固定为 1.0，避免外来 rollout 被 upweight 到支配更新；下界随 batch 内参数更新次数逐步收紧： $\mathrm{clip}\left(s_{t,i}^{(k,j)},1-\delta +m\cdot {\delta }_{\mathrm{step}},1.0\right),$ 其中 $m$ 是当前 step 内已经执行的参数更新数，${\delta }_{\mathrm{step}}$ 是每次更新后的 tightening factor。论文中常用 $1-\delta =0.8$；不同 model combination 的 $\alpha$、$1-\delta$、${\delta }_{\mathrm{step}}$ 见实验设置。

3.7 HACPO objective and paper-derived pseudocode

以两个 agents 为例，Agent 1 的 self objective 与 cross-agent objective 分别为： \mathcal J_{\mathrm{homo}}^{(1)}=rac{1}{G}\sum_{i=1}^{G} \min\left( s_{t,i}^{(1,1)} A_{t,i}^{(1)}, \mathrm{clip}(s_{t,i}^{(1,1)},1-\epsilon_l,1+\epsilon_h) A_{t,i}^{(1)} \right), \mathcal J_{\mathrm{hete}}^{(1)}=rac{1}{G}\sum_{i=1}^{G} \left[ \mathrm{clip}(s_{t,i}^{(1,2)},1.0-\delta+m\delta_{\mathrm{step}},1.0) \cdot\mathrm{sg}(s_{t,i}^{(1,2)})^{\alpha} \cdot\omega_t^{(2,1)} \cdot A_{t,i}^{(1)}(y_{t,i}^{(2)}) \right]. 下面伪代码是按论文公式整理的 PyTorch-style 版本；由于作者/官方实现未公开，它不是 released code 的逐行映射。

import torch
 
def capability_aware_advantages(rewards: torch.Tensor, eps: float = 1e-8):
    """rewards: [num_agents, batch, group] verifier scores in [0, 1]."""
    n, batch_size, group = rewards.shape
    perf = rewards.mean(dim=(1, 2)).clamp_min(eps)              # P_t^(k)
    omega = perf[:, None] / perf[None, :]                       # omega[k, j]
    joint_std = rewards.reshape(-1).std(unbiased=False).clamp_min(eps)
 
    # mu[k] = mean_j,i omega[k,j] * R_j,i
    mean_reward_per_agent = rewards.mean(dim=(1, 2))
    mu = (omega * mean_reward_per_agent[None, :]).mean(dim=1)
    advantages = (rewards - mu[:, None, None]) / joint_std
    return advantages, omega

def cross_agent_weight(target_logp, source_old_logp, target_len, source_len, alpha):
    """Sequence-level importance ratio for a source response under target agent."""
    s = torch.exp(target_logp / target_len - source_old_logp / source_len)
    exp_reweight = s.detach().pow(alpha)
    return s * exp_reweight
 
 
def hacpo_cross_loss(s, advantage, omega_provider_target, update_idx, delta=0.2,
                     delta_step=0.025, alpha=1.0):
    lower = 1.0 - delta + update_idx * delta_step
    clipped = torch.clamp(s, min=lower, max=1.0)
    stable_s = clipped * clipped.detach().pow(alpha)
    # maximize objective -> minimize negative objective
    return -(stable_s * omega_provider_target * advantage).mean()

def hacpo_training_step(agents, prompts, verifier, hyperparams):
    all_responses, all_rewards = [], []
    for agent in agents:
        responses = agent.generate(prompts, n=hyperparams.rollouts_per_prompt)
        rewards = verifier(prompts, responses)
        all_responses.append(responses)
        all_rewards.append(rewards)
 
    rewards = torch.stack(all_rewards)  # [num_agents, batch, group]
    advantages, omega = capability_aware_advantages(rewards)
 
    for k, target_agent in enumerate(agents):
        loss = target_agent.self_gspo_loss(all_responses[k], advantages[k])
        for j, source_agent in enumerate(agents):
            if j == k:
                continue
            text = source_agent.detokenize(all_responses[j])
            target_tokens = target_agent.tokenize(text)
            target_logp = target_agent.logprob(target_tokens)
            source_old_logp = source_agent.old_logprob(all_responses[j])
            s = cross_agent_weight(
                target_logp, source_old_logp,
                target_len=target_tokens.lengths,
                source_len=all_responses[j].lengths,
                alpha=hyperparams.alpha,
            )
            loss = loss + hacpo_cross_loss(
                s=s,
                advantage=advantages[k],
                omega_provider_target=omega[j, k],
                update_idx=hyperparams.update_idx,
                delta=hyperparams.delta,
                delta_step=hyperparams.delta_step,
                alpha=hyperparams.alpha,
            )
        target_agent.optimizer_step(loss)

Code reference: none — 代码搜索未找到开源实现；下面表格记录无法进行官方 code-to-paper mapping 的原因。

Paper Concept	Source File	Key Class/Function
HACRL / HACPO official implementation	N/A	作者/官方 public implementation 未找到
Project website	zzx-peter/hacrl GitHub Pages repo	仅项目页，不是训练实现
Community implementation	Fred990807/HACRL	HuggingFace comment 标注为 unofficial；不作为 github_ref 或训练配置来源

4. Experimental Setup (实验设置)

4.1 Datasets and evaluation tasks

• Training data：MATH dataset 中 7.5k high-quality math questions。
• Evaluation benchmarks：MATH-500、MATH、GSM8K、AIME2025、AMC23、Minerva、Olympiad。论文没有逐项列出这些 evaluation subset 在本实验中的 exact sample count；因此这里只记录论文显式给出的训练规模，并避免补写未说明的评测样本数。
• Task type：数学 reasoning / RLVR，reward 来自可验证答案或 verifier，而不是 learned preference model。

4.2 Models and heterogeneity settings

• Heterogeneous State：Qwen3-4B 与 Qwen3-4B-Instruct。
• Heterogeneous Size：Qwen3-1.7B-Base 与 Qwen3-4B-Base；appendix 还报告 Qwen3-4B-Base 与 Qwen3-8B-Base。
• Heterogeneous Model：Qwen3-4B-Base 与 Llama3.2-3B-Instruct；appendix 还报告 Llama3.2-1B/3B-Instruct、Qwen3-1.7B-Base/Llama3.2-1B-Instruct。

4.3 Baselines and metrics

• Raw / Base model：未经过该轮 RLVR 训练的起点。
• GRPO：standard single-agent group relative policy optimization baseline。
• GSPO：standard single-agent sequence-level policy optimization baseline。
• GSPO$\times 2$：resource-equivalent single-agent baseline，double rollouts and updates，用来排除“只是多采样”的解释。
• Naive：简单 rollout sharing baseline，不加入 HACPO 的 capability-aware / distribution-shift 修正。
• Metric：每个 benchmark 上报告 accuracy / pass rate，AVG 是七个 benchmark 的平均。

4.4 Training configuration

论文实验基于 verl。核心配置如下：maximum prompt length 1024，maximum response length 4096；主结果与 advantage / capability coefficient ablation 在评测 AIME2025 等复杂 benchmark 时使用 maximum response length 8196；learning rate $1\times 10^{-6}$；HACPO 和 single GSPO 的 ${ϵ}_{\mathrm{low}}=0.0003$、${ϵ}_{\mathrm{high}}=0.0004$；single GRPO 的 ${ϵ}_{\mathrm{low}}=0.2$、${ϵ}_{\mathrm{high}}=0.28$；batch size 128，mini-batch size 64，$n=8$ rollouts per prompt。GSPO$\times 2$ 使用 mini-batch size 32 与 $n=16$ rollouts per prompt，以保证每个 step 有 double updates，同时每次 update 的 rollout 数保持一致。训练通常为 one epoch；论文正文只说使用 eight GPUs，未在最终正文中给出 GPU 型号。

Model Combination	$\alpha$	$1-\delta$	${\delta }_{\mathrm{step}}$
Qwen3-4B and Qwen3-4B-Instruct	3.0	0.8	0.01
Qwen3-1.7B-Base and Qwen3-4B-Base	1.0	0.8	0.025
Qwen3-4B-Base and Qwen3-8B-Base	3.0	0.8	0.025
Llama3.2-1B-Instruct and Llama3.2-3B-Instruct	1.0	0.9	0.01
Qwen3-1.7B-Base and Llama3.2-1B-Instruct	1.0	0.8	0.025
Qwen3-4B-Base and Llama3.2-3B-Instruct	1.0	0.8	0.025

5. Experimental Results (实验结果)

5.1 Main results

主表显示 HACPO 在三类异构设置下均提升参与 agents，且多数情况下超过 GSPO$\times 2$。下面只列最关键的 GSPO$\times 2$ vs HACPO 行；列顺序为 MATH-500 / MATH / GSM8K / AIME2025 / AMC23 / Minerva / Olympiad / AVG。

Setting	Model	GSPO$\times 2$ AVG	HACPO AVG	HACPO row
Heterogeneous State	Qwen3-4B	0.691	0.755	0.910 / 0.905 / 0.933 / 0.622 / 0.850 / 0.423 / 0.643
Heterogeneous State	Qwen3-4B-Instruct	0.799	0.818	0.948 / 0.943 / 0.946 / 0.757 / 0.950 / 0.452 / 0.732
Heterogeneous Size	Qwen3-1.7B-Base	0.465	0.493	0.690 / 0.674 / 0.822 / 0.225 / 0.450 / 0.279 / 0.314
Heterogeneous Size	Qwen3-4B-Base	0.575	0.601	0.808 / 0.801 / 0.903 / 0.267 / 0.575 / 0.386 / 0.467
Heterogeneous Model	Qwen3-4B-Base	0.575	0.597	0.786 / 0.783 / 0.921 / 0.268 / 0.600 / 0.379 / 0.442
Heterogeneous Model	Llama3.2-3B-Instruct	0.334	0.390	0.566 / 0.548 / 0.826 / 0.054 / 0.350 / 0.176 / 0.208

Figure 2 解读：六个训练曲线 panel 对应三组 model pairs 中的两个 agents。整体趋势是 HACPO 收敛更快或最终 accuracy 更高，尤其在 weaker / base model 上更明显；这支持论文的解释：cross-agent rollouts 不只是增加 update 次数，而是提供了额外、可迁移的 reasoning trajectories。GSPO$\times 2$ 作为 double rollout/update baseline 仍经常低于 HACPO，说明 HACPO 的校准与 clipping 模块在样本利用率上有实际作用。

Appendix 的 additional results 进一步覆盖 Qwen3-4B/8B-Base、Llama3.2-1B/3B-Instruct、Qwen3-1.7B-Base/Llama3.2-1B-Instruct。典型结果包括：Qwen3-8B-Base 从 GSPO$\times 2$ AVG 0.595 提升到 HACPO 0.630；Llama3.2-3B 从 0.334 提升到 0.370；Qwen3-1.7B-Base/Llama3.2-1B-Instruct 组合中 Qwen3 从 0.475 提升到 0.496，Llama3.2 从 0.227 小幅到 0.228。

5.2 Ablation studies

Advantage estimator：在 Qwen3-1.7B/4B-Base 组合上，移除 capability-aware advantage estimator 会降低 AVG。1.7B 从 HACPO 0.493 降到 0.465，4B 从 0.601 降到 0.586。直觉是普通 group-relative baseline 在 heterogeneous setting 中有系统偏差，强弱模型 reward scale 混合后会让 advantage calibration 失准。

Model capability discrepancy coefficient：移除 gradient modulation 中的 $\omega$ 后，1.7B AVG 从 0.493 降到 0.462；4B 的 AVG 从 0.601 几乎持平到 0.600，但在 AIME2025、AMC23 等列仍有差异。这说明 $\omega$ 对 weaker agent 学习 stronger rollouts 更关键，对 stronger agent 则主要起到防噪作用。

Exponential importance sampling：论文测试 $\alpha \in \{0,1,2,3\}$。在 Qwen3-1.7B/4B-Base 上，1.7B 的 MATH500 最好值是 $\alpha =3.0$ 时 0.668，但 4B 最好值是 $\alpha =1.0$ 时 0.792；在 Qwen3-4B/8B-Base 上，4B 在 $\alpha =1.0$ 与 3.0 都为 0.776，8B 在 $\alpha =3.0$ 为 0.778。结论不是“越大越好”，而是 conservative reweighting 与 effective learning signal 之间存在 trade-off。

Figure 4 解读：两张 MATH500 ablation 曲线比较 stepwise clipping 的影响。论文观点是 cross-agent ratio 在 batch 内不如 self ratio 平滑，若没有随 update index 收紧下界，训练后段更容易被 noisy cross-agent rollouts 干扰；采用 stepwise schedule 后，外来样本仍可提供信号，但不会在 late updates 中过度支配。

5.3 Robustness, runtime, and memory

五个 random seeds（0、1、42、1337、3407）的 MATH500 实验显示收益稳定：Qwen3-1.7B-Base 上 HACPO 为 0.656 / 0.656 / 0.664 / 0.656 / 0.644，对应 GSPO 为 0.622 / 0.614 / 0.622 / 0.622 / 0.618；Qwen3-4B-Base 上 HACPO 为 0.762 / 0.780 / 0.792 / 0.772 / 0.774，对应 GSPO 为 0.740 / 0.748 / 0.748 / 0.750 / 0.750。论文总结为 1.7B 的 $65.52\%\pm 0.72\%$ vs GSPO $61.96\%\pm 0.36\%$、GSPO$\times 2$ $62.44\%\pm 0.30\%$；4B 的 $77.60\%\pm 1.10\%$ vs GSPO $74.72\%\pm 0.41\%$、GSPO$\times 2$ $74.96\%\pm 0.48\%$。

Runtime / memory 方面，Qwen3-1.7B-Base + Qwen3-4B-Base 组合中，HACPO overall runtime 5h31m；GSPO 两个模型串行合计 4h09m，GSPO updates$\times 2$ 合计 5h05m，GSPO$\times 2$ 合计 6h44m。peak GPU memory utilization 为 HACPO overall 86.0%，而 GSPO 是 76.8% / 82.7%，GSPO$\times 2$ 是 82.2% / 84.2%。这说明 HACPO 比普通 GSPO 更耗内存，但比真正 double rollout 的 GSPO$\times 2$ 更省总时间。

5.4 Limitations and conclusion

作者明确的 limitation 是：HACPO 理论上支持 $n\ge 3$ agents，但当前实验受计算资源与 verl framework infrastructure modification 成本限制，只验证了 two-agent settings。虽然覆盖了六种 model combinations 与三类 heterogeneity，但更大 agent ecosystem 的 empirical scaling 仍是 future work。

总体结论：HACRL/HACPO 提供了一种训练期 collaborative、推理期 independent 的 multi-agent RLVR 范式。实验中 HACPO 在 heterogeneous state、size、model 三类设置中均能让双方 agents 获益，并且经常超过 GSPO$\times 2$，说明通过 capability-aware advantage、capability-scaled gradient、EIS 与 stepwise clipping 组合，cross-agent rollouts 可以成为有效而非有害的训练信号。