PAPER DEEP DIVE
Data-Free Continual Learning for World Action Model with Rectified Generative Replay
World action models (WAMs) built on pretrained video generation models adapt quickly to new robotic tasks, but they forget previously learned tasks under sequential fine-tuning. Experience replay (ER) mitigates such forgetting by rehearsing data of previous tasks, yet this data is often unavailable in robotics, where a policy is deployed as weights only and its training data is not shared along with it. In this work, we ask whether a WAM can achieve data-free continual learning by regenerating its own past. Our key observation is that a WAM can indeed autoregressively regenerate complete rollouts of previously learned tasks and replay them to mitigate forgetting. However, replaying such raw rollouts still lags far behind replaying real data, which we attribute to two issues. First, the WAM is unable to recognize task completion and keeps generating purposeless motion after the task is done. Second, under open-loop generation, the generated actions gradually drift away from the generated observations. To address both issues, we present rectified generative replay (R²-WAM), which truncates generated rollouts at task completion with an agentic evaluator and filters out rollouts whose actions are physically inconsistent with the observations. On the four LIBERO suites and five real-world tasks, R²-WAM reduces forgetting by over 90% relative to sequential fine-tuning and nearly matches ER without accessing any data from previous tasks. Our analysis further reveals that forgetting in WAMs concentrates in inverse dynamics modeling: a forgotten WAM still produces visually plausible observations of previous tasks while its generated actions fail. Project page: https://kaipengfang.github.io/r2-wam/
Paper metadata Title: Data-Free Continual Learning for World Action Model with Rectified Generative Replay (R2-WAM). Authors: Kaipeng Fang, Hangxu Liu, Chaojian Shi, Yunsong Zhou, Hongzi Zhu, Minyi Guo, Jingkuan Song, Lianli Gao (Zhou and Gao are equal-advising). Affiliations: University of Electronic Science and Technology of China, Shanghai AI Lab, Fudan University, Shanghai Jiao Tong University, Tongji University, Shanghai Innovation Institute. Links: arXiv 2610.18038; project page kaipengfang.github.io/r2-wam. Code status: the paper states code will be released upon publication; no public repository exists at the time of this close read, so there is no source to cross-check and all method details come from the full text and appendix. Backbone: LingBot-VA; optical flow via Track4World.
One-line summary
A world action model can autoregressively regenerate rollouts of tasks it already learned from the instruction alone, but raw rollouts neither stop at task completion nor keep their actions consistent with their observations; R2-WAM rectifies them with completion-aware truncation and flow-based physical-consistency filtering before replay, cutting forgetting by over 90% relative to sequential fine-tuning and nearly matching experience replay while retaining zero data from previous tasks.
1. Background and motivation
Robots deployed in the real world keep meeting new tasks, so a practical policy must learn them continually while retaining what it already knows. Among robot policy paradigms, world action models (WAMs) have become prominent because they build on powerful pretrained video generation models and jointly predict future observations and robot actions. The authors first show empirically that sequentially fine-tuning a WAM adapts it well to new tasks but collapses it on previously learned ones, i.e. catastrophic forgetting.
Two classic families mitigate forgetting. Regularization-style methods constrain parameter updates, such as EWC with its Fisher-weighted quadratic penalty or LwF which distills the previous model's outputs, but regularization retains little for robotic policies. Experience replay (ER) instead keeps a buffer of demonstrations from earlier tasks and mixes them into new-task fine-tuning, and remains one of the most effective and robust choices for robot policies.
ER, however, assumes demonstrations accumulate alongside tasks. In practice a policy often arrives as weights alone and the data that trained it is not shared with it, so the deployer holds no demonstrations of earlier tasks. The authors therefore study a stricter, deployment-realistic setting: data-free continual learning, in which after adapting to a task only its instruction and the updated parameters carry over, while its demonstrations and task environment are no longer accessible.
Under this setting a WAM offers a unique opportunity. Because it models how the world evolves and can autoregressively predict future observations and actions, it can in principle roll out previously learned tasks again and use those rollouts as replay data. The paper thus asks: can a WAM leverage its own generative capability to achieve data-free continual learning as effectively as ER?
The answer is yes, with one crucial caveat: raw generated rollouts cannot be replayed directly. The authors attribute the gap to two defects. First, the WAM has no notion of task completion and receives no external stop signal, so generation runs for a fixed number of steps and keeps producing purposeless post-completion motion, e.g. re-grasping an object it already placed. Second, open-loop generation feeds the model's own predictions back without physical grounding, so errors accumulate and the generated actions gradually drift away from the generated observations. R2-WAM is entirely about rectifying these two defects.
2. Preliminaries
Each manipulation task $\mathcal{T}_k$ is modeled by an instruction $\ell_k$ and an expert demonstration set $\mathcal{D}_k$, where each trajectory $\tau_i^k=\{(o_t,a_t)\}$ pairs visual observations with robot actions. Continual learning considers a single policy shared across tasks and conditioned on the instruction, $\pi_\theta(a_t\mid o_{\leq t},\ell_k)$, optimized at each stage by behavior cloning on the current task's demonstrations:
$$\mathcal{L}_{\mathrm{BC}}(\theta;\mathcal{D}_k)=\mathbb{E}_{\tau\sim\mathcal{D}_k}\left[\sum_{t=0}^{|\tau|-1}-\log\pi_\theta(a_t\mid o_{\leq t},\ell_k)\right] \tag{1}$$Unlike a conventional policy that maps observations to actions, a WAM also predicts the future observations its actions would produce. Given task $\mathcal{T}_k$ and a trajectory prefix $\tau_{\leq t}$, it models the joint conditional distribution below, where $H$ is the chunk size, i.e. the number of observations and actions predicted in one step:
$$p_\theta\bigl(o_{t+1:t+H},\,a_{t:t+H-1}\mid \tau_{\leq t},\,\ell_k\bigr) \tag{2}$$The experiments adopt LingBot-VA as a representative WAM: a 5.1B-parameter diffusion Transformer (30 layers, hidden size 3072, FFN 14336) over 48-channel latents from a Wan VAE, conditioned on a frozen UMT5-XXL text encoder. On LIBERO it observes two 128x128 views and predicts four latent frames per chunk, i.e. $H=16$ actions, which is also the granularity at which truncation cuts. Generation is autoregressive across chunks and diffusion-based within a chunk, keeping the released inference configuration: a flow-matching sampler with 20 denoising steps for observations and 50 for actions, and classifier-free guidance of 5.0 on observations and 1.0 on actions. The single change the authors make is action normalization, using each task's own 1st and 99th percentiles instead of one global range.
3. Method: generate, rectify, replay
Step 1, generate rollouts from the instruction alone. For each learned task $\mathcal{T}_j$, R2-WAM feeds only the instruction $\ell_j$ to the current model. Because the WAM is built on a video generation model and fine-tuning keeps the initial observation as a prediction target, a rollout starts by sampling $\hat{o}_0\sim p_\theta(o_0\mid\ell_j)$ and then proceeds chunk by chunk: it first predicts the next $H$ observations from the generated history, then predicts the corresponding actions conditioned on them:
$$\hat{o}_{t+1:t+H}\sim p_\theta\bigl(\cdot\mid\hat{\tau}_{\leq t},\ell_j\bigr)\;\longrightarrow\;\hat{a}_{t:t+H-1}\sim p_\theta\bigl(\cdot\mid\hat{\tau}_{\leq t},\hat{o}_{t+1:t+H},\ell_j\bigr) \tag{3}$$This repeats until a predefined horizon $T$, yielding $\hat{\tau}_j=\{(\hat{o}_t,\hat{a}_t)\}_{t=0}^{T-1}$. The horizon is set to $\lfloor \bar{L}/16\rfloor+2$ chunks of 16 steps, where $\bar{L}$ is the mean demonstration length of the task, i.e. about two chunks longer than a typical demonstration; the authors stress this is only a convenience and the horizon can equally come from a human duration estimate or from probing a few generated rollouts, and because truncation cuts at completion the exact value matters little as long as it is long enough. Each task samples $M=40$ candidates.
Defect one and completion-aware adaptive truncation. The WAM cannot recognize when a task is done, so after completion it keeps generating re-grasping or wandering motion that would corrupt the task's learned behavior if replayed. R2-WAM therefore uses a vision-language model as an agentic evaluator to locate the completion point of each candidate rollout. Rather than feeding the whole video, it uniformly subsamples frames from the later part (every 2 steps over the final 20% or at least 40 steps) and annotates each frame with its step index, gripper command, and end-effector speed taken from the generated actions; frames where a motion ends or the gripper releases are tagged [BOUNDARY] and the rest [SAMPLE], since the correct cut usually falls on a boundary. Each frame pairs the external and wrist view, and a summary of motion segments detected from the action stream is attached.
The evaluator also receives one in-context example per task: a generated rollout of the same task whose acceptable truncation range a human has marked, calibrating what completion looks like. Given the instruction and these inputs, the evaluator first derives the goal state and the step at which each subgoal is satisfied, then decides whether the task was accomplished and returns the end step $\hat{t}_{\mathrm{end}}$, the point where the completing motion has fully finished (object released, gripper retreated); for multi-subgoal tasks it is the completion of the final subgoal. The rollout is then truncated at the chunk boundary following $\hat{t}_{\mathrm{end}}$, keeping the completed interaction and dropping what follows; rollouts judged as not accomplishing the task are discarded. The prompt encodes fine-grained rules: a placement subgoal counts as satisfied only once the object rests at its target, the printed gripper values have switched from closing to opening, and the object has settled; a non-held subgoal (pushing, sliding, turning) ignores the gripper and follows the interaction to its turning point; a subgoal is satisfied at the last successful attempt; ties between adjacent candidates go to the later one; and if some subgoal never appears, accomplished is set false and the last candidate step is returned.
The authors validate the evaluator on 200 human-annotated truncation ranges: stronger VLMs cut more accurately, from 73.5% for Qwen3-VL to 93.5% for GPT-5.6 Sol, with Terra (91.0%) used elsewhere to balance accuracy against cost; removing the in-context example drops accuracy to 78.0%, showing where a task ends is inherently ambiguous and the example anchors it; removing the action annotations drops it to 76.0%, showing completion is often hard to read from observations alone and the motion cues help.
Defect two and flow-based physical-consistency filtering. Open-loop drift between observations and actions must be quantified, but the environments of previous tasks are gone so the generated actions cannot truly be executed. Fortunately the robot itself is fully specified by its URDF and camera parameters, so its motion under the generated actions can be simulated without any environment and used as a reference. Concretely, the actions of each truncated rollout are executed in a robot-only MuJoCo scene and the resulting optical flow of the robot, $\Phi_{\mathrm{sim}}$, is recorded; in parallel, the dense 3D tracker Track4World estimates the flow $\Phi_{\mathrm{pred}}$ from the generated observations. The two flows are compared only on robot pixels (a pixel counts only if the simulator marks it as part of the moving robot in both frames of the pair), so the score measures whether the generated video moves the robot the way the generated actions would, with task objects excluded. The physical-consistency score is:
$$s_{\mathrm{flow}}(\tilde{\tau})=\lambda_{\mathrm{2D}}\,d_{\mathrm{2D}}\bigl(\Phi_{\mathrm{pred}},\Phi_{\mathrm{sim}}\bigr)+\lambda_{\mathrm{3D}}\,d_{\mathrm{3D}}\bigl(\Phi_{\mathrm{pred}},\Phi_{\mathrm{sim}}\bigr) \tag{4}$$where $d_{\mathrm{2D}}$ and $d_{\mathrm{3D}}$ summarize the disagreement in the image plane and in 3D camera space as a normalized discrepancy in $[0,1]$ averaged over all robot pixels and frame pairs, lower being better; the weights are $\lambda_{\mathrm{2D}}=\lambda_{\mathrm{3D}}=0.5$ and are used unchanged for all suites and the real robot. Candidates are ranked by $s_{\mathrm{flow}}$ and the top-$N$ kept as the replay set $\mathcal{R}_j$. In the real-robot variant the gripper command shown to the evaluator is replaced by the mean distance between the thumb and the other fingertips mapped to the same open/close scale, the end-effector velocity comes from forward kinematics on the arm joints, and the flow filter uses the head camera only; the prompt is otherwise unchanged.
Step 3, replay with rectified rollouts. R2-WAM replays exactly as ER does, replacing the real buffer $\mathcal{B}_{<k}$ with the union of rectified rollouts $\mathcal{R}_{<k}=\bigcup_{j<k}\mathcal{R}_j$ and fine-tuning on $\mathcal{D}_k\cup\mathcal{R}_{<k}$ at stage $k$ by maximizing the likelihood of Eq. (2). Each $\mathcal{R}_j$ is generated once and cached for all later stages, so $\mathcal{R}_{<k}$ matches ER's buffer in size without any real data. Experiments use $M=40$ and $N=20$ (i.e. $M=2N$), mixing replay data and new-task demonstrations with equal per-sample weight.
flowchart TD A["WAM k-1 has learned task k-1"] --> B["Generate M=40 rollouts
from the instruction only"] B --> C["VLM evaluator reads late frames
plus action annotations
locates completion step t_end"] C --> D{"task accomplished"} D -- no --> E["discard the rollout"] D -- yes --> F["truncate at the chunk
boundary after t_end"] F --> G["robot-only MuJoCo executes actions
gives flow Phi_sim"] F --> H["Track4World reads generated video
gives flow Phi_pred"] G --> I["rank by s_flow keep top-N=20"] H --> I I --> J["cache as R k-1 for later stages"] J --> K["fine-tune with new-task demos D k
equal sampling weight"] K --> L["obtain WAM k move to next stage"]
Cost. On a single node with four H200 GPUs, generating and rectifying the replay set of one LIBERO-Spatial task takes about 18 minutes, roughly one sixth of the 1.8 hours needed to fine-tune that task for 1,000 steps, and is paid once per task: 11 minutes to generate the 40 candidates, 3.5 minutes for completion-aware truncation (40 VLM calls, about 1.8M input tokens), 1.5 minutes for Track4World flow estimation, and 2 minutes for robot-only simulation, scoring, and top-N selection. Generation scales linearly with the number of candidates $M$ and with the horizon, while truncation is bounded by the VLM API rather than by compute.
4. Experiments
Simulation uses the four LIBERO suites (Spatial, Object, Goal, and 10), each a sequence of 10 tasks with 50 demonstrations per task; the real world uses a 7-DoF arm with a 20-DoF dexterous hand and head plus wrist cameras on a shared tabletop, learning five sequential "make a sandwich with (ingredient)" tasks, with observations at 30 Hz resized to 256x320 and a 27-dimensional joint command as the action. Metrics follow the task matrix: $c_{i,k}$ is the performance of task $i$ after learning task $k$ (success rate over 50 trials in simulation, progress rate over 20 trials on the robot), from which
$$\mathrm{SR}=\tfrac{1}{K}\sum_i c_{i,K},\quad \mathrm{NBT}=\tfrac{1}{K}\sum_{k<K}\tfrac{1}{K-k}\sum_{j>k}(c_{k,k}-c_{k,j}),\quad \mathrm{Plasticity}=\tfrac{1}{K}\sum_k c_{k,k} \tag{5}$$SR is average performance over all tasks with the final checkpoint, NBT (negative backward transfer) measures forgetting as the average drop of each task from the checkpoint that just learned it to all later checkpoints, and Plasticity is average performance at the checkpoint that just learned each task. Because a binary success hides partial progress on the long-horizon real tasks, they are scored by a four-step progress rate (lift the instructed ingredient, rest it on the bread, lift the top bread, cover the sandwich) divided by four, with the first two steps earning nothing if the wrong ingredient is used. All methods share the same backbone, schedule, and protocol; simulation uses three seeds and 50 trials per task, the robot 20 trials per task.
Figure 1: (a) A sequentially fine-tuned WAM forgets earlier tasks; experience replay retains them but needs their data. (b) R2-WAM achieves data-free continual learning with rectified generative replay and approaches ER on average success.
Main results. Across the four LIBERO suites every non-replay method collapses: Seq-FT averages only 12.5 SR with NBT 80.19, and Seq-LoRA, EWC, and LwF sit between 11 and 15, showing regularization and parameter isolation do almost nothing for a WAM. ER with real demonstrations reaches 94.6 / 0.09 / 94.7 and serves as the upper bound. Replaying unrectified rollouts (R-WAM) already lifts average SR from 12.5 to 70.4, proving that self-generated replay works at all; R2-WAM pushes further to 92.7 / 2.33 / 94.7, within 1.9 points of ER on average and 5.2 points on LIBERO-10, while cutting forgetting by over 90% relative to Seq-FT. Per suite, R2-WAM scores 94.0, 95.5, and 92.2 on Spatial, Object, and Goal, matching or exceeding ER on two of the three.
| Method | Spatial SR/NBT | Object SR/NBT | Goal SR/NBT | LIBERO-10 SR/NBT | Avg SR/NBT/Plast. |
|---|---|---|---|---|---|
| Seq-FT | 11.2 / 86.07 | 21.2 / 67.84 | 9.8 / 84.87 | 7.6 / 82.00 | 12.5 / 80.19 / 94.4 |
| Seq-LoRA | 9.6 / 75.42 | 17.6 / 52.47 | 9.8 / 68.72 | 7.4 / 71.24 | 11.1 / 66.96 / 84.4 |
| EWC | 12.0 / 85.59 | 23.6 / 62.19 | 10.0 / 84.55 | 7.8 / 82.24 | 13.3 / 78.64 / 95.0 |
| LwF | 13.0 / 85.14 | 27.6 / 61.76 | 10.4 / 83.70 | 8.6 / 78.96 | 14.9 / 77.39 / 94.2 |
| ER (real data, upper bound) | 94.0 / 0.54 | 97.3 / -1.83 | 92.8 / 2.11 | 94.1 / -0.46 | 94.6 / 0.09 / 94.6 |
| R-WAM (raw replay) | 76.1 / 11.97 | 83.1 / 18.93 | 51.2 / 27.31 | 71.3 / 7.63 | 70.4 / 16.46 / 89.1 |
| R2-WAM (ours) | 94.0 / 2.90 | 95.5 / -0.31 | 92.2 / 2.00 | 88.9 / 4.73 | 92.7 / 2.33 / 94.7 |
Table 1: Continual learning results on the four LIBERO suites (mean over three seeds); all replay methods use 20 episodes per previous task.
Figure 2: Overview of R2-WAM. After learning task k-1, the WAM (1) generates M candidate rollouts from the instruction alone; (2) rectifies them by truncating at task completion and filtering physically inconsistent ones; (3) replays the retained top-N together with earlier rectified rollouts and the new-task demonstrations to obtain WAM k, repeating at the next stage.
Real-robot results. On the five sandwich tasks, ER reaches 91.8 / 2.27 / 94.8, Seq-FT 28.5 / 65.62 / 98.8 (highly plastic but severely forgetful), and R2-WAM 89.5 / 3.45 / 93.8, again approaching ER with no data of previous tasks. Qualitatively, Seq-FT's forgetting worsens as more tasks are learned: right after learning a task it completes all four steps, one task later it skips the instructed ingredient and completes only the two bread steps, and several tasks later even the bread steps degrade; ER and R2-WAM both still complete the first task with the same motion four tasks later. Their shared failure mode is lost placement precision (the fried egg slips in transit, the cheese is released at the bread edge and slides off), consistent with task interference.
| Method (five real tasks) | SR up | NBT down | Plast. up |
|---|---|---|---|
| ER (real data) | 91.8 | 2.27 | 94.8 |
| Seq-FT | 28.5 | 65.62 | 98.8 |
| R2-WAM (ours) | 89.5 | 3.45 | 93.8 |
Table 2: Real-world results on five sequential tasks; metrics are computed on the four-step progress rate (20 trials per task).
Ablations and mechanism. On LIBERO-Spatial, removing truncation drops SR from 94.0 to 70.8 with NBT 13.73, removing filtering drops it to 80.8 with NBT 7.02, and doing neither (R-WAM) gives 76.1 / 11.97, so both rectification steps are necessary and truncation contributes more. The physical-consistency score does track executability: grouping 400 rollouts by $s_{\mathrm{flow}}$ from most to least consistent and executing their actions in simulation, the fraction that complete the task falls monotonically from 82.5% to 41.2%. Trajectory visualization shows generated trajectories follow the same overall pattern as real ones but deviate as the rollout proceeds, with release positions drifting far more than grasp positions; retained rollouts stay much closer to the real trajectories than filtered ones, confirming the filter picks low-drift samples, while the residual deviation in retained rollouts explains the remaining gap to ER on the longer-horizon suite.
| Variant (LIBERO-Spatial) | SR up | NBT down | Plast. up |
|---|---|---|---|
| R-WAM (no rectification) | 76.1 | 11.97 | 93.6 |
| without truncation | 70.8 | 13.73 | 89.2 |
| without filtering | 80.8 | 7.02 | 91.4 |
| R2-WAM full | 94.0 | 2.90 | 95.7 |
Table 3: Ablation of the two rectification components; each row removes one.
Figure 4: (a) Grouping rollouts by $s_{\mathrm{flow}}$ into quintiles and executing them in simulation, the executable fraction falls from 82.5% for the most consistent to 41.2% for the least. (b) The two optical flows behind the score for a low- and a high-score rollout: blue simulated from the generated actions, orange estimated from the generated observations.
Figure 5: (a) Trajectories of 50 real demonstrations and 40 generated rollouts (20 selected, 20 filtered) on a LIBERO-Spatial task. (b) Top view of grasp and release positions; release positions drift noticeably more.
Buffer scaling and forgetting diagnostics. Scaling the replay buffer from 1 to 50 episodes per previous task, both methods improve rapidly and plateau beyond 20, so the main experiments use 20; notably at buffer size 1 R2-WAM beats ER (79.2 versus 69.6 SR), and the authors conjecture a generated rollout reflects the typical behavior the model learned for a task and thus anchors it better than a single real demonstration that may be atypical or noisy. The diagnostic study probes the two coupled capabilities with teacher forcing and measures forgetting by relative retention
$$r(\Delta)=\frac{1}{K-\Delta}\sum_{i=0}^{K-1-\Delta}\frac{p_{i,i+\Delta}}{p_{i,i}} \tag{6}$$Seq-FT forgets inverse dynamics modeling almost entirely: retention of that capability drops to 8% after one further task and never recovers, whereas under R2-WAM it stays above 75% across all subsequent tasks. Video prediction is largely preserved, retaining 78% under Seq-FT and over 85% under R2-WAM. In other words a forgotten WAM still imagines visually plausible observations of previous tasks while its generated actions fail: forgetting concentrates on the action side, which is exactly the branch the rectification verifies. Against a ReGen-style replay variant that initializes each rollout from a real observation and applies no consistency filtering, the variant reaches only 68.0 on LIBERO-Spatial versus 94.0 for R2-WAM, showing that retaining real initial observations does not substitute for regenerating and rectifying rollouts from the instruction alone.
Figure 6: (a) Relative retention of the two probed capabilities as more tasks are learned; circles with solid lines are inverse dynamics, squares with dashed lines video prediction, yellow Seq-FT and green R2-WAM. (b) Rollouts generated by the final checkpoints from the same real first frame of T0, with the rightmost frame rendered by executing the generated actions in simulation: Seq-FT fails, R2-WAM succeeds.
5. Limitations
The authors state two. First, a small gap to ER remains and is largest on long-horizon tasks, suggesting filtering mitigates but does not fully resolve observation-action drift; aligning the two signals at training time or grounding generation with an external world model are directions they flag. Second, the reduced plasticity of replay-based methods in the real-world experiments suggests interference between tasks also needs to be addressed.
Two further observations of my own. First, completion-aware truncation depends on a VLM API and on human annotation: each task needs one human-marked in-context example, and 40 calls costing about 1.8M input tokens per task is non-trivial, while evaluator accuracy (91.0% for the default Terra) directly gates replay-data quality. Second, physical-consistency filtering requires an accurate URDF and camera intrinsics/extrinsics so the robot-only simulation can reproduce the flow, which excludes uncalibrated platforms; the generation horizon also still needs the mean demonstration length or a human duration estimate, so the setting is not information-free in the strictest sense.
6. Conclusion and outlook
R2-WAM delivers a clean message: the generative capability of a WAM is itself a memory. Once the two defects of not stopping at completion and open-loop drift are fixed, the model's regenerated past is good enough to serve as replay data, approaching experience replay while retaining no data of previous tasks. The ablations show truncation and filtering are both necessary, and the diagnostic localizes forgetting to inverse dynamics modeling, explaining why a WAM can regenerate its own past and pointing at the action branch as the part to verify.
Looking ahead, this line shifts the storage cost of continual learning from data to compute plus a one-time generation cache, which suits deployment regimes where only weights ship. Aligning observations and actions during training, grounding generation with an external world model, or extending rectification to data synthesis for VLA policies and video world models could make data-free continual learning a default capability of robot policies.
Golden quotes
"We ask whether a WAM can achieve data-free continual learning by regenerating its own past."
"A forgotten WAM still produces visually plausible observations of previous tasks while its generated actions fail: forgetting concentrates in inverse dynamics modeling."
"A generated rollout reflects the typical behavior the model has learned for a task and thus anchors it better than a single real demonstration, which may be atypical or noisy."
