--- abstract: | Latent Action Models (LAMs) learn action-like proxies from observation transitions. However, in multi-object or distractor-rich scenes, these visual effects mix agent motion with distractors, camera dynamics, and background changes, making the underlying action source ambiguous without supervision. Structuring this mixture as reusable transition effects provides an intermediate representation from which action-like latents can be more robustly formed. We introduce Observed Transition Factorization (OTF), which decomposes each transition into a sparse set of observed-transition primitives. Using these primitives as the transition interface, we propose OTF-LAM, which abstracts motion primitives into action-like latents within the standard inverse--forward dynamics framework, and OTF-LAM-Dino, a decoder-free variant that predicts future states in a frozen DINOv2 representation space. Empirically, OTF primitives transfer zero-shot across controlled carrier and morphology shifts, showing reusability. Furthermore, downstream policy learning results match or outperform baselines under complex transition ambiguity. bibliography: - ref.bib --- ```{=latex} \newcommand{\theHalgorithm}{\arabic{algorithm}} ``` ```{=latex} \newcommand{\ind}{\mathrel{\perp\!\!\!\perp}} ``` ```{=latex} \newcommand{\figleft}{{\em (Left)}} ``` ```{=latex} \newcommand{\figcenter}{{\em (Center)}} ``` ```{=latex} \newcommand{\figright}{{\em (Right)}} ``` ```{=latex} \newcommand{\figtop}{{\em (Top)}} ``` ```{=latex} \newcommand{\figbottom}{{\em (Bottom)}} ``` ```{=latex} \newcommand{\captiona}{{\em (a)}} ``` ```{=latex} \newcommand{\captionb}{{\em (b)}} ``` ```{=latex} \newcommand{\captionc}{{\em (c)}} ``` ```{=latex} \newcommand{\captiond}{{\em (d)}} ``` ```{=latex} \newcommand{\newterm}[1]{{\bf #1}} ``` ```{=latex} \def\figref#1{figure~\ref{#1}} ``` ```{=latex} \def\Figref#1{Figure~\ref{#1}} ``` ```{=latex} \def\twofigref#1#2{figures \ref{#1} and \ref{#2}} ``` ```{=latex} \def\quadfigref#1#2#3#4{figures \ref{#1}, \ref{#2}, \ref{#3} and \ref{#4}} ``` ```{=latex} \def\secref#1{section~\ref{#1}} ``` ```{=latex} \def\Secref#1{Section~\ref{#1}} ``` ```{=latex} \def\twosecrefs#1#2{sections \ref{#1} and \ref{#2}} ``` ```{=latex} \def\secrefs#1#2#3{sections \ref{#1}, \ref{#2} and \ref{#3}} ``` ```{=latex} \def\eqref#1{equation~\ref{#1}} ``` ```{=latex} \def\Eqref#1{Equation~\ref{#1}} ``` ```{=latex} \def\plaineqref#1{\ref{#1}} ``` ```{=latex} \def\chapref#1{chapter~\ref{#1}} ``` ```{=latex} \def\Chapref#1{Chapter~\ref{#1}} ``` ```{=latex} \def\rangechapref#1#2{chapters\ref{#1}--\ref{#2}} ``` ```{=latex} \def\algref#1{algorithm~\ref{#1}} ``` ```{=latex} \def\Algref#1{Algorithm~\ref{#1}} ``` ```{=latex} \def\twoalgref#1#2{algorithms \ref{#1} and \ref{#2}} ``` ```{=latex} \def\Twoalgref#1#2{Algorithms \ref{#1} and \ref{#2}} ``` ```{=latex} \def\partref#1{part~\ref{#1}} ``` ```{=latex} \def\Partref#1{Part~\ref{#1}} ``` ```{=latex} \def\twopartref#1#2{parts \ref{#1} and \ref{#2}} ``` ```{=latex} \def\ceil#1{\lceil #1 \rceil} ``` ```{=latex} \def\floor#1{\lfloor #1 \rfloor} ``` ```{=latex} \def\1{\bm{1}} ``` ```{=latex} \newcommand{\train}{\mathcal{D}} ``` ```{=latex} \newcommand{\valid}{\mathcal{D_{\mathrm{valid}}}} ``` ```{=latex} \newcommand{\test}{\mathcal{D_{\mathrm{test}}}} ``` ```{=latex} \def\eps{{\epsilon}} ``` ```{=latex} \def\reta{{\textnormal{$\eta$}}} ``` ```{=latex} \def\ra{{\textnormal{a}}} ``` ```{=latex} \def\rb{{\textnormal{b}}} ``` ```{=latex} \def\rc{{\textnormal{c}}} ``` ```{=latex} \def\rd{{\textnormal{d}}} ``` ```{=latex} \def\re{{\textnormal{e}}} ``` ```{=latex} \def\rf{{\textnormal{f}}} ``` ```{=latex} \def\rg{{\textnormal{g}}} ``` ```{=latex} \def\rh{{\textnormal{h}}} ``` ```{=latex} \def\ri{{\textnormal{i}}} ``` ```{=latex} \def\rj{{\textnormal{j}}} ``` ```{=latex} \def\rk{{\textnormal{k}}} ``` ```{=latex} \def\rl{{\textnormal{l}}} ``` ```{=latex} \def\rn{{\textnormal{n}}} ``` ```{=latex} \def\ro{{\textnormal{o}}} ``` ```{=latex} \def\rp{{\textnormal{p}}} ``` ```{=latex} \def\rq{{\textnormal{q}}} ``` ```{=latex} \def\rr{{\textnormal{r}}} ``` ```{=latex} \def\rs{{\textnormal{s}}} ``` ```{=latex} \def\rt{{\textnormal{t}}} ``` ```{=latex} \def\ru{{\textnormal{u}}} ``` ```{=latex} \def\rv{{\textnormal{v}}} ``` ```{=latex} \def\rw{{\textnormal{w}}} ``` ```{=latex} \def\rx{{\textnormal{x}}} ``` ```{=latex} \def\ry{{\textnormal{y}}} ``` ```{=latex} \def\rz{{\textnormal{z}}} ``` ```{=latex} \def\rvepsilon{{\mathbf{\epsilon}}} ``` ```{=latex} \def\rvtheta{{\mathbf{\theta}}} ``` ```{=latex} \def\rva{{\mathbf{a}}} ``` ```{=latex} \def\rvb{{\mathbf{b}}} ``` ```{=latex} \def\rvc{{\mathbf{c}}} ``` ```{=latex} \def\rvd{{\mathbf{d}}} ``` ```{=latex} \def\rve{{\mathbf{e}}} ``` ```{=latex} \def\rvf{{\mathbf{f}}} ``` ```{=latex} \def\rvg{{\mathbf{g}}} ``` ```{=latex} \def\rvh{{\mathbf{h}}} ``` ```{=latex} \def\rvu{{\mathbf{i}}} ``` ```{=latex} \def\rvj{{\mathbf{j}}} ``` ```{=latex} \def\rvk{{\mathbf{k}}} ``` ```{=latex} \def\rvl{{\mathbf{l}}} ``` ```{=latex} \def\rvm{{\mathbf{m}}} ``` ```{=latex} \def\rvn{{\mathbf{n}}} ``` ```{=latex} \def\rvo{{\mathbf{o}}} ``` ```{=latex} \def\rvp{{\mathbf{p}}} ``` ```{=latex} \def\rvq{{\mathbf{q}}} ``` ```{=latex} \def\rvr{{\mathbf{r}}} ``` ```{=latex} \def\rvs{{\mathbf{s}}} ``` ```{=latex} \def\rvt{{\mathbf{t}}} ``` ```{=latex} \def\rvu{{\mathbf{u}}} ``` ```{=latex} \def\rvv{{\mathbf{v}}} ``` ```{=latex} \def\rvw{{\mathbf{w}}} ``` ```{=latex} \def\rvx{{\mathbf{x}}} ``` ```{=latex} \def\rvy{{\mathbf{y}}} ``` ```{=latex} \def\rvz{{\mathbf{z}}} ``` ```{=latex} \def\erva{{\textnormal{a}}} ``` ```{=latex} \def\ervb{{\textnormal{b}}} ``` ```{=latex} \def\ervc{{\textnormal{c}}} ``` ```{=latex} \def\ervd{{\textnormal{d}}} ``` ```{=latex} \def\erve{{\textnormal{e}}} ``` ```{=latex} \def\ervf{{\textnormal{f}}} ``` ```{=latex} \def\ervg{{\textnormal{g}}} ``` ```{=latex} \def\ervh{{\textnormal{h}}} ``` ```{=latex} \def\ervi{{\textnormal{i}}} ``` ```{=latex} \def\ervj{{\textnormal{j}}} ``` ```{=latex} \def\ervk{{\textnormal{k}}} ``` ```{=latex} \def\ervl{{\textnormal{l}}} ``` ```{=latex} \def\ervm{{\textnormal{m}}} ``` ```{=latex} \def\ervn{{\textnormal{n}}} ``` ```{=latex} \def\ervo{{\textnormal{o}}} ``` ```{=latex} \def\ervp{{\textnormal{p}}} ``` ```{=latex} \def\ervq{{\textnormal{q}}} ``` ```{=latex} \def\ervr{{\textnormal{r}}} ``` ```{=latex} \def\ervs{{\textnormal{s}}} ``` ```{=latex} \def\ervt{{\textnormal{t}}} ``` ```{=latex} \def\ervu{{\textnormal{u}}} ``` ```{=latex} \def\ervv{{\textnormal{v}}} ``` ```{=latex} \def\ervw{{\textnormal{w}}} ``` ```{=latex} \def\ervx{{\textnormal{x}}} ``` ```{=latex} \def\ervy{{\textnormal{y}}} ``` ```{=latex} \def\ervz{{\textnormal{z}}} ``` ```{=latex} \def\rmA{{\mathbf{A}}} ``` ```{=latex} \def\rmB{{\mathbf{B}}} ``` ```{=latex} \def\rmC{{\mathbf{C}}} ``` ```{=latex} \def\rmD{{\mathbf{D}}} ``` ```{=latex} \def\rmE{{\mathbf{E}}} ``` ```{=latex} \def\rmF{{\mathbf{F}}} ``` ```{=latex} \def\rmG{{\mathbf{G}}} ``` ```{=latex} \def\rmH{{\mathbf{H}}} ``` ```{=latex} \def\rmI{{\mathbf{I}}} ``` ```{=latex} \def\rmJ{{\mathbf{J}}} ``` ```{=latex} \def\rmK{{\mathbf{K}}} ``` ```{=latex} \def\rmL{{\mathbf{L}}} ``` ```{=latex} \def\rmM{{\mathbf{M}}} ``` ```{=latex} \def\rmN{{\mathbf{N}}} ``` ```{=latex} \def\rmO{{\mathbf{O}}} ``` ```{=latex} \def\rmP{{\mathbf{P}}} ``` ```{=latex} \def\rmQ{{\mathbf{Q}}} ``` ```{=latex} \def\rmR{{\mathbf{R}}} ``` ```{=latex} \def\rmS{{\mathbf{S}}} ``` ```{=latex} \def\rmT{{\mathbf{T}}} ``` ```{=latex} \def\rmU{{\mathbf{U}}} ``` ```{=latex} \def\rmV{{\mathbf{V}}} ``` ```{=latex} \def\rmW{{\mathbf{W}}} ``` ```{=latex} \def\rmX{{\mathbf{X}}} ``` ```{=latex} \def\rmY{{\mathbf{Y}}} ``` ```{=latex} \def\rmZ{{\mathbf{Z}}} ``` ```{=latex} \def\ermA{{\textnormal{A}}} ``` ```{=latex} \def\ermB{{\textnormal{B}}} ``` ```{=latex} \def\ermC{{\textnormal{C}}} ``` ```{=latex} \def\ermD{{\textnormal{D}}} ``` ```{=latex} \def\ermE{{\textnormal{E}}} ``` ```{=latex} \def\ermF{{\textnormal{F}}} ``` ```{=latex} \def\ermG{{\textnormal{G}}} ``` ```{=latex} \def\ermH{{\textnormal{H}}} ``` ```{=latex} \def\ermI{{\textnormal{I}}} ``` ```{=latex} \def\ermJ{{\textnormal{J}}} ``` ```{=latex} \def\ermK{{\textnormal{K}}} ``` ```{=latex} \def\ermL{{\textnormal{L}}} ``` ```{=latex} \def\ermM{{\textnormal{M}}} ``` ```{=latex} \def\ermN{{\textnormal{N}}} ``` ```{=latex} \def\ermO{{\textnormal{O}}} ``` ```{=latex} \def\ermP{{\textnormal{P}}} ``` ```{=latex} \def\ermQ{{\textnormal{Q}}} ``` ```{=latex} \def\ermR{{\textnormal{R}}} ``` ```{=latex} \def\ermS{{\textnormal{S}}} ``` ```{=latex} \def\ermT{{\textnormal{T}}} ``` ```{=latex} \def\ermU{{\textnormal{U}}} ``` ```{=latex} \def\ermV{{\textnormal{V}}} ``` ```{=latex} \def\ermW{{\textnormal{W}}} ``` ```{=latex} \def\ermX{{\textnormal{X}}} ``` ```{=latex} \def\ermY{{\textnormal{Y}}} ``` ```{=latex} \def\ermZ{{\textnormal{Z}}} ``` ```{=latex} \def\vzero{{\bm{0}}} ``` ```{=latex} \def\vone{{\bm{1}}} ``` ```{=latex} \def\vmu{{\bm{\mu}}} ``` ```{=latex} \def\vtheta{{\bm{\theta}}} ``` ```{=latex} \def\va{{\bm{a}}} ``` ```{=latex} \def\vb{{\bm{b}}} ``` ```{=latex} \def\vc{{\bm{c}}} ``` ```{=latex} \def\vd{{\bm{d}}} ``` ```{=latex} \def\ve{{\bm{e}}} ``` ```{=latex} \def\vf{{\bm{f}}} ``` ```{=latex} \def\vg{{\bm{g}}} ``` ```{=latex} \def\vh{{\bm{h}}} ``` ```{=latex} \def\vi{{\bm{i}}} ``` ```{=latex} \def\vj{{\bm{j}}} ``` ```{=latex} \def\vk{{\bm{k}}} ``` ```{=latex} \def\vl{{\bm{l}}} ``` ```{=latex} \def\vm{{\bm{m}}} ``` ```{=latex} \def\vn{{\bm{n}}} ``` ```{=latex} \def\vo{{\bm{o}}} ``` ```{=latex} \def\vp{{\bm{p}}} ``` ```{=latex} \def\vq{{\bm{q}}} ``` ```{=latex} \def\vr{{\bm{r}}} ``` ```{=latex} \def\vs{{\bm{s}}} ``` ```{=latex} \def\vt{{\bm{t}}} ``` ```{=latex} \def\vu{{\bm{u}}} ``` ```{=latex} \def\vv{{\bm{v}}} ``` ```{=latex} \def\vw{{\bm{w}}} ``` ```{=latex} \def\vx{{\bm{x}}} ``` ```{=latex} \def\vy{{\bm{y}}} ``` ```{=latex} \def\vz{{\bm{z}}} ``` ```{=latex} \def\evalpha{{\alpha}} ``` ```{=latex} \def\evbeta{{\beta}} ``` ```{=latex} \def\evepsilon{{\epsilon}} ``` ```{=latex} \def\evlambda{{\lambda}} ``` ```{=latex} \def\evomega{{\omega}} ``` ```{=latex} \def\evmu{{\mu}} ``` ```{=latex} \def\evpsi{{\psi}} ``` ```{=latex} \def\evsigma{{\sigma}} ``` ```{=latex} \def\evtheta{{\theta}} ``` ```{=latex} \def\eva{{a}} ``` ```{=latex} \def\evb{{b}} ``` ```{=latex} \def\evc{{c}} ``` ```{=latex} \def\evd{{d}} ``` ```{=latex} \def\eve{{e}} ``` ```{=latex} \def\evf{{f}} ``` ```{=latex} \def\evg{{g}} ``` ```{=latex} \def\evh{{h}} ``` ```{=latex} \def\evi{{i}} ``` ```{=latex} \def\evj{{j}} ``` ```{=latex} \def\evk{{k}} ``` ```{=latex} \def\evl{{l}} ``` ```{=latex} \def\evm{{m}} ``` ```{=latex} \def\evn{{n}} ``` ```{=latex} \def\evo{{o}} ``` ```{=latex} \def\evp{{p}} ``` ```{=latex} \def\evq{{q}} ``` ```{=latex} \def\evr{{r}} ``` ```{=latex} \def\evs{{s}} ``` ```{=latex} \def\evt{{t}} ``` ```{=latex} \def\evu{{u}} ``` ```{=latex} \def\evv{{v}} ``` ```{=latex} \def\evw{{w}} ``` ```{=latex} \def\evx{{x}} ``` ```{=latex} \def\evy{{y}} ``` ```{=latex} \def\evz{{z}} ``` ```{=latex} \def\mA{{\bm{A}}} ``` ```{=latex} \def\mB{{\bm{B}}} ``` ```{=latex} \def\mC{{\bm{C}}} ``` ```{=latex} \def\mD{{\bm{D}}} ``` ```{=latex} \def\mE{{\bm{E}}} ``` ```{=latex} \def\mF{{\bm{F}}} ``` ```{=latex} \def\mG{{\bm{G}}} ``` ```{=latex} \def\mH{{\bm{H}}} ``` ```{=latex} \def\mI{{\bm{I}}} ``` ```{=latex} \def\mJ{{\bm{J}}} ``` ```{=latex} \def\mK{{\bm{K}}} ``` ```{=latex} \def\mL{{\bm{L}}} ``` ```{=latex} \def\mM{{\bm{M}}} ``` ```{=latex} \def\mN{{\bm{N}}} ``` ```{=latex} \def\mO{{\bm{O}}} ``` ```{=latex} \def\mP{{\bm{P}}} ``` ```{=latex} \def\mQ{{\bm{Q}}} ``` ```{=latex} \def\mR{{\bm{R}}} ``` ```{=latex} \def\mS{{\bm{S}}} ``` ```{=latex} \def\mT{{\bm{T}}} ``` ```{=latex} \def\mU{{\bm{U}}} ``` ```{=latex} \def\mV{{\bm{V}}} ``` ```{=latex} \def\mW{{\bm{W}}} ``` ```{=latex} \def\mX{{\bm{X}}} ``` ```{=latex} \def\mY{{\bm{Y}}} ``` ```{=latex} \def\mZ{{\bm{Z}}} ``` ```{=latex} \def\mBeta{{\bm{\beta}}} ``` ```{=latex} \def\mPhi{{\bm{\Phi}}} ``` ```{=latex} \def\mLambda{{\bm{\Lambda}}} ``` ```{=latex} \def\mSigma{{\bm{\Sigma}}} ``` ```{=latex} \newcommand{\tens}[1]{\bm{\mathsfit{#1}}} ``` ```{=latex} \def\tA{{\tens{A}}} ``` ```{=latex} \def\tB{{\tens{B}}} ``` ```{=latex} \def\tC{{\tens{C}}} ``` ```{=latex} \def\tD{{\tens{D}}} ``` ```{=latex} \def\tE{{\tens{E}}} ``` ```{=latex} \def\tF{{\tens{F}}} ``` ```{=latex} \def\tG{{\tens{G}}} ``` ```{=latex} \def\tH{{\tens{H}}} ``` ```{=latex} \def\tI{{\tens{I}}} ``` ```{=latex} \def\tJ{{\tens{J}}} ``` ```{=latex} \def\tK{{\tens{K}}} ``` ```{=latex} \def\tL{{\tens{L}}} ``` ```{=latex} \def\tM{{\tens{M}}} ``` ```{=latex} \def\tN{{\tens{N}}} ``` ```{=latex} \def\tO{{\tens{O}}} ``` ```{=latex} \def\tP{{\tens{P}}} ``` ```{=latex} \def\tQ{{\tens{Q}}} ``` ```{=latex} \def\tR{{\tens{R}}} ``` ```{=latex} \def\tS{{\tens{S}}} ``` ```{=latex} \def\tT{{\tens{T}}} ``` ```{=latex} \def\tU{{\tens{U}}} ``` ```{=latex} \def\tV{{\tens{V}}} ``` ```{=latex} \def\tW{{\tens{W}}} ``` ```{=latex} \def\tX{{\tens{X}}} ``` ```{=latex} \def\tY{{\tens{Y}}} ``` ```{=latex} \def\tZ{{\tens{Z}}} ``` ```{=latex} \def\gA{{\mathcal{A}}} ``` ```{=latex} \def\gB{{\mathcal{B}}} ``` ```{=latex} \def\gC{{\mathcal{C}}} ``` ```{=latex} \def\gD{{\mathcal{D}}} ``` ```{=latex} \def\gE{{\mathcal{E}}} ``` ```{=latex} \def\gF{{\mathcal{F}}} ``` ```{=latex} \def\gG{{\mathcal{G}}} ``` ```{=latex} \def\gH{{\mathcal{H}}} ``` ```{=latex} \def\gI{{\mathcal{I}}} ``` ```{=latex} \def\gJ{{\mathcal{J}}} ``` ```{=latex} \def\gK{{\mathcal{K}}} ``` ```{=latex} \def\gL{{\mathcal{L}}} ``` ```{=latex} \def\gM{{\mathcal{M}}} ``` ```{=latex} \def\gN{{\mathcal{N}}} ``` ```{=latex} \def\gO{{\mathcal{O}}} ``` ```{=latex} \def\gP{{\mathcal{P}}} ``` ```{=latex} \def\gQ{{\mathcal{Q}}} ``` ```{=latex} \def\gR{{\mathcal{R}}} ``` ```{=latex} \def\gS{{\mathcal{S}}} ``` ```{=latex} \def\gT{{\mathcal{T}}} ``` ```{=latex} \def\gU{{\mathcal{U}}} ``` ```{=latex} \def\gV{{\mathcal{V}}} ``` ```{=latex} \def\gW{{\mathcal{W}}} ``` ```{=latex} \def\gX{{\mathcal{X}}} ``` ```{=latex} \def\gY{{\mathcal{Y}}} ``` ```{=latex} \def\gZ{{\mathcal{Z}}} ``` ```{=latex} \def\sA{{\mathbb{A}}} ``` ```{=latex} \def\sB{{\mathbb{B}}} ``` ```{=latex} \def\sC{{\mathbb{C}}} ``` ```{=latex} \def\sD{{\mathbb{D}}} ``` ```{=latex} \def\sF{{\mathbb{F}}} ``` ```{=latex} \def\sG{{\mathbb{G}}} ``` ```{=latex} \def\sH{{\mathbb{H}}} ``` ```{=latex} \def\sI{{\mathbb{I}}} ``` ```{=latex} \def\sJ{{\mathbb{J}}} ``` ```{=latex} \def\sK{{\mathbb{K}}} ``` ```{=latex} \def\sL{{\mathbb{L}}} ``` ```{=latex} \def\sM{{\mathbb{M}}} ``` ```{=latex} \def\sN{{\mathbb{N}}} ``` ```{=latex} \def\sO{{\mathbb{O}}} ``` ```{=latex} \def\sP{{\mathbb{P}}} ``` ```{=latex} \def\sQ{{\mathbb{Q}}} ``` ```{=latex} \def\sR{{\mathbb{R}}} ``` ```{=latex} \def\sS{{\mathbb{S}}} ``` ```{=latex} \def\sT{{\mathbb{T}}} ``` ```{=latex} \def\sU{{\mathbb{U}}} ``` ```{=latex} \def\sV{{\mathbb{V}}} ``` ```{=latex} \def\sW{{\mathbb{W}}} ``` ```{=latex} \def\sX{{\mathbb{X}}} ``` ```{=latex} \def\sY{{\mathbb{Y}}} ``` ```{=latex} \def\sZ{{\mathbb{Z}}} ``` ```{=latex} \def\emLambda{{\Lambda}} ``` ```{=latex} \def\emA{{A}} ``` ```{=latex} \def\emB{{B}} ``` ```{=latex} \def\emC{{C}} ``` ```{=latex} \def\emD{{D}} ``` ```{=latex} \def\emE{{E}} ``` ```{=latex} \def\emF{{F}} ``` ```{=latex} \def\emG{{G}} ``` ```{=latex} \def\emH{{H}} ``` ```{=latex} \def\emI{{I}} ``` ```{=latex} \def\emJ{{J}} ``` ```{=latex} \def\emK{{K}} ``` ```{=latex} \def\emL{{L}} ``` ```{=latex} \def\emM{{M}} ``` ```{=latex} \def\emN{{N}} ``` ```{=latex} \def\emO{{O}} ``` ```{=latex} \def\emP{{P}} ``` ```{=latex} \def\emQ{{Q}} ``` ```{=latex} \def\emR{{R}} ``` ```{=latex} \def\emS{{S}} ``` ```{=latex} \def\emT{{T}} ``` ```{=latex} \def\emU{{U}} ``` ```{=latex} \def\emV{{V}} ``` ```{=latex} \def\emW{{W}} ``` ```{=latex} \def\emX{{X}} ``` ```{=latex} \def\emY{{Y}} ``` ```{=latex} \def\emZ{{Z}} ``` ```{=latex} \def\emSigma{{\Sigma}} ``` ```{=latex} \newcommand{\etens}[1]{\mathsfit{#1}} ``` ```{=latex} \def\etLambda{{\etens{\Lambda}}} ``` ```{=latex} \def\etA{{\etens{A}}} ``` ```{=latex} \def\etB{{\etens{B}}} ``` ```{=latex} \def\etC{{\etens{C}}} ``` ```{=latex} \def\etD{{\etens{D}}} ``` ```{=latex} \def\etE{{\etens{E}}} ``` ```{=latex} \def\etF{{\etens{F}}} ``` ```{=latex} \def\etG{{\etens{G}}} ``` ```{=latex} \def\etH{{\etens{H}}} ``` ```{=latex} \def\etI{{\etens{I}}} ``` ```{=latex} \def\etJ{{\etens{J}}} ``` ```{=latex} \def\etK{{\etens{K}}} ``` ```{=latex} \def\etL{{\etens{L}}} ``` ```{=latex} \def\etM{{\etens{M}}} ``` ```{=latex} \def\etN{{\etens{N}}} ``` ```{=latex} \def\etO{{\etens{O}}} ``` ```{=latex} \def\etP{{\etens{P}}} ``` ```{=latex} \def\etQ{{\etens{Q}}} ``` ```{=latex} \def\etR{{\etens{R}}} ``` ```{=latex} \def\etS{{\etens{S}}} ``` ```{=latex} \def\etT{{\etens{T}}} ``` ```{=latex} \def\etU{{\etens{U}}} ``` ```{=latex} \def\etV{{\etens{V}}} ``` ```{=latex} \def\etW{{\etens{W}}} ``` ```{=latex} \def\etX{{\etens{X}}} ``` ```{=latex} \def\etY{{\etens{Y}}} ``` ```{=latex} \def\etZ{{\etens{Z}}} ``` ```{=latex} \newcommand{\pdata}{p_{\rm{data}}} ``` ```{=latex} \newcommand{\ptrain}{\hat{p}_{\rm{data}}} ``` ```{=latex} \newcommand{\Ptrain}{\hat{P}_{\rm{data}}} ``` ```{=latex} \newcommand{\pmodel}{p_{\rm{model}}} ``` ```{=latex} \newcommand{\Pmodel}{P_{\rm{model}}} ``` ```{=latex} \newcommand{\ptildemodel}{\tilde{p}_{\rm{model}}} ``` ```{=latex} \newcommand{\pencode}{p_{\rm{encoder}}} ``` ```{=latex} \newcommand{\pdecode}{p_{\rm{decoder}}} ``` ```{=latex} \newcommand{\precons}{p_{\rm{reconstruct}}} ``` ```{=latex} \newcommand{\laplace}{\mathrm{Laplace}} ``` ```{=latex} \newcommand{\E}{\mathbb{E}} ``` ```{=latex} \newcommand{\Ls}{\mathcal{L}} ``` ```{=latex} \newcommand{\R}{\mathbb{R}} ``` ```{=latex} \newcommand{\emp}{\tilde{p}} ``` ```{=latex} \newcommand{\lr}{\alpha} ``` ```{=latex} \newcommand{\reg}{\lambda} ``` ```{=latex} \newcommand{\rect}{\mathrm{rectifier}} ``` ```{=latex} \newcommand{\softmax}{\mathrm{softmax}} ``` ```{=latex} \newcommand{\sigmoid}{\sigma} ``` ```{=latex} \newcommand{\softplus}{\zeta} ``` ```{=latex} \newcommand{\KL}{D_{\mathrm{KL}}} ``` ```{=latex} \newcommand{\Var}{\mathrm{Var}} ``` ```{=latex} \newcommand{\standarderror}{\mathrm{SE}} ``` ```{=latex} \newcommand{\Cov}{\mathrm{Cov}} ``` ```{=latex} \newcommand{\normlzero}{L^0} ``` ```{=latex} \newcommand{\normlone}{L^1} ``` ```{=latex} \newcommand{\normltwo}{L^2} ``` ```{=latex} \newcommand{\normlp}{L^p} ``` ```{=latex} \newcommand{\normmax}{L^\infty} ``` ```{=latex} \newcommand{\parents}{Pa} ``` ```{=latex} \newcommand{\enc}{\text{enc}_\theta} ``` ```{=latex} \newcommand{\pred}{p_\theta} ``` ```{=latex} \DeclareMathOperator*{\argmax}{arg\,max} ``` ```{=latex} \DeclareMathOperator*{\argmin}{arg\,min} ``` ```{=latex} \DeclareMathOperator{\sign}{sign} ``` ```{=latex} \DeclareMathOperator{\Tr}{Tr} ``` ```{=latex} \let\ab\allowbreak ``` ```{=latex} \newcommand{\up}[1]{\scriptsize \textcolor[HTML]{1F77B4}{$\uparrow$~#1}} ``` ```{=latex} \newcommand{\down}[1]{\scriptsize \textcolor[HTML]{D62728}{$\downarrow$~#1}} ``` ```{=latex} \newcommand{\best}[1]{\scriptsize \textcolor[HTML]{0565a8}{\textbf{$\uparrow$~#1}}} ``` ```{=latex} \twocolumn[ \icmltitle{Latent Actions from Factorized Transition Effects under Agent Ambiguity} % It is OKAY to include author information, even for blind % submissions: the style file will automatically remove it for you % unless you've provided the [accepted] option to the icml2025 % package. % List of affiliations: The first argument should be a (short) % identifier you will use later to specify author affiliations % Academic affiliations should list Department, University, City, Region, Country % Industry affiliations should list Company, City, Region, Country % You can specify symbols, otherwise they are numbered in order. % Ideally, you should not use this facility. Affiliations will be numbered % in order of appearance and this is the preferred way. % in order of appearance and this is the preferred way. \icmlsetsymbol{equal}{*} \begin{icmlauthorlist} \icmlauthor{Heejeong Nam}{brown} \icmlauthor{Chandradithya S Jonnalagadda}{brown} \icmlauthor{Harshit Aggarwal}{brown} \icmlauthor{Eric Xu}{brown} \icmlauthor{Randall Balestriero}{brown} \end{icmlauthorlist} {\href{https://hazel-heejeong-nam.github.io/LAM/}{https://hazel-heejeong-nam.github.io/LAM/}} \icmlaffiliation{brown}{Brown University} \icmlcorrespondingauthor{Heejeong Nam}{heejeong\_nam@brown.edu} % You may provide any keywords that you % find helpful for describing your paper; these are used to populate % the "keywords" metadata in the PDF but will not be shown in the document \icmlkeywords{Machine Learning, ICML} \vskip 0.3in ] ``` `\printAffiliationsAndNotice{}`{=latex} # Introduction World models [@wm] for planning and control have been evaluated in settings where the actor and the action space are known, such as a robotic manipulator [@hansen2024tdmpc; @hafner2025mastering]. In this regime, the model predicts the next state from the current state, and can therefore, separate the controlled source of variation from autonomous background dynamics or moving distractors at least implicitly. ![ Motivation for agent ambiguity in observation-only latent action learning. Unlike action-conditioned world models, which receive the actor and action as part of the input, LAMs infer action-like latents only from visual transitions. ](figs/teaser.png){#fig:teaser width="\\textwidth"} Recently, motivated by the fact that most online videos do not provide frame-level action labels or proprioceptive signals, Latent Action Models (LAMs) [@lapo; @lapa] have been proposed to learn action-like proxies directly from observation transitions. A typical LAM encodes an observation pair $(x_t, x_{t+1})$ into a latent action and uses it to predict $x_{t+1}$ from $x_t$. This formulation is appealing because it removes the need for action annotations, but it also changes what the model can identify. However, a LAM does not observe pure actions themselves. It observes the visual effects that actions, dynamics, rendering, and other transition sources produce. This distinction is often hidden in controlled settings where the agent is visually dominant and non-agent elements are static [@pmlr-v100-yu20a; @robomimic2021]. In more general scenes, however, a single transition may mix agent motion with passive objects, articulated parts, camera/background dynamics, and distractors [@laom; @flam; @segmentlam; @oclam]. From the model's perspective, all of these changes arrive through the same channel: the pixels at time $t$ and $t+1$. Without additional supervision or inductive biases, the model has no direct basis for deciding which observed changes should be attributed to the controlled agent, or which changes should be selected as relevant to the desired action abstraction, as depicted in Figure `\ref{fig:teaser}`{=latex}. A natural response to this ambiguity is to treat it as an object selection problem [@flam; @segmentlam; @oclam], identifying the controllable entity in order to learn its latent action. However, relying on segmentation or object-centric priors limits scalability and imposes rigid assumptions. More importantly, objects are not always the appropriate unit of abstraction, as motion effects can manifest within, across, or independently of strict object boundaries. Recognizing these limitations, we step back from the standard operational view of LAMs as simple transition bottlenecks [@lapo] and ask what can be identified from observation-only transitions, and what latent actions should represent under agent ambiguity. We interpret the pathway from action to observation at three levels as in Figure `\ref{fig:3step}`{=latex}: the true underlying action induces a physical or environment state change, which then produces visual transition effects in observation space. Under observation-only learning, the most reliable target is not necessarily the true action itself, but the structure of these observed transition effects. We therefore take a bottom-up approach to latent action learning under ambiguity. We first introduce **Observed Transition Factorization (OTF)**, which represents each transition as a sparse composition of reusable observed-transition primitives. Rather than compressing all changes into a monolithic embedding, OTF decomposes the transition into localized observed effects using a compositional VQ-style codebook. The resulting representation records which transition effects occur and where they are expressed. Using this factorized transition interface, we instantiate **OTF-LAM**, which forms state-aware action-like latents within the standard inverse--forward dynamics framework. A frozen OTF module first extracts reusable observed-transition primitives, and a state-aware aggregator abstracts these primitives into a compact latent action for prediction. We also introduce **OTF-LAM-Dino**, a decoder-free variant that predicts future states in a frozen DINO representation space, combining a reusable transition vocabulary with a reusable visual state representation. Empirically, OTF primitives transfer zero-shot across held-out visual carriers and cross-morphology shifts on Moving MNIST [@movingmnist] and DCS [@dcs], indicating reusable transition structure rather than environment- or embodiment-specific templates. For downstream control, we map learned latent actions to true actions using a small action-labeled dataset. The resulting latent action interfaces match or outperform LAM baselines under complex transition ambiguity, demonstrating the effectiveness of factorized observed transitions for policy learning. OTF-LAM-Dino further improves over decoder-based OTF-LAM, showing that reusable transition vocabularies complement frozen visual state representations. # From Actions to Observed Effects {#sec:comp} LAMs trained from observation-only transitions do not recover actions directly, but representations of their visible consequences after being mediated by state, embodiment, dynamics, and rendering. As a result, the learned latent space is not necessarily action-equivalent. ## The Forward Generative Chain ![ From causal generation to inverse inference. Blue arrows denote the causal pathway from action to visual change, while red arrows denote the inverse problem faced by observation-only latent action learning. ](figs/3step_cropped.png){#fig:3step width="\\textwidth"} We view a transition as a chain of three stages: $$\underbrace{a_t, \xi_t}_{\text{trainsition sources}} \;\xrightarrow{F_{\mathcal{E}}}\; \underbrace{\Delta s_t}_{\text{physical state change}} \;\xrightarrow{R_{\mathcal{E}}}\; \underbrace{\Delta x_t}_{\text{visual transition effect}}$$ as in Figure `\ref{fig:3step}`{=latex}. Here, $a_t$ denotes the controlled action, while $\xi_t$ denotes uncontrolled transition sources such as camera motion, distractor motion, background dynamics, or passive environment changes. The environment $\mathcal{E}$ includes the embodiment, dynamics, camera, and other environment-specific factors. Let $F{\mathcal{E}}$ be the state transition function and $R_{\mathcal{E}}$ be the observation or rendering map. The physical state change may be written as $$\Delta s_t = F_{\mathcal{E}}(s_t,a_t,\xi_t),$$ while the visual transition effect may be written as $$\Delta x_t = R_{\mathcal{E}}(s_t,\Delta s_t,\xi_t).$$ Equivalently, the observed transition is generated by the composition $$\label{eq:transition} \Delta x_t = R_{\mathcal{E}} \bigl( s_t, F_{\mathcal{E}}(s_t,a_t,\xi_t), \xi_t \bigr).$$ ```{=latex} \begin{empheqboxed} \looseness=-1 \textbf{Intuition.} This setup clarifies why a latent action cannot generally recover the true action. The observed transition is generated by Eq.~\ref{eq:transition}. For fixed observations, the map from $a_t$ to $\Delta x_t$ is generally not injective, and $\Delta x_t$ may also contain changes not caused by $a_t$ at all. Therefore, an observation-trained latent action can at best identify an equivalence class of causes and observed effects. \end{empheqboxed} ``` ## Observed Effects as a Transferable Intermediate Actions and physical state changes are often environment-specific. Actions depend on the control interface, such as torques, joint commands, or button inputs, while physical changes depend on state, embodiment, contact, and dynamics. Thus, neither level provides an obvious reusable primitive across heterogeneous embodiments. Observed visual effects provide a weaker but more transferable abstraction. They describe how change appears in observation space, such as local displacement, edge shifts, rotation-like residuals, contact deformation, or background drift. For instance, $$\texttt{Mario moves right} \qquad \texttt{Kirby moves right}$$ may correspond to different bodies, controls, and dynamics, yet both can induce similar rightward displacement patterns in the observation space. This motivates using observed effects as the intermediate target for latent action learning, rather than requiring the representation to immediately identify the controlled source. # From Observed Effects to Latent Actions Latent action learning can be viewed as an inverse problem of the causal process: construct latent actions from observations. Unlike a standard LAM [@lapo] learning $z_t = q(x_t,x_{t+1})$ directly, we decompose the inverse pathway into observed-transition factorization followed by state-aware abstraction: $$\label{eq:overview} E_t = q_\phi(x_t,x_{t+1}), \qquad \textrm{and} \qquad z_t^{\mathrm{act}} = h_\psi(E_t,x_t),$$ where $E_t$ denotes a structured set of observed-transition factors, and $z_t^{\mathrm{act}}$ is the compact latent action used for prediction. Our framework is trained in two stages. In Sec.`\ref{sec:stage1}`{=latex}, we pretrain the Observed-Transition Factorizer $q_\phi$ with a motion-space autoencoding objective. In Sec.`\ref{sec:stage2}`{=latex}, we freeze $q_\phi$ and train OTF-LAM on top of the extracted factors. ## Observed Transition Factorization (OTF) {#sec:stage1} ![ Observed-transition vocabulary learning with a VQ-VAE. Motion-centered transition inputs are patchified, quantized into a shared codebook of reusable observed-transition primitives, and decoded with reference-frame conditioning to reconstruct the observed-transition. ](figs/stage1.png){#fig:stage1 width="\\textwidth"} We construct the motion input $o_t$ as a frame-level transition signal over a temporal stride $\tau$, chosen to emphasize observable change while reducing dependence on RGB appearance, object identity, and environment-specific semantics. Unless otherwise specified, we construct $o_t$ by applying a gradient transform to both frames and subtracting the transformed current frame from the transformed future frame. The vocabulary stage does not infer latent actions or assign changes to action-level causes. It instead learns a shared codebook of $K$ reusable observed-transition primitives for representing $o_t$, capturing recurring visual change patterns such as local displacement, edge shifts, rotation-like residuals, contact deformation, background drift, or articulated part motion. ```{=latex} \begin{figure*}[t!] \includegraphics[width=\textwidth]{figs/stage2.pdf} \caption{ \textbf{Latent-action learning on top of the pretrained observed-transition vocabulary.} Given the extracted observed-transition factors \(E_t\) and the current frame \(x_t\), the model builds state-aware factor tokens, scores them with a relevance gate, aggregates the selected factors into a compact action-like latent \(z_t^{\mathrm{act}}\), and uses a reference-conditioned decoder to predict the next observation.} \label{fig:stage2} \end{figure*} ``` **Patchwise vector quantization.** Given $o_t \in \mathbb{R}^{C \times H \times W}$, we partition it into $P$ non-overlapping spatial patches and encode each patch with a shallow MLP into a token $f_{t,i} \in \mathbb{R}^D$. Each token is then assigned to its nearest codebook entry using top-1 nearest-neighbor quantization $$\label{eq:quantization} k^*_{t,i} = \arg\min_{k \in \{1,\dots,K\}} \|f_{t,i} - c^{(k)}\|_2^2, \quad q_{t,i} = c^{(k^*_{t,i})}.$$ Note that this quantization should be interpreted as discretizing local observed effects rather than pure motion like optical flow. Even when $o_t$ suppresses object-level semantics, patch tokens may retain carrier-specific cues such as texture, contrast, local geometry, and occlusion. ```{=latex} \begin{empheqboxed} \looseness=-1 \textbf{Intuition.} Patch size controls the locality of the observed-transition primitives. Smaller patches reduce appearance and object-identity leakage, but may not contain enough context to infer a stable motion effect. Larger patches provide richer motion evidence, but can mix multiple transition sources and become tied to local carrier appearance. A more detailed discussion is provided in Appendix~\ref{app:patch_size_tradeoff}. \end{empheqboxed} ``` From the patch-level assignments, we derive for each code $k$ an occupancy map $M_t^{(k)}$, denoting the spatial support or occupancy of code $k$ in the transition, and an activation strength $w_t^{(k)}$. Together these form the transition $$\label{eq:stage1return} E_t = \left\{ e_{t,k} \right\}_{k=1}^{K}, \quad e_{t,k} = \bigl(c^{(k)}, M_t^{(k)}, w_t^{(k)}\bigr).$$ Thus, $E_t$ records which observed-transition primitives are active in an observation transition, where they appear, and how strongly they are expressed, without yet determining which of them are action-relevant. In later stages, this observed-transition vocabulary can be compressed or selected into action-like latents for downstream LAM training. **Training.** Our training scheme follows Figure `\ref{fig:stage1}`{=latex}. We instantiate the observed-transition factorizer as a VQ-VAE trained to reconstruct the motion observation $o_t$ rather than the future RGB frame. Each transition factor $e_{t,k}\in E_t$ contains the information associated with code $k$. We map each active factor to an aggregated factor embedding $$h_{t,k} = \rho_\eta(e_{t,k})$$, where $\rho_\eta$ is a small shared network and $k$ indexes a code observed in the current transition. Let $\mathcal{I}_t$ denote the set of active codes. The resulting set of factor embeddings is $$H_t^{\mathrm{set}} = \{h_{t,k}\}_{k \in \mathcal{I}_t}.$$ To preserve spatial support, we place these embeddings back onto the patch grid using the occupancy maps $$H_t(u,v) = \sum_{k=1}^{K} M_t^{(k)}(u,v)\,h_{t,k}.$$ The decoder then combines the spatial factor map $H_t$ with the current frame $x_t$, which provides appearance and support information, to reconstruct the motion observation $$\hat{o}_t = D_{\eta}(H_t, x_t).$$ This encourages the codebook to represent local transition effects rather than object-specific appearance templates. OTF is trained with a motion reconstruction objective, standard VQ losses, and an orthogonality regularizer: $$\begin{aligned} \mathcal{L}_{\mathrm{vocab}} &= \mathcal{L}_{\mathrm{rec}} + \lambda_{\mathrm{1}}\mathcal{L}_{\mathrm{code}} + \lambda_{\mathrm{2}}\mathcal{L}_{\mathrm{commit}} + \lambda_{\mathrm{3}}\mathcal{L}_{\mathrm{orth}}, \end{aligned}$$ where $$\begin{aligned} \mathcal{L}_{\mathrm{rec}} &= \|\hat{o}_t - o_t\|_2^2, \quad \\ \mathcal{L}_{\mathrm{code}} &= \sum_{i=1}^{P} \left\| \operatorname{sg}(f_{t,i}) - q_{t,i} \right\|_2^2 \\ \mathcal{L}_{\mathrm{commit}} &= \sum_{i=1}^{P} \left\| f_{t,i} - \operatorname{sg}(q_{t,i}) \right\|_2^2, \\ \mathcal{L}_{\mathrm{orth}} &= \sum_{\substack{k,k' \in \mathcal{I}_t \\ k \neq k'}} \left( \hat{\mathbf{c}}^{(k)\top} \hat{\mathbf{c}}^{(k')} \right)^2. \end{aligned}$$ Details of architecture and training schemes are provided in Appendix `\ref{app:stage1_details}`{=latex}. ```{=latex} \remark[\textbf{Local Quantization vs. Discrete Latent Actions.}]{ Recent work~\cite{garrido} suggests that using vector quantization as the final latent action bottleneck can be too restrictive for complex in-the-wild videos. OTF uses quantization differently. The codebook represents local observed-transition primitives, while the final action-like latent is obtained by aggregating these primitives into a continuous representation. Thus, the discrete bottleneck is used to structure reusable local effects, not to represent the full action as a single code. } ``` ## OTF-LAM {#sec:stage2} After learning the OTF module, we freeze the factorizer and train a LAM on the extracted factor set $E_t$, as shown in Fig. `\ref{fig:stage2}`{=latex}. Our goal is to learn an action-like latent $$z_t^{\mathrm{act}} = h_\psi(E_t,x_t)$$ by selecting or compressing observed-transition factors for next-frame prediction. **Action abstraction.** We first convert each factor in $E_t$ into a state-aware factor token $$r_{t,k} = \Gamma_\theta(c^{(k)},M_t^{(k)},w_t^{(k)},x_t),$$ where $\Gamma_\theta$ embeds the code identity, occupancy, activation strength, and current-frame context. A gate network then assigns each factor a relevance weight $\alpha_{t,k} = \sigma\!\left(g_\theta(r_{t,k})\right) \in [0,1],$ with inactive codes masked out. The factor-level latent is obtained by a normalized gated average $$z_t^{\mathrm{fac}} = \frac{ \sum_{k=1}^{K}\alpha_{t,k} r_{t,k} }{ \sum_{k=1}^{K}\alpha_{t,k}+\epsilon }.$$ Finally, a linear projection produces the action-like latent $z_t^{\mathrm{act}} = P_\theta(z_t^{\mathrm{fac}}).$ This module does not assume that the factorizer has identified the controlled agent. It only learns which observed-transition factors are useful for forming a compact latent for prediction. **Forward dynamics.** We predict the next observation from the current frame and the latent action $$\hat{x}_{t+\tau} = p_\theta(x_t,z_t^{\mathrm{act}}).$$ Features from $x_t$ provide appearance and layout information, while $z_t^{\mathrm{act}}$ modulates the decoder to provide transition information. The decoder may predict either the next frame directly or a residual update to the current frame, we use residual prediction by default. **Training.** A full latent action model is trained with a next-frame prediction loss $$\mathcal{L}_{\mathrm{OTF-LAM}} = \left\| \hat{x}_{t+\tau}-x_{t+\tau} \right\|_2^2.$$ The observed-transition vocabulary encoder and codebook remain frozen, and gradients are applied only to the action abstraction module and the forward dynamics model. Architectural details of the factor token construction, gating network, and decoder are provided in Appendix `\ref{app:stage2_details}`{=latex}. ## OTF-LAM-Dino ![OTF-LAM-Dino uses frozen DINOv2 as an encoder and frozen OTF module as a motion primitive extractor.](figs/dinolam_cropped.png){#fig:dinolam width="\\textwidth"} We explore a decoder-free JEPA-style variant, OTF-LAM-Dino. As described in Figure `\ref{fig:dinolam}`{=latex}, we map both the current and future observations into a latent representation space using a frozen DINOv2 encoder [@dinov2], and train the model to predict the future representation with $z_t^{\mathrm{act}}$ similar as OTF-LAM. OTF-LAM separates reusable transition primitives from the image decoder, but the decoder itself can still become environment-specific. OTF-LAM-Dino pushes this separation further by replacing pixel-space prediction with prediction in a frozen DINOv2 representation space. In this variant, both the observed-transition vocabulary and the visual state encoder are fixed and reusable, leaving the learned model to focus on abstracting transition information into $z_t^{\mathrm{act}}$ and predicting its effect in representation space. OTF-LAM appears architecturally similar to the concurrent work TDV [@tdv], the two methods are fundamentally different in purpose: TDV aims to learn a strong encoder, or scene representation, whereas our goal is to learn latent actions. Appendix `\ref{app:dinolam}`{=latex} describes details of OTF-LAM-Dino architecture and training objective. ## Policy Learning with Latent Actions ![ **Policy Training.** The latent motion space is distilled into a policy via behavioral cloning (left). An action decoder then maps these primitives to ground-truth actions $a_t$, utilizing the pixel frame to associate motions with specific objects (right). ](figs/policy_training2.png){#fig:policy width="\\textwidth"} The final step is to connect the learned latent action space back to real actions. Since the visual transition alone is not invertible to the true action, we use a small amount of action supervision to resolve this inverse ambiguity. As described in Figure `\ref{fig:policy}`{=latex}, we first distill the learned latent action space into a policy $\pi(z_t^{\mathrm{act}}\mid x_t)$ via behavioral cloning. We then train an action decoder on a small action-labeled dataset to map the predicted latent action to the true environment action. The decoder also receives the current observation $x_t$, allowing it to associate latent motion with the relevant object or state context. In our experiments, this supervised stage uses 32 action-labeled trajectories for `cheetah-run` and `walker-run` from DCS [@dcs]. # Experiments ## Dataset We mainly evaluate our method on the Distracting Control Suite (DCS) [@dcs], where we focus on `cheetah-run` and `walker-run` environment, which combine articulated embodied motion with complex visual distractors in the background. This dataset is challenging because the visual transition contains both agent-induced motion and distractor-induced changes, making it a natural testbed for evaluating whether a latent action model can separate reusable transition structure from environment-specific visual variation. Trajectories are collected using the pretrained expert policies from @laom. For each environment, we collect $2000$ trajectories, corresponding to roughly $2$M transitions. We use $1000$ trajectories to train the latent action models, and reserve the remaining trajectories for downstream training and evaluation. #### Moving MNIST [@movingmnist]. We further introduce controlled Moving MNIST benchmark, where digit identity and observed-transition primitive can be independently specified. This setting serves as a clean diagnostic environment for testing whether the learned codebook captures reusable motion/effect primitives rather than digit-specific visual templates. In particular, we use held-out digit classes to evaluate transfer across visual carriers while keeping the underlying observed-transition primitives shared. We construct a training set of 3,000 sequences containing digits from $\{0,1,2,3,4\}$ and a test set of 300 sequences containing digits from $\{5,6,7,8,9\}$. ## Baseline Latent Action Models We evaluate three existing LAM baselines and two OTF-LAM-specific variants. The OTF-LAM-specific variants are designed to isolate the contributions of motion processing and patchwise latent quantization. - **LAPO** [@lapo]: A standard monolithic latent action model with inverse dynamics model (IDM) and forward dynamics model (FDM). - **FLAM** [@flam]: A factorized latent action baseline that decomposes scene dynamics into separate factors, addressing the limitations of a single monolithic latent action. We train two different models with differnt number of slots (4 and 8). - **HiLAM** [@hilam]: A hierarchical latent action baseline that uses a pretrained low-level LAM to extract latent action and aggregates them into higher-level latent skills. - **Motion-LAPO**: a LAPO variant that receives motion inputs together with pixel frames, isolating the effect of explicit motion processing. - **F-LAPO**: a LAPO variant with an OTF-LAM-like patch encoder and patchwise quantization, isolating the effect of patch-level latent quantization. ## Reusability of Latent Action Primitives {#sec:learned_vocab} In this section, we evaluate the observed-transition primitives learned by the pretrained OTF tokenizer. A useful motion vocabulary should transfer across visual carriers and embodied morphologies, rather than overfitting to a single agent. To test this, the vocabulary is trained on `walker-run` and applied zero-shot to `cheetah-run` environment, with the codebook kept fixed. We also conduct a similar transfer study on Moving MNIST [@movingmnist], trained on digits `0,1,2,3,4` and evaluated zero-shot on held-out digits `5,6,7,8,9` with the same observed-transition primitives. To evaluate transferability, we compare against a monolithic VQ-VAE that encodes each transition into a single global latent bottleneck with a comparable latent budget. We additionally vary the motion input $o_t$ used for vocabulary learning. In particular, we compare grayscale frames with a Sobel transform against our default gradient-based transform. Details of the motion input construction are provided in Appendix `\ref{app:motion}`{=latex}. ![ Example of learned OTF codes assigned to the motion input. More visualization results are in Appendix `\ref{app:otfvis}`{=latex} ](figs/example_cropped.png){#fig:example width="\\textwidth"} ![ Cross-morphology transfer in DCS using only the pretrained observed-transition factorizer. The vocabulary is trained on `walker-run` and evaluated zero-shot on `cheetah-run`. ](figs/dcs_transfer.png){#fig:dcs_transfer width="\\textwidth"} ![ Controlled carrier transfer on Moving MNIST. ](figs/mnist_transfer.png){#fig:mnist_transfer width="\\textwidth"} ```{=latex} \begin{figure*}[t] \includegraphics[width=\textwidth]{figs/res_final_cropped.pdf} \caption{ (a) Bar chart comparing the relative mean return of latent action model variants on the DCS \texttt{cheetah-run} downstream policy evaluation task. (b) Downstream evaluation of OTF-LAM with different motion vocabulary sizes. Error bar is computed as the RMS of standard deviations per seed. } \label{fig:combined_result} \end{figure*} ``` #### Results on transferability. `\ttabbox[] { \tabcolsep=0.17cm \renewcommand{\arraystretch}{0.8} \small \caption{ Quantitative evaluation of cross-morphology zero-shot transfer degradation in DCS environments under different motion inputs and frame-level transforms. Motion inputs are described in Appendix~\ref{app:motion}. } \label{tab:transfer} \begin{tabular}{@{}lllccc@{}} \toprule \footnotesize & \textbf{Motion Input} & \textbf{MSE} & \multirow{2}{*}{\textbf{Drop (\%)}} \\ \cmidrule(lr){2-5} & type & transform & train & transfered & \\ \midrule OTF & acc. & gradient & 0.142 & 0.171 & 20.49\% \\ & & sobel & 0.088 & 0.107 & 20.98\% \\ \cmidrule(l){2-6} & vel. & gradient & 0.037 & 0.055 & 49.34\% \\ & & sobel & 0.024 & 0.036 & 51.58\% \\ \midrule monolithic & acc. & gradient & 0.172 & 0.271 & 58.18\% \\ & & sobel & 0.120 & 0.196 & 64.06\% \\ \cmidrule(l){2-6} & vel. & gradient & 0.048 & 0.080 & 64.78\% \\ & & sobel & 0.034 & 0.058 & 71.60\% \\ \bottomrule \end{tabular} }`{=latex} We provide qualitative and quantitative results on transferability. Figure `\ref{fig:dcs_transfer}`{=latex} shows that OTF reconstructs motion signals under a test-time embodiment shift across different DCS environments, and Figure `\ref{fig:mnist_transfer}`{=latex} shows results on controlled carrier transfer on Moving MNIST dataset. Larger versions of these figures are provided in Appendix. From the reconstructed motion signals, we observe that OTF remains better aligned with the target transition. Note this difference can be visually subtle, since the reference and future frames are often close in pixel space. A model that copies the reference frame may therefore look plausible, even when it fails to incorporate the actual future transition. For this reason, the reconstructions should be compared against whether they reflect the target motion, not only whether they preserve a sharp reference appearance. The monolithic VQ-VAE baseline often shows this failure mode, producing reconstructions closer to the reference frame than to the future frame. This suggests that its latent bottleneck entangles appearance or morphology-specific structure with motion information and falls back toward the static reference appearance under transfer. By contrast, OTF maintains a more usable reconstruction of the observed motion, indicating that its codebook captures observed-transition primitives that are not tied to a single digit class or embodiment. Quantitatively, we measure the relative transfer degradation from the source to the target $\mathrm{Drop} = \frac{ \mathcal{E}_{\mathrm{target}} - \mathcal{E}_{\mathrm{source}} }{ \mathcal{E}_{\mathrm{source}} },$ where $\mathcal{E}_{\mathrm{source}}$ and $\mathcal{E}_{\mathrm{target}}$ denote reconstruction error on the training and transfer sets, respectively. A smaller drop indicates better reusability. As shown in Table `\ref{tab:transfer}`{=latex}, the OTF vocabulary shows substantially smaller degradation than the monolithic global embedding with the same input type and transform. These results indicate that the factorized codebook is less sensitive to the morphology shift, while the global monolithic bottleneck more strongly entangles motion reconstruction with source-domain visual structure. ## Policy Learning Results In Figure `\ref{fig:combined_result}`{=latex} (a), we report the mean and standard deviation of downstream returns. For each seed, the policy is evaluated over $10$ trajectories, and each model is run with three seeds. The performance of OTF-LAM and OTF-LAM-Dino is reported using the best-performing $K$. The results highlight three observations. First, OTF-LAM and OTF-LAM-Dino remain competitive with, and in some cases outperform, monolithic LAM baselines, despite using a reusable latent action interface, or even reusable visual encoder. Second, these results support our hypothesis that factorizing observed transitions can provide a useful latent action interface under distractor-induced ambiguity, while also showing that explicit scene-level factorization remains a strong advantage when available. Third, OTF-LAM-Dino improves the mean return over decoder-based OTF-LAM in both environments. A possible explanation for the stronger performance of OTF-LAM-Dino is that it changes the prediction target rather than simply changing the encoder. Decoder-based OTF-LAM is trained to predict future pixels, which can pressure the latent action and forward model to account for texture, background motion, lighting, and other environment-specific details. OTF-LAM-Dino instead predicts future states in a frozen DINO representation space, where many of these pixel-level nuisance factors are suppressed while control-relevant state information is preserved. In this sense, the frozen representation may act as a regularizer, encouraging action aggregator to encode transition structure that is useful for control rather than appearance variation that is useful for reconstruction. ```{=latex} \remark[\textbf{Toward reusable latent action models.}]{ DINO-WM~\cite{dinowm} suggests that a frozen visual representation can provide an effective state space for planning and control across environments. OTF-LAM-Dino applies this premise to observation-only latent action learning by fixing the visual prediction space and learning the action-conditioning variable from unlabeled transitions. The results indicate that this provides a viable latent-action interface, while identifying the learned aggregator and predictor as the remaining sources of environment dependence. The observed-transition vocabulary may transfer across visual carriers and morphologies, while the action aggregator and predictor remain learned components that can still absorb environment-specific regularities. This suggests a broader direction for pushing the generalization boundary of latent action models under minimal assumptions about the actor, action space, and environment.} ``` #### Effect of Motion Vocabulary Size. We study how the size of the motion primitives affects downstream policy performance. Figure `\ref{fig:combined_result}`{=latex} (b) reports evaluation returns for OTF-LAM and OTF-LAM-Dino with different codebook sizes $K$ on `cheetah-run` and `walker-run`, averaged over $3$ seeds, where each seed evaluates $10$ trajectories. For decoder-based OTF-LAM, `cheetah-run` performance improves consistently as $K$ increases. This suggests that a larger vocabulary provides a more expressive set of transition primitives for this environment. On `walker-run`, however, performance is relatively stable across codebook sizes, with all variants achieving similar returns, indicating that the required transition structure in `walker-run` is captured even by smaller vocabularies, or that downstream control is less sensitive to additional motion primitives in this setting. OTF-LAM-DINO shows a different pattern. It improves over decoder-based OTF-LAM for every tested $K$ in both environments, suggesting that prediction in a frozen DINO representation space provides a useful downstream interface for the learned latent actions. However, its performance is not monotonic in $K$. Overall, codebook size should be viewed as an environment- and architecture-dependent capacity parameter rather than a monotonic source of improvement. A more systematic study of how vocabulary size interacts with motion complexity, representation-space prediction, and downstream control remains future work. # Related Works #### Factorized Motion and observed-transition Representations. Recent works feature video autoencoding methods to learn decoupled representations that can separate temporal motion from spatial information, which can be used for video reconstruction and generation [@ava; @decovae; @hivae]. However, their primary objective is video reconstruction or generation and not the decomposition of multiple simultaneously moving sources into an abstraction for action-relevant factors. Other prior works have approached motion factorization through independent motion segmentation where the goal is to identify parts of a scene that move as either coherent or separately moving components [@segmotion; @eventbasedsegmotion; @guesswhatmoves]. @partmotion further show that motion structure can exist below the object level through dynamic-static disentanglement to separate independently moving parts from static geometry. Our focus is not on 3D reconstruction, but instead to learn reusable observed-transition primitives, which capture localized patterns of visual change caused by motions. #### Latent Action Learning and Distractors. LAPO [@lapo] introduced this action-free learning framework for control from videos, while LAPA [@lapa] scaled this idea by pretraining latent actions from large video datasets for VLA modeling. However, these models compress each transition into a single compact latent action. This can perform well in controlled settings where the agent is the main source of change, but becomes ambiguous in scenes with distractors where background/camera motion or other exogenous motions may be entangled with the latent action [@laom; @dcs]. @laom shows that latent action learning can degrade under distractors, and that limited action supervision can improve performance. Other methods improve robustness by constraining or focusing the visual transition: LAOF [@laof] uses optical-flow constraints, @oclam uses object-centric scene decomposition, and @segmentlam uses pretrained segmentation masks to suppress background distractors. Recent work also studies latent action world models in more diverse in-the-wild videos [@wild]. In contrast, we factorize the observed transition into multiple motion-effect factors and learn to gate them with current-frame context. Several recent methods introduce structured latent action spaces. AC-LAM [@ac-lam] uses additive component vectors, FLAM [@flam] decomposes dynamics into entity-level IDM/FDM modules, and LPWM [@lpwm] models object-centric stochastic dynamics with particle-level latents. Our work instead factorizes transitions through patch-level activations of a shared observed-transition codebook. #### Compositional and Quantized Latent Representations. VQ-VAE introduced learned discrete codebooks as reusable latent units, and LAPA uses a VQ-VAE-style objective to learn discrete latent actions from transitions [@vqvae; @lapa]. Compositional VQ-VAE-style representations have also been used to decompose complex human motion into reusable discrete components, for example in speech-driven holistic 3D motion generation [@yi2023generatingholistic3dhuman] and music-conditioned dance video generation [@chen2025xdancerexpressivemusichuman]. Product quantization has also been used to learn compact discrete representations in visual and multimodal domains [@ma2024nymeriamassivecollectionmultimodal; @elnouby2023imagecompressionproductquantized]. A complementary line of work studies compositionality through object-centric representations, where objects or slots serve as the basic units of decomposition [@slotattention; @cjepa; @dlp]. In contrast, we build on the idea that codebooks can provide reusable components. This provides a compositional latent interface alternative to compact latent actions, where individual codes can be analyzed through their localized effects on the reconstructed transition. # Conclusion We presented OTF-LAM, a bottom-up approach to latent action learning under agent ambiguity. Since observation transitions are visual effects rather than actions themselves, a monolithic latent action can entangle controllable motion with distractors, camera dynamics, and other spurious transition sources. OTF addresses this by factorizing transitions into reusable observed-transition primitives before composing them into state-aware action-like latents. Our motion primitives transfer across held-out carriers and morphology shifts, and the resulting latent action model, OTF-LAM, support downstream policy learning in the conventional inverse--forward dynamics framework. OTF-LAM-Dino further shows that this interface can be paired with a frozen DINO representation space, improving over pixel-space prediction. These results support factorized observed effects as a useful intermediate representation for observation-only latent action learning. This work evaluates the approach on controlled settings and DCS distractor environments. Extending it to richer video-game domains, such as Mario-like environments with scrolling cameras, enemies, particles, and diverse non-agent dynamics, remains future work. # Acknowledgement {#acknowledgement .unnumbered} We thank Chen Sun and Dan Haramati for helpful and meaningful discussions. ```{=latex} \bibliographystyle{icml2026} ``` ```{=latex} \newpage ``` ```{=latex} \appendix ``` ```{=latex} \onecolumn ``` ```{=latex} \setcounter{figure}{0} ``` ```{=latex} \setcounter{table}{0} ``` ```{=latex} \renewcommand{\thefigure}{A\arabic{figure}} ``` ```{=latex} \renewcommand{\thetable}{A\arabic{table}} ``` # OTF Implementation Detail {#app:stage1_details} #### Encoder. The input is a motion observation $o_t \in \mathbb{R}^{C \times H \times W}$. The encoder partitions $o_t$ into non-overlapping spatial patches and embeds each patch independently using a lightweight MLP patch encoder. We concatenate normalized spatial coordinates to each flattened patch representation before the MLP, so that the encoder has access to coarse patch location. The output is a grid of latent patch embeddings $\{f_{t,i}\}_{i=1}^{P}$, where each embedding corresponds to a local transition region. #### Local code assignment. Each patch embedding is discretized using a learned codebook $\mathcal{C}=\{c^{(1)},\dots,c^{(K)}\}$, where patch $i$ is assigned to its nearest codebook entry. To stabilize training, we use a short warmup phase in which quantization is disabled and the model behaves as a continuous autoencoder. After warmup, the codebook is initialized with $k$-means clustering over encoder patch embeddings collected from the training data, and discrete quantization is enabled. #### Decoder input construction. For each code $k$, we compute an occupancy map $M_t^{(k)}$ indicating which patches are assigned to the code, and a normalized usage weight $w_t^{(k)}$ equal to the fraction of assigned patches. Together, these define the observed-transition factor $e_{t,k}=(c^{(k)},M_t^{(k)},w_t^{(k)})$. Each factor is mapped to a descriptor $h_{t,k}=\rho_\eta(e_{t,k})$ using a shared MLP. The descriptors are then placed back onto the patch grid using the occupancy maps $$H_t(u,v)=\sum_{k=1}^{K}M_t^{(k)}(u,v)h_{t,k}.$$ #### Decoder. The decoder reconstructs the motion observation from the spatial feature map $H_t$. It uses a convolutional decoding network with bilinear upsampling to produce an output at the original resolution. A separate convolutional encoder extracts spatial context features from the current frame $x_t$, and these features are combined with $H_t$ before decoding. The reference pathway provides appearance and support information, while the codebook pathway provides the factorized transition information. #### Training. The objective combines a reconstruction loss with the standard VQ-VAE [@vqvae] codebook, commitment, and orthogonal losses $$\mathcal{L} = \mathcal{L}_{\mathrm{rec}} + \lambda_{\mathrm{code}}\mathcal{L}_{\mathrm{code}} + \lambda_{\mathrm{commit}}\mathcal{L}_{\mathrm{commit}} + \lambda_{\mathrm{orth}}\mathcal{L}_{\mathrm{orth}}.$$ The codebook is updated by exponential moving average updates, where orthogonality primarily serves as a diagnostic for codebook diversity. To reduce code collapse, rarely used codebook entries are periodically reinitialized using randomly sampled encoder embeddings. We train with AdamW [@loshchilov2018decoupled] and gradient clipping. All OTF tokenizers are trained for $10$ epochs, with batch size 512, learning rate 1e-4, codebook vector dimension 32. For all DCS [@dcs] environment, we use gradient transform to each frame and subtract each other to construct motion input. # OTF-LAM Implementation Detail {#app:stage2_details} Let $B$ denote the batch size, $K$ the number of VQ codes, $(h,w)$ the VQ-VAE patch grid, $C$ the number of image channels, and $(H,W)$ the image resolution. For convenience, we denote the stacked occupancy maps by $O_t \in \mathbb{R}^{B \times K \times h \times w},$ where $O_{t,k}=M_t^{(k)}$ is the occupancy map of code $k$. ## Encoders #### State Encoder The state encoder extracts a spatial representation of the current observation conditioned on the observed-transition usage pattern. It takes the current frame $x_t \in \mathbb{R}^{B \times C \times H \times W}$ and the code usage vector $w_t \in \mathbb{R}^{B \times K}$ after projected into a compact conditioning vector $c^{\mathrm{occ}}_t = W_{\mathrm{occ}} w_t$. The image branch is a convolutional encoder with strided downsampling and residual blocks. Rather than concatenating the code usage vector to the image, we use $c^{\mathrm{occ}}_t$ to modulate intermediate visual features through FiLM conditioning [@perez2018film] after each encoder stage. This allows the encoder to produce state features that are aware of the active observed-transition vocabulary while preserving the spatial structure of the current frame. The encoder outputs a spatial state feature map $$s_t \in \mathbb{R}^{B \times d_s \times h \times w}.$$ When necessary, a $1\times1$ projection adjusts the channel dimension to $d_s$, and bilinear interpolation is used to match the target spatial resolution $(h,w)$. We also compute a global state summary by spatial average pooling $\bar{s}_t = \frac{1}{hw}\sum_{i,j} s_{t,:,i,j}.$ The spatial feature map $s_t$ is used by the decoder to preserve layout information, while the pooled feature $\bar{s}_t$ provides a compact state representation for later conditioning modules. #### Occupancy Encoder The occupancy encoder converts the spatial support of each observed-transition code into a compact representation. Given the occupancy maps $O_t$, the encoder processes each code occupancy map independently and produces $u_t \in \mathbb{R}^{B \times K \times d_o}.$ Each vector $u_{t,k}$ summarizes where code $k$ is active in the current transition. By default, we use an MLP occupancy encoder. For each code $k$, the corresponding occupancy map is flattened and passed through a small network $$u_{t,k} = f_{\mathrm{occ}}(O_{t,k};\bar{s}_t),$$ where $\bar{s}_t$ is the global state feature from the state encoder. We condition the hidden representation on $\bar{s}_t$ using FiLM, allowing the same occupancy pattern to be interpreted in the context of the current frame. This yields a compact state-aware embedding of each code's spatial support. ## Action Aggregator We first get $e_{t,k}=(c^{(k)},M_t^{(k)},w_t^{(k)})$ from OTF module. We map this descriptor to a factor token $$r_{t,k} = f_{\mathrm{fac}}(e_{t,k};\bar{s}_t,M_t^{(k)}),$$ where the embedding network is conditioned on the global state feature $\bar{s}_t$ and the occupancy embedding $M_t^{(k)}$ using FiLM. This conditioning allows the same codebook primitive to be interpreted differently depending on the current visual state and its spatial support. We then calculate occupancy-pooled local state. For code $k$, we compute this vector by occupancy-weighted average pooling over the spatial state feature map $$\ell_{t,k} = \frac{\sum_{i,j} O_{t,k,i,j} s_{t,:,i,j}} {\max(\sum_{i,j} O_{t,k,i,j}, \epsilon)}.$$ Now we summarize information. For each code $k$, the gate network takes the factor token, local state summary, and global state summary $g^{\mathrm{in}}_{t,k} = [r_{t,k},\ \ell_{t,k},\ \bar{s}_t].$ The gate network $G_\theta$ maps each factor representation to a scalar logit, which is converted into a continuous gating weight with a sigmoid activation $$\alpha_{t,k} = \sigma(G_\theta(g^{\mathrm{in}}_{t,k};c^{\mathrm{gate}}_{t,k})) \in [0,1],$$ where $c^{\mathrm{gate}}_{t,k}=[\bar{s}_t,u_{t,k}]$ is for FiLM-conditioning. Codes with zero occupancy are masked out before aggregation. Finally, the model forms a factor-level latent by a normalized gated average over factor tokens $$z^{\mathrm{fac}}_t = \frac{\sum_{k=1}^{K} \alpha_{t,k} r_{t,k}} {\max(\sum_{k=1}^{K} \alpha_{t,k}, \epsilon)},$$ and the final action-like latent is obtained by a projection $$z_t^{\mathrm{act}} = P_\theta(z_t^{\mathrm{fac}}).$$ The projection is the identity when the factor-token dimension already matches the desired latent dimension; otherwise, it is a linear layer. ## Decoder The decoder predicts the next observation from the current-state features and the selected latent action. It receives the spatial state feature map $s_t$ from the state encoder and the latent action $z_t^{\mathrm{act}}$, and produces a residual update added to the current frame. To preserve spatial structure, we first project $z_t^{\mathrm{act}}$ into a low-resolution spatial grid $$z_t^{\mathrm{grid}} \in \mathbb{R}^{B \times d_g \times h \times w}.$$ This grid is concatenated with the state feature map $s_t$, allowing the decoder to combine the current visual layout with the transition information encoded in the latent action. The concatenated representation is then processed by a convolutional decoder with progressive upsampling. The latent action also modulates the decoder features through FiLM conditioning. After each upsampling stage, channel-wise scale and shift parameters are predicted from $z_t^{\mathrm{act}}$ and applied to the intermediate feature map $$a \leftarrow (1+\gamma(z_t^{\mathrm{act}}))\odot a + \beta(z_t^{\mathrm{act}}).$$ This gives the latent action a direct mechanism for controlling the predicted transition while the spatial state features preserve appearance and layout. # OTF-LAM-DINO Implementation Detail {#app:dinolam} Here we describe a decoder-free variant, OTF-LAM-DINO, which replaces pixel-space prediction with prediction in a frozen visual representation space. The purpose of this variant is to test whether the latent action learned from observed-transition primitives can also condition a JEPA-style latent dynamics model, and furthur maintain downstream performance with frozen DINOv2 [@dinov2] encoder. We use the same pretrained OTF module as OTF-LAM. #### Latent visual state. Given an observation $x_t$, we encode it with a frozen DINOv2 encoder: $$S_t = \mathrm{DINO}(x_t), \qquad S_{t+\tau} = \mathrm{sg}(\mathrm{DINO}(x_{t+\tau})),$$ where $S_t$ denotes the patch-token representation and $\mathrm{sg}(\cdot)$ stops gradients through the future target. The DINO encoder is kept fixed throughout training. Thus, unlike the main OTF-LAM model, both the state representation and the prediction target are defined by a reusable pretrained visual encoder. #### Latent action. Following OTF module described in Appendix `\ref{app:stage1_details}`{=latex}, we first get the set of assigned code for each patch, $C_t$. An action abstraction module first abstract local transition primitives, conditioned on the current DINO state: $$u_i = \phi([S_t^{(i)}, C_t^{(i)}, p_i])$$ where $p_t$ is learnable positional encoding. Next, since our state encoder is frozen DINO encoder, we need stronger aggregator compared to OTF-LAM. Here we pool four action tokens with Cross Attention, then feed that into small Transformer (depth=2) with query residual. $$A_t = \mathrm{Transformer} \left( Q + \mathrm{CrossAttn}(Q, U_t, U_t) \right),$$$$z_t^{\mathrm{act}} = \phi_{\mathrm{out}}(\mathrm{Flatten}(A_t)).$$ The default action embedding dimension is 256 and $\phi$ is a linear layer with layernorm. #### Forward dynamics. Instead of reconstructing the future frame, OTF-LAM-DINO predicts the future DINO representation: $$\hat{S}_{t+\tau}= P_\theta(S_t,z_t^{\mathrm{act}}).$$ The latent action token is injected into the predictor at multiple layers, to prevent model ignoring it after the input layer. #### Training objective. The model is trained with a latent prediction loss in frozen DINO feature space: $$\mathcal{L}_{\mathrm{OTF\text{-}LAM\text{-}DINO}}= \left| \hat{S}_{t+\tau}- S_{t+\tau} \right|_2^2.$$ #### Discussion. OTF-LAM-DINO follows the same latent action principle as OTF-LAM, but evaluates it in a different prediction space. The decoder-based model asks whether $z_t^{\mathrm{act}}$ can support future observation reconstruction, while OTF-LAM-DINO asks whether the same type of latent action can support future prediction in a reusable representation space. This variant is therefore complementary to the main model: it removes the pixel decoder, but still relies on the OTF vocabulary to construct the latent action from local observed-transition primitives. # Additional Visualizations {#app:additional_visualizations} ## Motion-Centered Transition Inputs {#app:motion} To learn reusable observed-transition primitives effectively, the input should reduce semantic appearance information present in RGB frames while preserving the visual evidence of motion. We therefore consider several simple motion-centered input spaces. Specifically, we construct motion inputs by combining two temporal difference operators, which define the order of motion, with three frame-level transforms, which change the visual carrier through which motion is represented. Let $\phi$ denote a transformation applied independently to each frame. For first-order velocity inputs, we define $$o_t^{\mathrm{vel},\phi} = \phi(x_{t+\tau})-\phi(x_t).$$ For second-order acceleration inputs, we define $$o_t^{\mathrm{acc},\phi} = \phi(x_{t+\tau}) - 2\phi(x_t) + \phi(x_{t-\tau}).$$ In all cases, the transform is applied before temporal differencing. We evaluate choices of $\phi$: Sobel [@Sobel1990AnI3] features after grayscale transformation, and image-gradient features. Sobel and gradient transforms emphasize edge changes and local directional variation, respectively. Figure `\ref{fig:motion}`{=latex} shows examples. ```{=latex} \begin{figure*}[h] \includegraphics[width=0.7\textwidth]{figs/motionsample.png} \caption{ Examples of motion-centered inputs produced by different frame-level transforms: Sobel, gradient, and none (identity). } \label{fig:motion} \end{figure*} ``` ## Visualized Examples of OTF Module {#app:otfvis} ```{=latex} \begin{figure*}[h!] \includegraphics[width=\textwidth]{figs/codebook.png} \caption{ Visualization of the learned codebook of observed-transition primitives on controlled Moving MNIST. Each point denotes one learned codebook vector, and the two-dimensional coordinates are obtained by applying t-SNE~\cite{tsne} to the code embeddings. } \label{fig:codebook} \end{figure*} ``` We provide additional qualitative visualizations of the learned observed-transition vocabulary. #### Distracting Control Suite [@dcs]. We train the observed-transition factorizer using the Sobel-transformed velocity input. Similarly to the Moving MNIST visualization, Fig. `\ref{fig:codebook}`{=latex}(b) shows the learned codebook after training the observed-transition factorizer on DCS samples. Fig. `\ref{fig:code_eg2}`{=latex} shows example assignments on individual `walker-run` transitions, including the current frame, the motion-centered input, the local patch embeddings, and the assigned codebook entries. ```{=latex} \begin{figure*}[h!] \includegraphics[width=0.8\textwidth]{figs/code_eg_dcs.png} \caption{ Example code assignments for walker-run transitions from Distracting Control Suite. } \label{fig:code_eg2} \end{figure*} ``` ```{=latex} \begin{figure*}[h!] \includegraphics[width=\textwidth]{figs/mnist_transfer.png} \caption{Zero-shot transfer experiment results on MovingMNIST.} \label{fig:app_mnist} \end{figure*} ``` ```{=latex} \begin{figure*}[h!] \includegraphics[width=\textwidth]{figs/dcs_transfer.png} \caption{Enlarged version of Fig.~\ref{fig:dcs_transfer} for readability.} \label{fig:app_dcs} \end{figure*} ``` #### MovingMNIST [@movingmnist]. We train the observed-transition factorizer using the Sobel-transformed acceleration input. To make the motion signal more pronounced, we use a temporal stride of two frames when constructing the transition input. Fig. `\ref{fig:codebook}`{=latex} (a) visualizes the learned codebook after training the factorizer described in Sec. `\ref{sec:stage1}`{=latex}. This visualization provides a qualitative view of how the discrete observed-transition primitives are organized in the learned vocabulary. Fig. `\ref{fig:code_eg}`{=latex} shows example assignments on individual Moving MNIST samples. For each sample, we visualize the current frame, the motion-centered input, the t-SNE [@tsne] projection of patch embeddings, and the corresponding assigned codebook entries on the patch grid or assigned observed-transition primitives on the patch grid. These examples illustrate how local transition patterns are mapped to discrete codebook primitives across different spatial regions. Then we use Moving MNIST [@movingmnist] as a controlled diagnostic for motion reusability. The VQ-VAE factorizer is trained on digits `{0,1,2,3,4}` and evaluated on held-out digits `{5,6,7,8,9}`, while the set of observed-transition primitives is shared across the two splits. Figure `\ref{fig:app_mnist}`{=latex} shows result. ```{=latex} \begin{figure*}[h!] \includegraphics[width=0.8\textwidth]{figs/code_eg_mnist.png} \caption{ Example code assignments for controlled Moving MNIST transitions. } \label{fig:code_eg} \end{figure*} ``` # Observed Motion Signals and Patch Scale {#app:observed_motion_patch_scale} ## Observed Motion Signals Are Not Pure Motion {#app:observed_motion_not_pure} The motion input used in this work is computed from image observations, for example by first- or second-order temporal differencing. Although this suppresses static appearance, it does not expose physical motion directly. A pixel-level velocity or acceleration signal is an *observed effect* of motion through the local visual content of the scene. More formally, let $m_{t,p} \in \mathcal{M}$ denote the underlying local motion effect at patch $p$, such as translation, rotation, deformation, or camera-induced displacement. Let $\xi_{t,p} \in \Xi$ denote the local visual carrier through which this motion is observed. This carrier may include local texture, contrast, edge orientation, color, depth discontinuities, occlusion boundaries, or other patch-level appearance statistics. The observed motion signal $y_{t,p}$ is then better understood as $$y_{t,p} = \Psi(m_{t,p}, \xi_{t,p}),$$ for some image-formation-dependent map $\Psi$, rather than as a direct observation of $m_{t,p}$ alone. Thus, the codebook should not be interpreted as spanning the space of physical observed-transition primitives $\mathcal{M}$ in isolation. It is better viewed as learning from the space of observed motion effects $$\mathcal{Y} = \{\Psi(m,\xi) : m \in \mathcal{M}, \xi \in \Xi\}.$$ This distinction is important for interpreting the learned codes. For example, the same rightward displacement can produce different observed signals depending on whether it occurs on a vertical edge, a textured background, a uniform region, or an articulated limb boundary. Conversely, patches with different appearance may still activate similar codes when their local transition patterns are sufficiently similar. Therefore, our codes should not be interpreted as pure geometric motion variables. They are more accurately viewed as reusable *observed-transition primitives*: local transition patterns that combine motion with the visual carrier through which that motion becomes visible. This interpretation also clarifies the role of the reference-frame conditioning branch. The codebook is encouraged to represent transition effects, while the reference frame provides complementary static support information such as object shape and local appearance. In this sense, the method does not attempt to remove the visual carrier entirely. Rather, it limits the carrier information available to each local patch and avoids forcing the codebook to encode full object identity. ## Patch Size and the Motion--Carrier Trade-off {#app:patch_size_tradeoff} Patch size controls the granularity at which observed transition effects are quantized. It therefore determines an important trade-off between motion locality and carrier ambiguity. If patches are too small, each token contains only a limited visual neighborhood. This reduces leakage from object identity or large-scale appearance, but it can make local motion difficult to infer. Small patches are more sensitive to noise, texture aliasing, and the aperture problem [@detopt; @iterative]: a short edge fragment may not contain enough information to distinguish translation, rotation, or deformation. In such cases, the codebook may learn overly local residual patterns rather than stable motion-effect primitives. If patches are too large, each token contains richer spatial context and may provide more reliable evidence for local motion. However, larger patches are also more likely to contain multiple motion sources, object-part identity, texture statistics, or foreground-background boundaries. As a result, the learned codes may become more appearance- or part-specific, approaching object-conditioned transition templates rather than reusable observed-transition primitives. In this regime, the effective code space may expand from a compact motion-effect basis toward a larger product space of motion and local carrier factors. The desired patch scale is therefore task-dependent. A useful patch should be large enough to contain sufficient local structure for estimating a dominant transition effect, but small enough to avoid mixing multiple independent motion sources or encoding full object identity. In our setting, patchification is intended to preserve a direct local correspondence between the observed motion field and the latent code assignment. The patch size should therefore be interpreted as a design choice that controls the locality of the learned observed-transition primitives. # Training Details {#app:training_details} #### OTF and LAPO family OTF-LAM, LAPO, and LAPO variants are trained for $20$k steps, while OTF-LAM-DINO is trained for $10$k steps. #### FLAM [@flam] For FLAM, we use $d_{\mathrm{model}}=256$, $2$ transformer blocks, and $z$ channels of size $128$. We evaluate $4$ and $8$ slots. The action codebook uses $16$ codes per factor, with the VAE-VQ KL weight annealed from $0$ to $2\times10^{-4}$. We use sub-trajectory length $10$, history length $1$, and $5$ prediction steps. The tokenizer uses an IMPALA encoder, a LAPO decoder, image size $64$, an FSQ quantizer with codebook size $1024$, levels $(4,4,4,4,4)$, $128$ latent channels, and codebook dimension $128$. FLAM is trained for $10$ epochs with batch size $32$, learning rate $10^{-4}$, weight decay $0$, and gradient norm clipping at $1.0$. We use xFormers attention, frame skip $1$, HDF5 datasets, and seed $42$. #### HiLAM [@hilam] For HiLAM, we train for $50$k steps with learning rate $10^{-4}$ and latent action dimension $64$. #### Downstream For downstream policy learning, the OTF-LAM and baselines (FLAM, HiLAM, LAPO, and LAPO variants) behavior cloning policy is trained for $10$ epochs, and action decoder is trained for 10k steps. For OTF-LAM-DINO, policy is trained for $5$ epochs, and 5k steps for action decoder training # Full Results `\ttabbox[] { \tabcolsep=0.7cm \renewcommand{\arraystretch}{1} \small \caption{ Mean and std of average return across 10 trajectories over 3 random seeds. } \label{tab:full_baseline} \begin{tabular}{@{}lcccc@{}} \toprule \textbf{Model} & \textbf{Cheetah-Run} & \textbf{Walker-Run} \\ \cmidrule(l){2-5} & Mean & Std. & Mean & Std. \\ \midrule FLAM (4)~\cite{flam} & 41.58 & 28.48 & 27.61 & 7.22 \\ \midrule Flam (8)~\cite{flam} & 31.95 & 21.11 & 34.97 & 9.15 \\ \midrule HiLAM~\cite{hilam} & 22.64 & 12.42 & 25.12 & 5.88 \\ \midrule LAPO~\cite{lapo} & 11.48 & 7.19 & 28.71 & 7.59 \\ \midrule Motion LAPO & 9.68 & 4.18 & 23.93 & 4.40 \\ \midrule F-LAPO & 11.56 & 3.39 & 23.44 & 5.79 \\ \midrule \textbf{OTF-LAM} & 25.79 & 17.63 & 26.94 & 7.91 \\ \midrule \textbf{OTF-LAM-DINO} & 43.80 & 26.98 & 28.87 &8.23 \\ \bottomrule \end{tabular} }`{=latex} `\ttabbox[] { \tabcolsep=0.7cm \renewcommand{\arraystretch}{1} \small \caption{ Downstream evaluation of OTF-LAM and OTF-LAM-DINO with differet motion vocabulary sizes. Std. is computed as root mean square across three random seeds. } \label{tab:full_ksweep} \begin{tabular}{@{}lccccc@{}} \toprule & \multirow{2}{*}{K} & \textbf{OTF-LAM} & \textbf{OTF-LAM-DINO} \\ \cmidrule(l){3-6} & & Mean & Std. & Mean & Std. \\ \midrule \textbf{Cheetah-Run} & 16 & 10.142 & 6.574 & 40.85 & 23.69 \\ \cmidrule(l){2-6} & 32 & 13.764 & 12.272 & 43.80 & 26.98 \\ \cmidrule(l){2-6} & 64 & 19.393 & 10.503 & 33.09 & 20.46 \\ \cmidrule(l){2-6} & 128 & 25.788 & 17.664 & 42.92 & 26.01 \\ \midrule \textbf{Walker-Run} & 16 & 26.941 & 7.919 & 28.87 & 8.23 \\ \cmidrule(l){2-6} & 32 & 24.231 & 7.856 & 27.64 & 6.57 \\ \cmidrule(l){2-6} & 64 & 24.812 & 5.734 & 28.70 &7.74 \\ \cmidrule(l){2-6} & 128 & 25.019 & 6.712 & 27.65 & 8.09 \\ \bottomrule \end{tabular} }`{=latex}