README.md

---
license: cc-by-4.0
pretty_name: RoboMME-Interference
size_categories:
- 10K<n<100K
tags:
- robotics
- vision-language-action
- memory
- benchmark
- evaluation
- cross-session
configs:
- config_name: default
  data_files:
  - split: test
    path: canonical_rollouts.csv
- config_name: retrieval
  data_files:
  - split: test
    path: retrieval_rollouts.csv
- config_name: success_rates
  data_files:
  - split: test
    path: tables/main_success_rates.csv
---

# RoboMME-Interference

Every rollout from **RoboMME-Interference**, a cross-session benchmark that measures whether a memory-augmented robot policy can still use a relevant past session once unrelated sessions accumulate in its history.

The benchmark is built on [RoboMME](https://robomme.github.io/) (Dai et al., ICML 2026), reusing its tasks, memory-augmented π₀.₅ variants, and released checkpoints. This dataset is the evaluation output, not robot data: one row per rollout, with the outcome and the composition of the history buffer the policy was given.

- **Paper:** [arXiv:2606.22338](https://arxiv.org/abs/2606.22338)
- **Project page:** https://robotmemorybench.com
- **Code:** https://github.com/SoumilRathi/robomme-interference

## The protocol

For each query episode, the policy is given an external history buffer holding the episode's relevant prior demonstration (the *lesson*), followed by `k` unrelated *distractor* sessions from other task families. Larger `k` pushes the lesson farther back.

| `condition` | History buffer contents |
| --- | --- |
| `no-history` | empty |
| `k0` | the lesson only |
| `k1`, `k3`, `k7` | the lesson, then 1, 3, or 7 unrelated sessions |

Eight memory systems, each across nine task families, five conditions, and 50 test episodes, gives 18,000 rollouts. The π₀.₅ baseline has no memory and appears only at `no-history`, adding 450, for **18,450 rollouts** over 369 cells.

## Scoring convention

Success rate is `successes / 50` per cell. Episodes that hit the step limit have `status == "ongoing"` and **count as non-successes**: they stay in the denominator. Filtering them out inflates every rate.

```python
from datasets import load_dataset

ds = load_dataset("SoumilR/robomme-interference", split="test")
cell = ds.filter(lambda r: r["variant"] == "perceptual-framesamp-modul"
                       and r["family"] == "MoveCube" and r["condition"] == "k7")
rate = sum(r["status"] == "success" for r in cell) / len(cell)  # 0.32
```

## Configs

| Config | Rows | Contents |
| --- | --- | --- |
| `default` | 18,450 | every rollout across all nine systems (`canonical_rollouts.csv`) |
| `retrieval` | 1,800 | rollouts for Retrieval-FrameSamp-Modul (`retrieval_rollouts.csv`) |
| `success_rates` | 41 | per-system, per-condition success rates with Wilson 95% intervals |

`tables/` also holds success rates per family and per difficulty, each system's lift over its own `no-history` rate, and the `k0`-to-`k7` drops.

## Columns

Shared by both rollout files:

| Column | Description |
| --- | --- |
| `family` | task family: `MoveCube`, `RouteStick`, `VideoUnmask`, `VideoUnmaskSwap`, `VideoRepick`, `VideoPlaceButton`, `VideoPlaceOrder`, `InsertPeg`, `PatternLock` |
| `condition` | `no-history`, `k0`, `k1`, `k3`, `k7` |
| `episode` | test-episode index, 0–49; the same identity across conditions, so comparisons are paired |
| `seed` | simulator seed |
| `difficulty` | RoboMME's `easy` / `medium` / `hard` stratification |
| `status` | `success`, `fail`, or `ongoing` (hit the step limit) |
| `success` | boolean, equivalent to `status == "success"` |
| `steps` | environment steps taken |

`canonical_rollouts.csv` adds:

| Column | Description |
| --- | --- |
| `variant` | one of `perceptual-{framesamp,tokendrop}-{modul,context,expert}`, `recurrent-ttt-{context,expert}`, `pi05_baseline` |
| `distractors` | number of unrelated sessions in the buffer |
| `buffer_frames_start`, `buffer_frames_end` | buffer size in frames, before and after the rollout |
| `actual_*_lesson,filler,query` and `*_fraction` | how much of the buffer came from the lesson, the distractors, and the live query episode, at rollout start and end |
| timing and cache columns | wall-clock and server-side latency per phase, feature-cache hit counts |

`retrieval_rollouts.csv` adds:

| Column | Description |
| --- | --- |
| `retrieval_model` | encoder and segmentation setting used for retrieval |
| `retrieval_selected_{lesson,filler,query}_fraction` | share of the retrieved segment that came from the lesson, the distractors, and the query episode |

The mean `retrieval_selected_lesson_fraction` is 0.96, so what retrieval delivers to the policy is almost entirely the lesson.

## Variant names

Paper names map to `variant` values as `FrameSamp` → `framesamp`, `TokenDrop` → `tokendrop`, `Recurrent-TTT` → `recurrent-ttt`, and the integration suffixes `-Modul`, `-Context`, `-Expert` → `-modul`, `-context`, `-expert`.

## Citation

```bibtex
@article{rathi2026robomme_interference,
  title  = {RoboMME-Interference: Benchmarking Robot Memory Under Interference},
  author = {Rathi, Soumil},
  journal = {arXiv preprint arXiv:2606.22338},
  year   = {2026}
}
```

Please also cite [RoboMME](https://robomme.github.io/), which this benchmark builds on.

## License

CC BY 4.0. The simulator checkpoints and raw rollout videos are not redistributed here; they come from [RoboMME](https://robomme.github.io/).