RynnUnify: Towards Unified Embodied Brain

Paper: RynnUnify: Towards Unified Embodied Brain (arXiv:2610.32965v1, October 23, 2026)

Authors: Minghao Zhu, Bohan Hou, Kun Xiang, Zixuan Wang, Yinzhou Tang, Yifei Yang, Zhikai Wang, Tianyi Zhang, Kehan Li, Haoyu Zhao, Siteng Huang, Leigang Qu, Sicong Leng, Dongchi Huang, Mingxiu Chen, Shijian Lu, Yue Wang, Xiaodan Liang, Zhenyu Zeng, Deli Zhao, Chengju Liu, Jianfei Yang, Xin Li

Affiliations: DAMO Academy, Alibaba Group, and Hupan Lab

Resources: GitHub repository, project page, and the RynnUnify model collection on Hugging Face

Code status: At commit 5653a9c756f4e87533d2c2031c680d010f8eada7, the repository exposes visual-plan inference, cross-chunk timeline validation, BCPO rollout and objective code, evaluation hooks, and model entry points. Project-authored code is Apache-2.0 while the visual-planning directory retains OpenMDW-1.1; weights, datasets, and paper figures have separate terms.

Summary

RynnUnify is a 16B mixture-of-transformers that couples an 8B autoregressive reasoner with an 8B rectified-flow video generator. Four scene-memory frames and a continuous prior-video prefix make long-horizon prediction spatially and temporally coherent. BCPO then teaches the reasoner when generated evidence is worth requesting, and a world-action extension turns the generator's future-state features into 48-step robot action chunks.

The Problem: Prediction Is Useful Only When It Enters the Reasoning Loop

A robot does not need a video model merely because video looks rich. It needs a prediction that can answer a concrete question before the next action: where an object will be after a drawer opens, how a cloth will deform after a fold, or which unseen doorway will become visible after the base turns. A conventional vision-language model answers such questions from the observed image and often collapses future state into a sentence. A conventional video generator may produce a plausible sequence without exposing whether the implied transition is executable, spatially grounded, or useful to the task.

RynnUnify treats this gap as an interaction problem rather than a representation-size problem. The reasoner first decides what should happen next and describes the visual change it expects. The generator predicts that change under persistent scene references. The resulting clip becomes evidence for the next reasoning turn, and its final frame becomes the observation for the next subtask. This creates a closed loop in which language planning selects what to imagine while imagined state feeds back into language reasoning.

Long-horizon operation adds two failure modes. An object can leave the camera view even though the robot still needs its pose, and a new clip can preserve semantics while changing the identity or geometry of the scene at the boundary. RynnUnify addresses the first with sparse scene anchors and the second with a continuous latent prefix. The anchors preserve layout across clips; the prefix preserves recent motion without treating the new clip as an unrelated video.

The paper also refuses the assumption that every question benefits from generation. Generated motion can introduce incorrect geometry, latency, and a persuasive but false intermediate state. BCPO therefore learns a routing policy from paired direct and generation-assisted rollouts. The system keeps a low-cost direct path and invokes the world model only when a reward-trained reasoner expects the prediction to improve the answer.

Finally, video prediction is connected to control rather than left as an offline visualization. In the world-action model, the reasoner creates a continuous subtask latent, the generator predicts future video conditioned on it, and an action head reads the generator's internal state. This makes the future video a shared computational substrate for perception, prediction, and action.

Architecture: One Model with Two Computational Rhythms

The backbone follows the Cosmos3 mixture-of-transformers design. The reasoner is autoregressive because its job is to accumulate multimodal context and emit language tokens in sequence. The generator is a rectified-flow model because its job is to refine continuous visual latents across denoising steps. Separate Transformer parameters prevent the two objectives from being forced into one update rule, while joint attention lets the generator read representations produced by the reasoner.

Visual inputs are encoded by a causal video VAE with a spatial compression factor of 16 and a temporal compression factor of 4. Each of the four scene-memory images is encoded independently, yielding four visual-token groups. They remain separate items rather than being inserted into the target video's temporal axis. The main video occupies a fifth group, represented by noisy latents at denoising time t. The generator's condition sequence is therefore

$$ S_t=\left[S_{\mathrm{AR}};Z_{\mathrm{mem}}^{(0)};\ldots;Z_{\mathrm{mem}}^{(3)};z_t\right], $$

where $S_{\mathrm{AR}}$ contains reasoner-conditioned text tokens, $Z_{\mathrm{mem}}^{(i)}$ denotes the tokens of memory frame i, and $z_t$ is the noisy target video. Keeping memory as separate encoded items is important: an image of the original tabletop should constrain appearance and object identity, but it should not be mistaken for a frame that occurs immediately before the action.

The four anchors are selected for complementary roles. One is the persistent initial observation. Two keyframes are selected from earlier history. The fourth refers to the most recent step. If the rollout has too little history, available frames fill the slots, and at the first step the initial image is repeated. During execution the initial anchor stays fixed while the historical anchors refresh from generated video. The mixture of a stable global anchor and rolling local references is a practical compromise between forgetting the room and becoming trapped in an early wrong prediction.

Temporal continuity is handled differently. The generator receives a prefix taken from the preceding clip's tail and places it at the beginning of the main video timeline. The shared boundary frame appears once, so the model sees one contiguous sequence rather than two videos concatenated after encoding. This distinction matters because a causal VAE's latent at a boundary depends on preceding pixels. The codebase explicitly validates that a prefix of $k$ clean latents corresponds to $4k-3$ pixel frames.

Three conditioning modes reuse the same interface. Image-to-video fixes the first latent. First-and-last-frame-to-video fixes both ends and predicts the transition. Cross-chunk continuation fixes the leading prefix from an earlier clip. During training, fixed memory and conditioning tokens are excluded from the generation loss, so the model is not rewarded for copying known pixels. Only active target positions contribute to the flow-matching objective.

Figure 1. The 8B reasoner and 8B generator interact through joint attention. Four independent scene-memory items and an optional continuous prefix condition the predicted clip. Source: paper Figure 1.

flowchart TD
    A[Task instruction and current observation] --> B[8B autoregressive reasoner]
    B --> C[Next subtask, visual description, and duration]
    C --> D[Four independent scene-memory frames]
    C --> E[Continuous prefix from the previous clip]
    D --> F[8B rectified-flow generator]
    E --> F
    F --> G[Predicted future clip]
    G --> H[New final-frame observation]
    H --> B
    B --> I[BCPO direct or generation-assisted route]
    B --> J[Continuous subtask latent for control]
    J --> F
    F --> K[Future video features]
    K --> L[48 by 12 action chunk]
    L --> M[Execute the first 16 actions]

Two-Stage Pretraining: Learn the Plan, Then Learn the Consequence

The first stage trains the reasoner on interleaved embodied data. For visual planning, it receives the goal, initial and current observations, and the preceding subtask history. It predicts the next executable subtask, a detailed description of the anticipated visual evolution, and an estimated duration. These three outputs matter together: a short instruction such as "open the drawer" does not tell the generator which handle to approach, how the arm should move, or how long the interaction should last.

The reasoner is also trained on future-state questions in an interleaved format. It can request a world-modeling prompt, observe the corresponding real future video, and then answer. The supervised language loss is the usual next-token objective over assistant tokens,

$$ \mathcal{L}_R= -\sum_{i\in I_R}\log p_{\theta_R}\left(s_i\mid s_{1:i-1}\right), $$

where $I_R$ indexes assistant response tokens and $\theta_R$ denotes reasoner parameters. User context and image/video tokens are not directly supervised. The objective therefore teaches both task decomposition and how to interpret the visual evidence that a generated future is supposed to supply.

The second stage freezes the reasoner and updates only the generator. Every planning example carries the subtask, a dense visual description, and an operation duration. The generator is trained on image-to-video, first-and-last-frame-to-video, and cross-chunk continuation. Its rectified-flow loss is normalized across the active set $\Omega$ of positions that must be predicted:

$$ \mathcal{L}_G= \mathbb{E}\left[ \frac{1}{|\Omega|} \sum_{j\in\Omega} \left\| v_{\theta_G}(z_t,t,c)_j-v^{\star}_{t,j} \right\|_2^2 \right]. $$

Here $v_{\theta_G}$ is the predicted velocity field, $c$ combines text and visual conditions, and $v^{\star}_{t,j}$ is the target velocity defined by the clean latent and sampled noise. Dividing only by the number of active tokens prevents a large fixed prefix or four memory images from dominating the loss.

Teacher forcing would expose the generator to clean source frames that are unavailable during autonomous rollout. The paper's self-forcing recipe closes part of this gap in three ways: pixel-space noise and blur are applied to the starting frame; a frozen checkpoint generates the preceding clip and replaces the clean frame with its last frame; and a harder variant also replaces historical memory with generated frames. The current clip's real future remains the target, so the model learns to recover from its own visual errors rather than only from controlled degradations.

The prefix arithmetic is not an implementation detail. Training samples $k\in\{2,4,8\}$ clean prefix latents, corresponding to 5, 13, and 29 pixel frames. Inference uses the final 13 frames. The combined timeline contains at most 241 frames, and a prefix may occupy at most half of the latent timeline. If the source clip is too short, the executable code skips the continuation instead of repeating frames or taking an older clip and pretending that the boundary is continuous.

BCPO: Learning the Value of an Imagined Observation

The post-trained agent has two branches for a routable question. The direct branch D answers from the original observation. The generation-assisted branch G first emits a world-modeling request and duration, receives a video from the frozen generator, and then answers with that evidence. Each question supplies four direct and four generated trajectories. Questions that already provide multiple native images use eight direct trajectories because routing is not part of their evaluation.

Within each branch, rewards are normalized relative to the other trajectories that took the same route. For branch z and rollout i, the advantage is

$$ \hat A_{z,i}= \frac{r_{z,i}-\mu_z}{\sigma_z+\epsilon}, $$

where the mean and standard deviation are computed only inside that branch. A direct response is not penalized merely because video-assisted reasoning has a different absolute score distribution. It is compared with other direct attempts, while the generated route is optimized according to what makes a generated-evidence attempt succeed.

The policy objective uses a sequence-level importance ratio. Let $\rho_{z,i}$ average the token log-probability difference across the whole trajectory. The clipped objective is

$$ \mathcal{L}_{\mathrm{GSPO}}= -\mathbb{E}_{x,z,i} \left[ \min\left( \rho_{z,i}\hat A_{z,i}, \operatorname{clip}\left( \rho_{z,i}, 1-\epsilon_{\mathrm{low}}, 1+\epsilon_{\mathrm{high}} \right)\hat A_{z,i} \right) \right]. $$

Sequence-level clipping is a better fit than independent token clipping when different reasoning paths have different lengths. One scalar ratio applies to the entire request-and-answer trajectory, so a long response cannot accumulate many separately clipped token ratios into an uncontrolled update.

Routing is learned from the difference between branch means. The soft target for invoking the generator is

$$ q_G(x)= \operatorname{sg}\left[ \operatorname{sigmoid}\left( \frac{\mu_G-\mu_D}{T_{\mathrm{route}}} \right) \right], $$

where $\operatorname{sg}$ blocks gradients through the target. A route prediction is computed from the original question and observation before the model sees generated video. This prevents information leakage: the agent must anticipate whether generation will help, not peek at the result and decide that it was useful in hindsight.

The full update combines reasoning, routing, and regularization:

$$ \mathcal{L}_{\mathrm{RL}}= \mathcal{L}_{\mathrm{GSPO}} +\lambda_{\mathrm{route}}\mathcal{L}_{\mathrm{route}} +\beta\mathcal{L}_{\mathrm{KL}} -\eta H. $$

$L_{\mathrm{KL}}$ keeps the policy near the initial reasoner and H penalizes a collapsed entropy profile. The generator, reward system, and reference policy remain fixed, so BCPO cannot improve its reward by changing the video model. It can improve the legality and usefulness of generation requests, the interpretation of returned frames, and the decision to use generation at all.

Figure 2. BCPO compares four direct and four generation-assisted rollouts, applies GSPO inside each branch, and learns a soft route from the difference in branch rewards. Source: paper Figure 2.

Rewards: Protocol Validity Is Separate from Task Quality

A trajectory first has to obey the request-observe-answer protocol. Its task reward is multiplied by a binary validity gate:

$$ r(\tau)=F(\tau)A_k(\hat y,y^\star), \qquad F(\tau)\in\{0,1\}. $$

For numerical and geometric targets, normalized error $e_k$ is mapped to a continuous cubic score:

$$ A_k= \max\left(0,1-\frac{e_k}{0.30}\right)^3. $$

Physical and spatial quantities use relative error. Area and affordance predictions use symmetric nearest-point distance. Trajectories use discrete Frechet distance normalized by reference arc length, and the Mess subset evaluates multi-step interaction outcomes by level. Text answers use option matching, normalized matching, or a task-specific semantic judge.

The open implementation preserves an important engineering boundary. A malformed route or an illegal image reference yields an invalid zero-reward trajectory, but a generator service outage is raised upstream rather than scored as zero. Otherwise reinforcement learning would discover the pathological shortcut that infrastructure failures justify always choosing direct reasoning.

The training set contains 22,007 questions, including 883 validation questions. Each update uses 64 questions and eight rollouts each, for 512 trajectories. The reasoner is optimized for one epoch with a constant learning rate of $10^{-6}$; generated videos are observations, not tokens updated by the policy loss. This isolates adaptation to the reasoner while keeping the world model's visual behavior stable.

From Future Video to Actions

The world-action model extends the same stack with three inputs: the task instruction, current left/wrist/right camera views, and visual history. For RoboCasa365 it can receive up to 12 images, including an episode-start view, earlier left views, and earlier wrist views. The reasoner converts this context into a continuous subtask latent. The generator uses that latent through layer-wise attention while current views remain fixed visual conditions for future video prediction.

The action head is not a separate post-hoc parser. It reads the generator's video features after a single video-denoising step. Eighteen head modules use cross-attention over neighboring generator layers and produce an action chunk of shape $48\times12$. Only the first 16 actions are executed before replanning. The 12 control dimensions cover planar base translation, base yaw, torso height, end-effector translation and rotation, gripper control, and a control-mode indicator.

WAM training has three stages. First, the visual encoder and generator are frozen while the reasoner's language layers learn the current subtask. Second, the reasoner is frozen and the generator is trained jointly with native action tokens. Third, the original reasoner and action outputs are frozen while a new action head and generator are jointly trained with an auxiliary camera-pose objective. The stage-three loss is

$$ \mathcal{L}_{\mathrm{III}}= \mathcal{L}_{\mathrm{act}} +0.01\mathcal{L}_{\mathrm{pose}} +0.005\mathcal{L}_{\mathrm{rel}}. $$

The pose head predicts the future camera pose relative to the current one and is used only for training. At inference, no ground-truth pose is required. The relative-weighting is deliberate: action quality is primary, while camera motion supplies a geometry-aware auxiliary signal that helps the predictor represent viewpoint changes during mobile manipulation.

Where the Code Makes the Paper Concrete

VisualPlan/interleave_vp/plan_generator.py::generate_visual_plan accepts the current frame, context images, prefix frames, and an optional target frame. Its assertions encode the paper's layout rather than leaving it to callers. Prefix and target conditions are mutually exclusive; prefix length must be $4k-3$; context images are packed before the main video; and cross-chunk captions describe only the new action duration, excluding the historical prefix.

VisualPlan/interleave_vp/cross_chunk_v2v.py::combined_timeline turns the boundary-sharing rule into arithmetic: the prefix and new action share one frame. prefix_skip_reason rejects an insufficient source tail, a prefix longer than half the model timeline, or a total timeline beyond the configured maximum. Returning a skip reason is safer than silently creating a continuity that the model was never trained to accept.

BCPO/rynn_rl/selective_rollout.py::Collector.one implements the actual direct/generated branch. It parses the model's requested prompt and duration, checks cited frame or picture indices against the available inputs, calls the frozen generator, inserts the returned video as an observation, and samples a final answer. The collector creates exactly four D and four G trajectories for routable questions.

BCPO/rynn_rl/selective_objective.py::build_targets confirms three details behind the paper's equations. It enforces the four-plus-four or eight-direct layout, computes population variance separately inside each branch, and sets the routing target with a stop-gradient sigmoid over the difference in branch means. selective_loss.py then averages each trajectory's token ratios before clipping the whole sequence.

These implementation choices clarify what the claimed unity does and does not mean. The branches share a model and an interface, but they retain distinct losses, frozen components, and executable protocol checks. The most transferable engineering idea is not simply "put a video generator beside an LLM." It is to make future imagery a typed tool call whose request, conditions, validity, and downstream use can all be inspected.

Evaluation: Four Questions, Four Result Tables

The experiments separate four capabilities that a single overall score would blur. The first question is whether the reasoner understands embodied scenes without help from generation. The second is whether selective generation improves reasoning about unobserved states. The third is whether a rollout can sustain a visual plan across multiple steps. The fourth is whether the learned future representation helps a policy execute simulated and real manipulation.

Direct Embodied Understanding

Without generated-video rollouts or the BCPO agent, RynnUnify reaches an average of 57.9 across the paper's ten public embodied-understanding measures. That is the highest average among the compared unified multimodal models, exceeding Cosmos 3 Nano at 53.2. It scores 67.1 on VSI-Bench, 72.8 on RoboSpatial, 83.0 on EmbSpatial, and 60.3 on RefSpatial, while its trajectory error is 0.27.

Model	VSI	MMSI	MindCube	ERQA	RoboSpatial	EmbSpatial	RefSpatial	Affordance	Trajectory error	Where2Place	Average
Qwen3-VL-8B	60.3	29.8	36.8	44.8	58.2	78.5	53.4	37.9	0.37	64.7	52.7
RynnBrain-8B	71.0	39.6	56.6	46.8	73.1	80.4	59.2	44.7	0.35	75.5	61.2
Cosmos 3 Nano	54.9	36.2	40.5	46.0	62.1	81.4	53.1	28.0	0.34	64.0	53.2
RynnUnify	67.1	35.9	44.2	43.8	72.8	83.0	60.3	41.8	0.27	56.9	57.9

The table also prevents an overclaim. RynnBrain-8B is a specialized understanding model and has a higher ten-task average, 61.2. RynnUnify's advantage is that a single 16B system performs both understanding and generation while leading the unified-model group. Its Where2Place score is also substantially lower than RynnBrain's, showing that sharing a backbone does not eliminate task-specific tradeoffs.

When Does Generation Help?

Direct RynnUnify scores 44.0 on Rynn-GEU. After BCPO training, the agentic version reaches 50.0, a six-point gain. The public benchmark average rises from 41.3 to 44.6, and MindCube rises from 44.2 to 52.6. More revealing than the average are the uneven task effects: area localization improves from 35.9 to 66.2, while Mess reasoning rises from 8.5 to 29.1.

Configuration	Public average	MindCube	ERQA	Rynn-GEU average	Area	Mess
RynnUnify direct	41.3	44.2	43.8	44.0	35.9	8.5
RynnUnify with BCPO	44.6	52.6	44.8	50.0	66.2	29.1
BAGEL with interleaved thinking	38.4	39.6	44.8	10.8	18.5	1.9
Cosmos 3 Nano with interleaved thinking	36.0	36.4	41.4	33.5	28.4	4.5

The result is not a blanket endorsement of "think with video." The authors report small declines on position, distance, and size measures after agentic rollout. Fine-grained geometry can be distorted in a generated scene, and the following language step may treat the distortion as evidence. This supports a selective world model over an always-on one: the value of generation depends on whether the task requires transition evidence rather than precise measurement from the current frame.

The contrast with BAGEL and Cosmos 3 Nano also cautions against attributing the gains to interleaving alone. Their generated visual context lowers several averages, plausibly because inaccurate dynamics or irrelevant content contaminates later reasoning. RynnUnify combines a stronger embodied reasoner, task-focused prompts, and a direct fallback; the paper's evidence supports the package, not an isolated claim that any future video is beneficial.

Long-Horizon Visual Planning

Rynn-VP contains 200 manually collected egocentric task scenarios. Planning Intelligence checks whether the sequence advances the goal with valid, complete dependencies. Visual Realization checks action evidence, object consistency, state continuity, chunk consistency, and physical plausibility. Visual Quality measures image quality and task relevance. The overall score weights planning most heavily:

$$ \mathrm{Score}_{\mathrm{RynnVP}}= 0.5\,\mathrm{PI} +0.4\,\mathrm{VR} +0.1\,\mathrm{VQ}. $$

Method	Output	Planning Intelligence	Visual Realization	Visual Quality	Overall
BAGEL	Step images	9.46	24.36	58.50	20.32
RxBrain	Step images	1.28	11.35	28.15	8.00
Cosmos 3 Nano	Video	30.50	54.58	79.69	45.05
RynnUnify	Video	45.66	60.54	77.53	54.80
GPT-5.6 Terra plus MiniMax-H3	Composed video system	59.82	69.56	79.73	65.71

RynnUnify improves the overall score by 9.75 over Cosmos 3 Nano, but the decomposition is more informative than the total. Planning Intelligence rises by 15.16 and Visual Realization by 5.96, while Visual Quality falls by 2.16. The advantage is therefore concentrated in task progression and cross-clip consistency, not in generating prettier individual frames. A composed system using a stronger external planner and generator remains ahead at 65.71, so RynnUnify's claim is the best unified model in this comparison, not the best possible planning system.

Figure 3. Toy storage stresses repeated object transfer, while pillowcase folding stresses cloth deformation and background continuity across chunks. Source: paper Figure 8.

World-Action Execution

On RoboCasa365, RynnUnify reaches 52.0% on Composite-Seen, 50.0% on Composite-Unseen, and 51.5% on the paper's Selected-20 mobile-manipulation set. The unseen score is the highest in the table. The seen score is not: Xiaomi-Robotics-1 reaches 57.1%. Selected-20 uses ten episodes per task, or 200 episodes total, and RynnUnify exceeds CMA, Xiaomi-Robotics-1, and Cosmos 3 by 4.5, 5.5, and 6.5 percentage points.

Method	Composite Seen	Composite Unseen	Selected-20
pi0	6.1%	1.1%	3.0%
pi0.5	7.1%	1.2%	2.0%
GR00T N1.5	14.8%	2.7%	7.5%
GR00T N1.6	9.4%	1.7%	6.5%
Cosmos 3	49.6%	39.0%	45.0%
Xiaomi-Robotics-1	57.1%	32.1%	46.0%
CMA	50.6%	44.0%	47.0%
RynnUnify	52.0%	50.0%	51.5%

The real-robot study uses an Astribot S1 dual-arm mobile robot and 20 trials per task. Turn-and-Grasp requires turning between workstations and transferring two blocks; Block Swapping exchanges red and blue cubes between a drawer and the tabletop; Bowl times 3 then Spoon requires three visually similar pick-and-place cycles before a different final action. Complete-task success is 55.0%, 35.0%, and 50.0%, averaging 46.7%. GR00T N1.7 averages 26.7% and pi0.5 averages 25.0%.

Figure 4. Astribot S1 executions test base reorientation, precise object exchange, and history-dependent repeated manipulation. Source: paper Figure 10.

The 35.0% result for Block Swapping exposes the remaining precision gap. Small-object localization, grasp alignment, and placement across multiple steps remain difficult even when the higher-level plan is correct. The Bowl times 3 result is the stronger evidence for visual history: success depends on remembering how many cycles have completed when the current image looks nearly identical to an earlier state.

Figure 5. RynnUnify leads Composite-Unseen and Selected-20 while trailing the best seen-task score. Source: paper Table 5.

Data Scale and What It Does Not Resolve

The training mixture combines approximately 2 million general-understanding examples, 1.2368 million visual-planning understanding samples, and 196,600 embodied perception and reasoning samples. Video generation uses 1,083,458 clips totaling about 1,370.1 hours across human demonstrations, real robots, simulation, and embodied reasoning video. The WAM adaptation uses roughly 1,600 hours of RoboCasa365 atomic-task trajectories and 177 hours of composite-task trajectories.

Purpose	Source	Scale
General understanding	A 10% subset of the RynnBrain pretraining corpus	About 2 million examples
Visual-plan understanding	Human, robot, RoboCasa365, and simulation data	1,236,800 samples
Embodied perception and reasoning	Spatial, physical, action, clutter, area, and trajectory tasks	196,600 samples
Video generation	Planning and embodied-reasoning clips	1,083,458 clips, about 1,370.1 hours

Scale does not make the evaluation exhaustive. Rynn-VP supplies a simulator-free test of planning and visual consistency, but it cannot establish that those scores predict success under every physical controller. The paper adds RoboCasa365 and Astribot experiments, yet three real tasks with 20 trials each still leave broad uncertainty around material variation, lighting, calibration drift, network latency, and human interference.

Limitations

Generated geometry remains unreliable. The authors explicitly identify fine-grained geometric distortion as a limitation and connect it to lower position, distance, and size scores after agentic rollout. A semantically correct future can still move a target boundary or alter camera geometry. In high-precision assembly, such an error is not cosmetic; it can change the answer and the action. Deployment needs a confidence mechanism, a direct-observation fallback, or an external geometric check.

Visual-planning gains do not equal physical competence. The authors state that stronger simulator-free planning must be complemented by broader physical-execution validation, and future work should study how visual-planning scores relate to robot outcomes. The Astribot study is valuable because it tests the full action loop, but it is smaller and narrower than Rynn-VP. A system can generate a coherent plan while failing to execute it because of calibration, contact dynamics, or controller mismatch.

Interleaved generation is still expensive. A step that generates four seconds of 480p video at 24 frames per second, interprets it, and then plans again creates a second-scale decision loop. WAM reduces this cost by using one video-denoising step for action prediction, but the generator remains on the control path. The paper lists reduced computational cost as future work, which limits current suitability for fast reflexes and broad real-time deployment.

No model wins every comparison. RynnBrain-8B has a higher average on the direct-understanding table, the composed GPT-5.6 Terra plus MiniMax-H3 system scores higher on Rynn-VP, and Xiaomi-Robotics-1 leads Composite-Seen. RynnUnify's contribution is a unified architecture with competitive or leading results inside the relevant comparison groups. Treating it as an unconditional state of the art would misread the paper's own tables.

Conclusion

RynnUnify's most consequential move is to make future imagery a first-class intermediate state in embodied reasoning. The reasoner decides what future evidence is relevant, the generator produces that evidence under explicit spatial and temporal memory, and the next reasoning turn must interpret it. BCPO adds the missing control policy: the model can choose the cheap direct path and learn from paired outcomes when generation is actually useful.

The WAM extension shows that the same predicted future can become action context rather than a side-channel visualization. The action head reads generator features, and the real-robot Bowl result demonstrates why persistent history matters when observation alone is ambiguous. At the same time, distorted geometry, the gap between simulated planning scores and physical execution, and generation latency remain unresolved.

The useful research direction is therefore not simply scaling a unified video-language model. It is making generated evidence calibrated enough to trust, cheap enough to use in a loop, and inspectable enough to reject when the image is fluent but the geometry is wrong.