RoboMemArena: A Comprehensive and Challenging Robotic Memory Benchmark

Paper: arXiv:2605.10921 Code: OpenHelix-Team/RoboMemArena Code reference: main @ 25ee194 (2026-05-20)

1. Motivation（研究动机）

这篇论文的核心问题不是“如何让机器人执行更长的动作序列”这么宽泛，而是更具体地追问：当机器人当前观测已经看不到关键历史信息时，现有 VLA / memory-VLA 是否真的能记住任务进度、隐藏物体位置、动作计数和顺序约束。作者认为现有机器人 benchmark 对这个问题的覆盖不足，原因有三类。第一，很多长任务虽然步数多，但下一步动作仍可从当前帧局部判断，无法隔离 memory 本身的作用；第二，已有 memory benchmark 往往缺少能直接训练记忆系统的多模态标注，例如子任务文本、历史关键帧、stage-level completion signal；第三，大多数 benchmark 只停留在仿真，缺少与真实机器人任务对齐的物理评测。

论文把这个缺口定义为 embodied memory evaluation：机器人要在部分可观测环境中完成 long-horizon manipulation，必须依赖过去的观察和动作，而不是只靠当前 RGB 或当前语言指令。例如抽屉任务中，机器人打开第一个抽屉观察到里面是否有物体，随后抽屉关闭，当前画面又回到类似初始状态；如果策略没有记住“哪个抽屉已检查、里面有什么、当前全局约束是什么”，就可能重复打开同一个抽屉或提前把物体放进局部看似合适的抽屉。再如计数任务中，连续两次倒水或倒酱油后的视觉状态可能高度相似，策略需要记住已经执行了几次，而不是看到可倒就继续倒。

RoboMemArena 的动机正是把这类 memory-dependent subtasks 做成可扩展、可训练、可量化的 benchmark。论文构建了 26 个仿真任务，覆盖 transferring、occlusion、counting、sequence 四类记忆需求；每个任务平均轨迹长度为 1,076 steps；全部 151 个 distinct subtasks 中有 104 个需要历史信息，得到 68.9% 的 history-dependent subtask ratio。这个比例的意义在于，benchmark 中大部分高层决策不是当前观测可解，而必须从历史事件恢复状态。

除 benchmark 之外，作者还提出 PrediMem 作为 memory VLA baseline。它不是单纯把更多历史帧塞进上下文，而是使用 dual-system 结构：S2 高层 VLM planner 维护 recent buffer 与 keyframe bank，并输出当前 subtask；S1 低层 VLA actor 根据最新 subtask 产生 action chunk。作者进一步加入 predictive coding head，让 S2 在训练时预测下一帧视觉 latent，从而让隐藏表示对状态突变、物体消失、抓取释放、倒水次数等事件更敏感。这个设计直接服务于记忆写入问题：什么时候该把一帧写入长期 keyframe bank，比“能否看懂当前帧”更关键。

2. Idea（核心思想）

RoboMemArena 的核心 insight 是：机器人记忆能力应当在“历史信息离开当前视野后仍决定当前动作”的任务中被评测，并且 benchmark 需要同时给出子任务、关键帧和 stage-level verification，才能区分纯执行失败、记忆失败和规划失败。PrediMem 的核心 insight 则是：高层 VLM 不应仅被训练成 subtask generator，还应通过预测未来视觉 latent 学到哪些帧代表真实状态转移，从而改善 keyframe decision 和长期记忆管理。

这与 MemER、MemoryVLA 等已有方法的区别在于，PrediMem 没有只依赖检索模块或 token-level history compression。MemER 也使用 dual-system 和关键帧，但论文认为它对任务动态和状态转移的感知不足，因此高层 VLM 往往选不到足够 informative 的 keyframes。PrediMem 把 predictive coding 作为训练期辅助目标，目标是重塑共享 hidden space，使标准 LM head 就能更好地产生 subtask 与 keyframe decisions；推理时移除 predictive head，不增加额外推理成本。

Benchmark 侧的创新也很具体：RoboMemArena 不是只给最终成功率，而是通过 TSR 与 CSR 同时评估完整任务成功和中间进度。TSR 要求所有 stage predicates 都满足，CSR 则计算完成了多少 verification stages。对 long-horizon memory task 来说，这比单一 binary success 更能暴露模型在哪里忘记了历史约束。

3. Method（方法）

3.1 RoboMemArena benchmark 设计

RoboMemArena 包含 26 个仿真任务，作者按 memory demand 划分为四类。Multi-Object Transferring 要求记住多个物体从哪个容器转移到哪个容器，以及哪些转移已经完成；Multi-Object Occlusion 要求记住抽屉、柜子或微波炉关闭后不可见的物体位置和容器状态；Multi-Object Counting 要求记住重复动作次数，例如精确倒两次；Multi-Object Sequence 要求后续操作引用前面子任务结果，例如“把新物体放到之前用过的同一容器”。论文还提供 5 个真实机器人任务：Pour Bottle $\times 2$、Brush Plates with Swap、Transfer Objects、Shell Game、Imitate Human to Make Breakfast，覆盖 counting、sequence、transferring、occlusion tracking 和人类示范条件记忆。

Figure 1 解读：这张图把四类仿真任务放在同一格式下展示：每一行先给出 task instruction，再给出 subtask decomposition，最后展示 rollout。它说明 benchmark 的难点不在单个 grasp/place primitive，而在跨多个 subtask 维护状态。例如 occlusion row 中，抽屉关闭后当前画面不足以判断目标抽屉；counting row 中，重复倒酱油次数必须由历史动作计数决定。

3.2 自动数据生成与 keyframe annotation

RoboMemArena 的数据生成有三阶段。第一阶段使用 VLM 根据高层指令和当前 RGB observation 生成有序 executable subtasks，随后人工修正不一致的分解。作者在 prompt 中显式暴露 occlusion、counting、order-dependent execution 等 memory demands，使子任务分解天然包含记忆需求。第二阶段用 AnyGrasp 做 6-DoF grasp pose estimation，再把估计位姿交给 predefined primitives 生成 action trajectories；post-condition checker 会在 subtask 失败时用更新后的 grasp pose 重试，以维持自动生成成功率。第三阶段是 multi-conditioned keyframe extraction：作者不用固定频率采样，而是基于物理交互和运动学转折选择关键帧。

令连续轨迹为 $\tau =\{(s_t,a_t){\}}_{t=1}^T$，keyframe set 是 physical anchors 与 kinematic inflections 的并集： $\mathcal{K}={\mathcal{K}}_{\mathrm{phys}}\cup {\mathcal{K}}_{\mathrm{kin}}.$ physical anchors 由 gripper state transition 定义。令 $g_t\in \{0,1\}$ 表示 gripper 是否闭合，则： ${\mathcal{K}}_{\mathrm{phys}}=\{t\in [1,T]\mid g_t\ne g_{t-1}\}.$ kinematic inflections 由末端速度极小值或方向突变定义。令 ${\mathbf{v}}_t\in {\mathbb{R}}^3$ 为 end-effector linear velocity，当速度模长小于阈值 $ϵ$，或相邻速度向量 cosine similarity 低于 $\cos (\theta )$ 时，认为该时刻是运动相位转折： ${\mathcal{K}}_{\mathrm{kin}}=\left\{t\in [1,T]|\Vert {\mathbf{v}}_t\Vert <ϵ\vee \frac{{\mathbf{v}}_t\cdot {\mathbf{v}}_{t-1}}{\Vert {\mathbf{v}}_t\Vert \Vert {\mathbf{v}}_{t-1}\Vert }<\cos (\theta )\right\}.$ 这套规则的直觉是：机器人任务进度通常在抓取、释放、停顿、转向等稀疏事件处改变，而不是每一帧都同等重要。固定帧率采样会存储大量静态或重复帧，错过真正决定后续记忆的 transition；event-focused keyframes 则更适合作为 hierarchical supervision 和 memory bank 内容。

Figure 2 解读：Figure 2a 比较平均轨迹长度，RoboMemArena 达到 1,076 steps/task，高于现有 robotic memory benchmarks；Figure 2b 显示任务组成，包括 4 个 transferring、11 个 occlusion、7 个 counting、4 个 sequence；Figure 2c 显示 history-dependent subtask ratio，RoboMemArena 为 68.9%，即 151 个 subtasks 中 104 个需要历史信息。

3.3 评测协议：TSR 与 CSR

论文认为 long-horizon memory task 不能只看最终是否成功，因为最终失败可能发生在很晚阶段，而模型仍可能完成了前面大部分 memory subgoals。因此作者定义两个指标。对第 $i$ 个任务，设有 $K_i$ 个 stage-level verification predicates $\psi (s_i^{(k)})$，每个 predicate 检查 object location、containment、visibility 或 stage completion 等状态条件。Task Success Rate 要求所有 predicates 都满足： $\mathrm{TSR}=\frac{1}{N}{\sum }_{i=1}^N{\prod }_{k=1}^{K_i}1\left[\psi \left(s_i^{(k)}\right)\right].$ Cumulative Success Rate 衡量平均完成了多少 stage： $\mathrm{CSR}=\frac{1}{N}{\sum }_{i=1}^N\frac{1}{K_i}{\sum }_{k=1}^{K_i}1\left[\psi \left(s_i^{(k)}\right)\right].$ CSR 对调试 memory failure 很有用：如果 TSR 很低但 CSR 较高，说明系统能执行部分流程但在某个历史依赖点崩溃；如果两者都低，则可能是低层动作或高层规划都不稳定。Appendix Figure S3 说明每个任务包含 3-9 个 verification steps，且多数超过 5 个，因此 CSR 有足够分辨率。

3.4 PrediMem 总体框架

PrediMem 是 dual-system memory VLA。S2 是 high-level VLM planner，输入任务指令、当前 observation、recent sliding window 与 keyframe bank，输出当前 subtask 和 keyframe decision；S1 是 low-level execution policy，输入当前 observation 和最新 subtask，输出 action chunk。记忆库写作： ${\mathcal{M}}_t={\mathcal{M}}_t^{\mathrm{key}}\cup {\mathcal{M}}_t^{\mathrm{rec}},$ 其中 ${\mathcal{M}}_t^{\mathrm{rec}}$ 是固定窗口最近帧，负责短时动态；${\mathcal{M}}_t^{\mathrm{key}}$ 是长期关键帧，负责保存离开视野后仍影响决策的事件。这个拆分避免了两种极端：只看 recent buffer 会遗忘早期抽屉状态；只存全部历史会造成上下文冗余和 VLM latency。

Figure 3 解读：图中 S1 与 S2 异步耦合。S1 在高频执行当前 subtask-conditioned action chunk；S2 低频读取 recent buffer 与 keyframe buffer，更新 subtask 并决定是否写入 keyframe。右侧 predictive coding head 只在训练中存在，用当前视觉 hidden state 预测下一帧视觉 latent，推理时删除，因此不会增加 deployed dual-system 的计算路径。

3.5 Predictive Coding Head

PrediMem 的关键训练机制是 predictive coding。设当前帧视觉相关 hidden state 为 $h_t$，predictive head $f_{\mathrm{Pre}}$ 预测下一帧视觉表示： ${\hat{Z}}_{t+1}=f_{\mathrm{Pre}}(h_t).$ 监督信号 $Z_{t+1}$ 来自 VLM 的 frozen ViT visual encoder，并通过 stop-gradient 阻止 teacher branch 被辅助目标改变。论文使用 latent MSE 与 cosine distance： ${\mathcal{L}}_{\mathrm{Pre}}=\mathrm{MSE}\left({\hat{Z}}_{t+1},\mathrm{sg}(Z_{t+1})\right)+\left(1-\cos \left({\hat{Z}}_{t+1},\mathrm{sg}(Z_{t+1})\right)\right).$ S2 的总训练目标为： ${\mathcal{L}}_{S2}={\mathcal{L}}_{\mathrm{text}}+0.1{\mathcal{L}}_{\mathrm{Pre}}.$ 这里 ${\mathcal{L}}_{\mathrm{text}}$ 是 subtask generation 与 keyframe decision 的 next-token prediction loss。直觉上，如果模型能从当前 hidden state 预测下一帧视觉 latent，它就必须编码“当前事件会怎样改变世界”。这些事件正是 memory bank 最需要保留的内容：物体被放进抽屉、抽屉关闭、目标被遮挡、重复动作完成一次等。因此 predictive coding 不只是 regularization，而是把隐藏空间推向 event-transition-sensitive 的表示。

3.6 异步推理协议

Appendix 给出了 PrediMem inference protocol。S2 异步地从 recent-frame buffer 和 ${\mathcal{M}}_t$ 产生 subtask $c_t$ 与 keyframe decision $k_t$；S1 在更高频率下用最新 subtask 产生 action chunk： $a_t={\pi }_{S1}(o_t,c_t).$ 论文报告当前异步实现中 S2 稳态刷新率为 1.06 Hz，VLM latency p50 为 0.939 s、p95 为 1.136 s、包含 cold start 的 mean 为 1.752 s；S1 低层 VLA 频率为 3.40 Hz，平均每步 0.294 s，p50 为 0.289 s，p95 为 0.365 s。因此一个 S2 update 约覆盖 2.92 个 S1 chunks。这个调度让高层记忆推理不阻塞低层执行，最新 subtask 会覆盖旧 subtask。

Figure S1 解读：补充图把异步 loop 展开：S1 持续用当前 observation 和最新 subtask 执行动作；当 S2 idle 且 recent window ready 时，系统触发一次高层 VLM 推理；S2 返回新 subtask 和 keyframe decision 后，系统更新当前 subtask，并在需要时把对应 observation 写入 ${\mathcal{M}}_t^{\mathrm{key}}$。

3.7 基于 released code 的伪代码

Code reference: main @ 25ee194 (2026-05-20) — pseudocode and mapping based on this commit

Keyframe candidate clustering

Released code 中 evaluation_benchmark/openpi_minimal_runtime/keyframe_selection.py 和 evaluation_benchmark/reference_evaluation/task1_nomap_reference/eval_task1_nomap_reference.py 使用 VLM 输出的 recent-window keyframe positions 形成历史候选，再按时间邻近聚类并选 cluster median。它不是直接实现论文公式中的 ${\mathcal{K}}_{\mathrm{phys}}\cup {\mathcal{K}}_{\mathrm{kin}}$ 数据生成规则，而是推理时的 memory selection helper。

def build_visual_memory(J_hist, t, N, d):
    G = sorted(idx for J in J_hist for idx in J)  # 汇总历史每次 S2 输出的候选关键帧绝对索引，并排序形成全局候选序列
    if not G:
        return []  # 如果 S2 从未标出候选关键帧，则长期视觉记忆为空
    clusters = []  # 准备按时间距离把相邻候选帧合并，减少同一事件附近的重复帧
    cur = [G[0]]  # 用第一个候选帧初始化当前事件簇
    for i in range(1, len(G)):
        if G[i] - G[i - 1] <= d:
            cur.append(G[i])  # 时间间隔不超过 merge distance 时，认为仍属于同一物理事件
        else:
            clusters.append(cur)  # 时间间隔过大时，关闭当前事件簇并开始新的事件簇
            cur = [G[i]]  # 用当前候选帧开启下一个事件簇
    clusters.append(cur)  # 循环结束后保存最后一个事件簇
    K_selected = []  # 保存每个事件簇代表性的长期 keyframe index
    for C in clusters:
        K_selected.append(C[len(C) // 2])  # 选择簇中位数帧，避免簇边缘噪声影响记忆写入
    cutoff = t - N + 1  # recent window 的起始帧索引，用于避免把仍在短期窗口内的帧重复放入长期记忆
    K_selected = [k for k in K_selected if k <= cutoff]  # 只保留已经离开 recent buffer 的历史事件帧
    return K_selected  # 返回可从 frame store 取出的长期 keyframe 索引列表

Predictive coding training loss

predictive_coding_head/predictive_coding_head.py 附加 2-layer MLP projection head，并从 image tokens 的 hidden states 预测下一张图像的 frozen visual features。

def compute_predictive_losses(model, batch, outputs):
    base = resolve_multimodal_base_model(model)  # 穿透 PEFT/base_model/model 包装，找到真正含视觉塔和配置的多模态模型
    head = base.predictive_coding_head  # 读取训练时挂到 base model 上的两层 MLP predictive head
    image_token_id = base.config.image_token_id  # 找到输入序列中代表图像 patch/token 的特殊 token id
    with torch.no_grad():
        targets = base.get_image_features(  # 用 frozen/teacher visual encoder 重新计算每张输入图像的视觉特征
            pixel_values=batch["pixel_values"],
            image_grid_thw=batch["image_grid_thw"],
            return_dict=True,
        ).pooler_output
    last_hidden = outputs.hidden_states[-1]  # 取语言模型最后一层 hidden state，作为 S2 已融合上下文后的表示
    image_mask = batch["input_ids"] == image_token_id  # 选出序列中所有图像 token 位置，定位每帧视觉表示对应的 hidden states
    pred_tokens = last_hidden[image_mask]  # 抽取模型内部对每张图像 token 的预测上下文表示
    pred_per_image = split_by_image_token_counts(pred_tokens, targets)  # 按每张图像的 token 数切分回逐帧特征序列
    mse_terms, cosine_terms = [], []  # 分别累积 latent MSE 和 cosine-distance 两类预测误差
    for cur_pred, next_target in adjacent_pairs(pred_per_image, targets):
        predicted_next = head(cur_pred.to(next(head.parameters()).dtype))  # 用当前帧 hidden tokens 预测下一帧 visual latent
        target_next = next_target.detach().to(predicted_next.device, predicted_next.dtype)  # 对下一帧 teacher latent 停梯度，避免辅助目标改动视觉塔
        predicted_next, target_next = align_token_count(predicted_next, target_next)  # 当视觉 token 数不一致时按较短长度对齐，避免形状错误
        mse_terms.append(F.mse_loss(predicted_next.float(), target_next.float()))  # 惩罚预测 latent 与 teacher latent 的欧氏偏差
        cosine_terms.append(1.0 - F.cosine_similarity(predicted_next.float(), target_next.float(), dim=-1).mean())  # 惩罚方向不一致，鼓励语义/状态变化方向对齐
    mse_loss = torch.stack(mse_terms).mean()  # 对 batch 内所有相邻帧预测误差取平均，得到 MSE 辅助目标
    cosine_loss = torch.stack(cosine_terms).mean()  # 对 batch 内所有相邻帧 cosine distance 取平均，得到方向一致性目标
    return mse_loss, cosine_loss  # 返回两个辅助 loss，供 trainer 与 CE loss 加权相加

S2 memory planner inference

Released reference evaluation 中的 FullVlm26MemoryPlanner.infer_sync 把历史 keyframes 和 recent frames 组装为 VLM messages，解析 VLM 输出的 current primitive 与 keyframe positions，再更新 memory bank。

def infer_sync(planner, step_idx, context_frames_np):
    recent_start = step_idx - len(context_frames_np) + 1  # 根据当前 step 和窗口长度恢复 recent frames 的绝对起始索引
    context_frames = convert_np_frames_to_pil(context_frames_np)  # 把环境返回的 RGB array 转成 VLM processor 可接收的 PIL 图像
    if planner.use_keyframe_memory:
        memory_frames = list(planner.K_main_frames)  # 取出长期 keyframe bank 中保存的历史主视角帧
        memory_indices = list(planner.K_indices_abs)  # 同步取出长期 keyframe 的绝对时间索引，便于日志和 prompt 对齐
    else:
        memory_frames, memory_indices = [], []  # ablation 或无记忆模式下，清空历史视觉上下文，只保留 recent window
    messages = planner._build_messages(memory_frames, [], context_frames, [])  # 按系统 prompt 组织历史 keyframes 与 recent frames 给 S2
    inputs = planner.processor(text=[chat_template(messages)], images=extract_images(messages), return_tensors="pt")  # 将多图 prompt 编码为 Qwen3-VL 输入
    gen = planner.model.generate(**move_to_device(inputs), max_new_tokens=planner.max_new_tokens, do_sample=False)  # 贪心生成当前 primitive 和 keyframe positions JSON
    out_text = planner.processor.batch_decode(trim_generated_tokens(gen, inputs), skip_special_tokens=True)[0]  # 解码只属于模型新生成部分的文本
    vlm_subtask, j_rel = parse_output(out_text, max_pos=len(context_frames), allowed_subtasks=planner.allowed_subtasks)  # 从 JSON 中提取当前子任务与 recent window 内关键帧位置
    j_abs = [recent_start + (p - 1) for p in j_rel]  # 把 1-indexed recent-window 位置转换成全局绝对帧索引
    planner.J_hist.append(j_abs)  # 将本次 S2 提议的候选关键帧加入历史候选集合
    raw_k = build_visual_memory(planner.J_hist, t=planner.step, N=len(context_frames), d=planner.d_merge)  # 聚类历史候选帧并选出事件代表帧
    planner.K_indices_abs = [idx for idx in raw_k if idx < recent_start]  # 只保留已经离开 recent window 的长期 keyframes
    planner.K_main_frames = get_frames_from_indices(planner.K_indices_abs, planner.frame_store_main)  # 从 frame store 取回长期 keyframe 图像，供下一次 prompt 使用
    if vlm_subtask:
        planner._current_subtask = vlm_subtask  # 如果 S2 输出了合法 primitive，就刷新低层 VLA 的语言条件
    return planner._current_subtask  # 返回当前应交给 S1 执行的最新 subtask prompt

Async VLM/VLA loop

evaluation_benchmark/async_vlm26_reference/eval_fullvlm26_async_vlm_vla.py 给出 26-task reference evaluation。它用 single-slot queue 异步触发 S2，S1 每次使用最新 subtask prompt 调 OpenPI policy server。

def run_async_episode(env, planner, client, args):
    recent_vlm_frames = deque(maxlen=args.n_recent)  # 维护固定长度 recent visual buffer，作为 S2 的短期动态输入
    latest_subtask = planner.default_subtask_prompt  # 初始化低层 VLA prompt，避免 S2 首次返回前没有可执行指令
    vlm_queue = Queue(maxsize=args.vlm_queue_size)  # 使用单槽队列限制高层 VLM backlog，保证只处理最新上下文
    start_worker(lambda payload: planner.infer_sync(payload.step_idx, payload.frames))  # 在后台线程异步运行 S2 planner，避免阻塞动作执行
    while not task_finished(env):
        if len(recent_vlm_frames) == args.n_recent:
            try_submit(vlm_queue, clone_recent_frames(recent_vlm_frames))  # recent window 准备好后提交 S2 job，队列满则丢弃旧节奏中的重复请求
        maybe_new_subtask = read_latest_subtask_nonblocking()  # 非阻塞读取后台 S2 的最新 subtask，避免等待 VLM 生成
        if maybe_new_subtask:
            latest_subtask = maybe_new_subtask  # 用新 subtask 覆盖旧 subtask，保持 S1 条件尽可能新鲜
        element = obs_to_pi_element(env.current_obs, resize_size=args.resize_size, prompt=latest_subtask)  # 把当前观测和最新 subtask 编码成 OpenPI policy 输入
        out = client.infer(element)  # 调用低层 VLA policy server，得到一个 action chunk
        for action in out["actions"][:args.replan_steps]:
            obs, _, done, _ = env.step(action.tolist())  # 执行动作 chunk 中的一步，与仿真环境交互推进状态
            recent_vlm_frames.append(extract_vlm_frame(env, obs, args))  # 把新观测加入 recent buffer，供下一轮 S2 判断状态变化
            update_stage_metrics(obs)  # 用 stage predicates 更新 CSR/TSR 相关的完成状态
            if done or goal_success(obs):
                return summarize_episode()  # 任务终止或所有目标满足时返回 stage progress 和 final success

论文公式与 released code 实现差异：论文正文把 S2 输出表述为 subtask 与二值 keyframe decision $k_t$，Appendix algorithm 也写成 $k_{\tau }=1$ 时写入 keyframe；released reference implementation 中，S2 实际输出的是 recent window 内的 keyframe_positions，代码再把这些相对位置转成全局索引并做时间聚类。另一个差异是论文给出数据生成阶段的物理/运动学 keyframe extraction 公式，而 released evaluation helper 实现的是推理时基于 VLM 输出候选的 build_visual_memory，不是同一个过程。训练配置方面，论文报告 S2 使用 Qwen3-VL-8B-Instruct、vision tower frozen、其余模块 full fine-tune 2 epochs、4 $\times$ H100、LR $1\times 10^{-5}$；但 released repo 在 main@25ee194 中只提供 predictive head add-on 与 evaluation reference，未提供完整 S2 training launch script，因此这些训练数值只能锚定到论文正文，不能从具体 launcher override 文件复核。

Code-to-paper mapping

Code reference: main @ 25ee194 (2026-05-20) — pseudocode and mapping based on this commit

Paper Concept	Source File	Key Class/Function
RoboMemArena dataset structure and HDF5 format	README.md, RoboMemArena_dataset_builder.py	RoboMemArenaDataset RLDS conversion and dataset layout notes
26 benchmark task definitions	bddl/, evaluation_benchmark/async_vlm26_reference/fullvlm_v2_26_memory_tasks.json	task BDDL files and task metadata JSON
Predictive Coding Head	predictive_coding_head/predictive_coding_head.py	init_predictive_coding_head, compute_predictive_coding_losses, combine_main_and_predictive_losses
Keyframe memory selection at inference	evaluation_benchmark/openpi_minimal_runtime/keyframe_selection.py	build_visual_memory, get_frames_from_indices
Task-1 synchronous reference planner	evaluation_benchmark/reference_evaluation/task1_nomap_reference/eval_task1_nomap_reference.py	FullVlm26MemoryPlanner.infer_sync and memory update logic
26-task asynchronous VLM/VLA loop	evaluation_benchmark/async_vlm26_reference/eval_fullvlm26_async_vlm_vla.py	vlm_worker, submit_vlm_job, S1/S2 execution loop
OpenPI low-level policy interface	third_party/openpi_minimal/, evaluation_benchmark/async_vlm26_reference/run_fullvlm26_async_vlm_vla_csr_tsr.sh	bundled OpenPI runtime and policy serving integration
Evaluation metrics output	evaluation_benchmark/async_vlm26_reference/README.md	summary.tsv, aggregate.json, macro_csr, macro_tsr descriptions

4. Experimental Setup（实验设置）

Datasets：RoboMemArena 仿真 benchmark 包含 26 个 tasks、4 个 memory categories、每个任务 100 条 successful demonstrations，总计 2,600 long-horizon visual trajectories。任务平均长度为 1,076 steps/task，生成 15,100 keyframe-aligned short segments，可用于 hierarchical supervision。全部 151 个 distinct subtasks 中 104 个 memory-dependent，benchmark-level memory ratio 为 $R_{\mathrm{mem}}=104/151=68.9\%$。真实机器人部分包含 5 个 dual-arm platform tasks，每个任务 10 rollouts，用于物理验证。

Baselines：仿真实验比较 ${\pi }_{0.5}$、HiF-VLA、MemoryVLA、MemER、Qwen3-VL-8B frozen、GPT-5.4、Ground Truth oracle，以及 PrediMem 的 component/backbone variants。${\pi }_{0.5}$ 是 reactive VLA，只基于当前观测动作；HiF-VLA 引入 hindsight/insight/foresight motion representation；MemoryVLA 使用 token-level working memory；MemER 使用 dual-system 和 visual keyframe retrieval；Qwen3-VL-8B frozen 与 GPT-5.4 用作 frozen/closed-source S2 reference；Ground Truth 是 oracle reference。

Evaluation metrics：TSR 是 full-task success rate，所有 stage predicates 均满足才记成功；CSR 是 cumulative success rate，衡量平均完成的 verification stages 比例。真实机器人实验使用 task-level success rate，每个任务 10 次 rollout。Appendix 中还报告异步系统 runtime：S2 refresh 1.06 Hz，S1 low-level VLA 3.40 Hz。

Training config：PrediMem S2 基于 Qwen3-VL-8B-Instruct，vision tower frozen，其余模块 full fine-tune 2 epochs，使用 4 $\times$ H100，learning rate 为 $1\times 10^{-5}$。predictive coding head 使用 latent MSE 和 cosine loss，代码 add-on 默认 mse_weight=0.1、cosine_weight=0.1；论文主文写作 ${\mathcal{L}}_{S2}={\mathcal{L}}_{\mathrm{text}}+0.1{\mathcal{L}}_{\mathrm{Pre}}$，其中 ${\mathcal{L}}_{\mathrm{Pre}}$ 是 MSE 与 cosine distance 之和。recent buffer 使用 5 frames，keyframe buffer uncapped。released async reference 默认 N_RECENT=5、K_MAX=0、VLM_INTERVAL=5、VLM_QUEUE_SIZE=1、REPLAN_STEPS=5、MAX_STEPS=2000，这些来自 evaluation_benchmark/async_vlm26_reference/README.md 和 eval_fullvlm26_async_vlm_vla.py 的环境变量默认值。

5. Experimental Results（实验结果）

5.1 仿真主结果

Table 2 是最关键的结果。PrediMem overall average 达到 38.5% TSR / 55.2% CSR，是所有非 oracle 方法中最高。作为对照，${\pi }_{0.5}$ 为 21.5% / 38.7%，HiF-VLA 为 16.9% / 39.8%，MemoryVLA 为 15.0% / 35.3%，MemER 为 27.3% / 49.1%。这说明显式 keyframe bank 与 predictive coding 的组合确实改善了 long-horizon memory task，而不仅仅是比 reactive policy 多看几帧。

按类别看，PrediMem 在 Transferring 上是 22.5 TSR / 45.2 CSR；Occlusion 上是 27.3 / 38.4；Counting 上是 45.7 / 69.3；Sequence 上是 72.5 / 89.5。Occlusion 仍是最难类别，但 PrediMem 相比 MemER 的 Occlusion TSR 从 16.4 提升到 27.3，说明关键帧管理对抽屉、柜子、微波炉等隐藏状态有明显帮助。Counting 和 Sequence 的 CSR 较高，说明模型能完成较多中间 stage，但 TSR 仍受长链条错误累积影响。

Closed-source / frozen reference 的结果很低。Qwen3-VL-8B frozen overall 只有 6.0 TSR / 26.2 CSR，GPT-5.4 也只有 8.7 / 30.5。论文的解释是，这些模型虽然有通用 multimodal reasoning 和语言记忆能力，但没有在 robotic memory 数据上训练，难以理解物理动作进度、隐藏容器状态和 subtask-level execution。Ground Truth oracle 为 46.1 / 64.8，表明 benchmark 本身有较高上界，但仍非 trivial。

5.2 Ablation：predictive coding 与 keyframe bank

去掉 Predictive Coding Head 后，PrediMem average 降到 32.3% TSR / 49.0% CSR；去掉 Keyframe Bank 后，降到 17.7% TSR / 41.6% CSR。Keyframe Bank 的影响更广，因为很多任务的关键信息一旦离开 recent window 就不可恢复；没有长期 bank 时，occlusion 和 sequence 尤其受损。Predictive coding 的影响更像 representation shaping：它让模型对状态转移更敏感，特别是抽屉关闭、物体消失、重复倒液体完成一次、某个 ordered step 完成等 subtle transitions。

Table 3 比较 predictive loss 权重：0.0 对应 32.3% TSR，0.1 对应 38.5%，0.5 对应 31.0%，1.0 对应 29.8%。最佳是 0.1，说明 predictive loss 过大时会干扰 text/subtask supervision；它应当作为辅助目标，而不是主导 S2 学习。

Figure 4 解读：Figure 4a 和 4b 展示 memory bank scaling。recent buffer 只有 1-2 帧时，模型缺少短时动态证据；3-5 帧通常足够；更大窗口增加冗余和 latency。keyframe bank 容量太小会快速驱逐早期关键观察，uncapped bank 表现最好。Figure 4c 的 t-SNE 显示 predictive coding 后同类 keyframe hidden representations 更紧凑、不同类更分离，支持“predictive coding 改善 keyframe representation”的解释。

5.3 Scaling：S2 backbone 与 memory size

S2 backbone scaling 在 Table 2(d) 中体现：Qwen3-1.7B 版本 overall 为 19.9 TSR / 41.4 CSR，Qwen3-4B 为 31.9 / 51.7，Qwen3-VL-8B PrediMem 为 38.5 / 55.2。作者控制预训练数据和架构后观察到更大 S2 consistently improves performance，说明高层 planner 的视觉-语言推理和记忆管理能力对 RoboMemArena 很关键。

Memory scaling 的结论是 recent buffer 和 keyframe bank 分工不同。recent buffer 负责短期状态变化检测，过短会看不到动作前后差异，过长则引入 redundant visual context 并拖慢 VLM refresh。keyframe bank 保存长期事件，在 long-horizon occlusion 和 transferring 中尤其重要；容量 2 明显不足，4-8 有改善，uncapped 最好。

5.4 Real-world results

真实机器人实验在双臂平台上，每个任务 10 rollouts。${\pi }_{0.5}$ 平均成功率 20%，MemER 为 40%，PrediMem 为 52%。逐任务结果为：Pour $\times 2$，${\pi }_{0.5}$/MemER/PrediMem = 20/30/60；Brush = 10/50/60；Transfer = 60/80/80；Shell = 10/40/50；IHMB = 0/0/10。PrediMem 在 4 个任务上优于 MemER，并且在最长的 Imitate Human to Make Breakfast 中是唯一成功方法。

Figure S2 解读：补充图展示真实机器人评测任务和双臂平台。真实任务把仿真中的四类记忆需求迁移到物理世界：counting 需要记住倒水次数，Shell Game 需要跟踪被遮挡目标，Breakfast from Human 需要记住人类示范的顺序。PrediMem 在这些任务上的提升说明 benchmark 设计不是纯仿真 artifact，记忆机制对物理执行也有价值。

5.5 限制与结论

论文没有把 PrediMem 描述为已解决 robotic memory。首先，最强 PrediMem 的 overall TSR 仍只有 38.5%，距离 Ground Truth 46.1% 还有差距，尤其 occlusion 类别仍困难。第二，真实任务平均成功率 52%，IHMB 只有 10%，说明三分钟级别示范模仿和多步骤物理记忆仍非常难。第三，released repo 在 main@25ee194 未提供完整 S2 fine-tuning launcher，因此外部复现实验时需要自行把 predictive head 接入 Qwen3-VL training stack，并按论文配置冻结 vision tower、处理多图 prompt 与 keyframe labels。

总体结论是：RoboMemArena 把机器人 memory 评测从“是否能做长任务”推进到“是否能在当前观测不充分时恢复历史状态”。PrediMem 的结果说明，explicit keyframe bank 是必要的，predictive coding 能改善高层 VLM 的状态转移敏感性，而更大的 S2 backbone 和合适的 memory capacity 进一步提升性能。对后续工作而言，这个 benchmark 更适合检验 event memory、hierarchical planner、visual keyframe selection、async VLM/VLA coordination，而不是单纯比较低层抓取或局部视觉控制能力。