REVER: Vision-Language Robotic Manipulation Framework

• The paper introduces REVER (Reinforced Embodied Planning with Verifiable Reward) as a framework that couples vision-language planning with explicit step verification for long-horizon tasks.
• It leverages a fine-tuned VLM, RoboFarseer, to generate chain-of-thought plans and employs dense, interpretable rewards to guide reinforcement fine-tuning.
• REVER achieves significant performance gains, including up to 76% bipartite matching accuracy and a 60% boost in household task success through real-world data synthesis and closed-loop control.

REVER is a framework for long-horizon robotic manipulation from free-form language instructions that couples vision-language planning with explicit step verification in real-world settings. The name expands to Reinforced Embodied Planning with Verifiable Reward, and the framework is built around two claims: first, that embodied planning is constrained by the scarcity of sequential manipulation data aligned with natural language; second, that effective fine-tuning of vision-LLMs (VLMs) for planning requires dense, interpretable rewards rather than only terminal success signals. Within REVER, a fine-tuned VLM called RoboFarseer generates chain-of-thought plans with temporal and spatial reasoning, while the overall system uses a verifiable reward based on ordered bipartite matching overlap with ground-truth skill sequences and a runtime monitoring loop that checks step-wise completion (Bo et al., 30 Sep 2025).

1. Problem setting and conceptual scope

REVER targets long-horizon manipulation tasks in which a robot must execute a sequence of atomic skills derived from a free-form instruction such as tidying, preparing an item, or transporting objects. The framework is explicitly motivated by two gaps: the lack of large-scale, sequential manipulation data that jointly represent natural language and multi-step plans, and the lack of dense, interpretable rewards for planning-oriented fine-tuning of VLMs (Bo et al., 30 Sep 2025).

The framework therefore treats planning not as one-shot action prediction but as a structured sequence-generation problem over executable skills. In deployment, the VLM does not operate as a passive captioning module. It functions both as a planner, which maps scene observations and instructions to a skill sequence, and as a monitor, which verifies whether each planned subtask has been completed before the next skill is issued. This closes the loop between symbolic plan generation and low-level robotic execution.

The paper instantiates this design with RoboFarseer, based on Qwen2.5-VL-7B, fine-tuned to emit explicit chain-of-thought plans satisfying physical and logical constraints. The reported objective is not merely linguistic plausibility but physically plausible and logically coherent plans under real-world manipulation constraints (Bo et al., 30 Sep 2025).

2. Data synthesis, UMI, and the LEAP dataset

A central component of REVER is its real-world data synthesis pipeline. To obtain manipulation data, the framework uses the Universal Manipulation Interface (UMI) to collect hardware-agnostic demonstrations of atomic skills. The description in the paper gives representative skills such as put, pick, open, and pour. These demonstrations are then segmented and stored as a reusable skill library (Bo et al., 30 Sep 2025).

An automated annotation engine converts demonstrations into supervision suitable for planning and verification. For each multi-step task, it generates:

• Plan annotation: the sequence of executable skills forming the plan.
• Completion annotation: a binary True/False label indicating whether a skill was completed.

The completion labels are produced by pairing before/after images and sampling failures with intermediate frames, so the verification problem is posed directly on visual evidence rather than on privileged simulator state (Bo et al., 30 Sep 2025).

The resulting dataset is named LEAP, expanded in the paper as Long-horizon Embodied Action Planning, and is reported to contain ~12,000 tasks, split into training and testing subsets. Data points are organized as vision, instruction, plan/completion triplets. This design gives REVER supervision for both sequence generation and runtime verification, rather than only for final task outcomes.

3. Verifiable reward and reinforcement fine-tuning

The defining technical mechanism in REVER is the verifiable reward used in reinforcement fine-tuning. Let the generated plan be $P_g = (p_1, \ldots, p_M)$ and the ground-truth plan be $P_{gt} = (p'_1, \ldots, p'_N)$. The full reward is defined as

$$\mathcal{R}(P_g, P_{gt}) = w_f \cdot \mathcal{R}_{\text{format}}(P_g) + w_c \cdot \mathcal{R}_{\text{content}}(P_g, P_{gt}).$$

The format score enforces a prescribed syntax and chain-of-thought template:

$$\mathcal{R}_{\text{format}}(P_g)= \begin{cases} 1, & \text{if } P_g \text{ matches prescribed template} \ 0, & \text{otherwise.} \end{cases}$$

The content score is built from an ordered bipartite matching objective. Step similarity is decomposed into action and object similarity:

$$\text{Sim}(p_i, p'_j) = w_a \cdot \text{Sim}_{\text{act}}(p_i, p'_j) + w_o \cdot \text{Sim}_{\text{obj}}(p_i, p'_j),$$

and the matching reward is

$$\mathcal{R}_{\text{bm}}(P_g, P_{gt}) = \frac{1}{\max(M, N)} \max_{\pi \in \Pi} \sum_{i=1}^M \text{Sim}(p_i, p'_{\pi(i)}).$$

The paper then defines

$$\mathcal{R}_{\text{content}}(P_g, P_{gt}) = \mathcal{R}_{\text{bm}}(P_g, P_{gt}) - w_l |M-N|.$$

This construction is intended to reward semantic overlap while penalizing plan length mismatch, and it is deterministic and directly computable from annotations rather than from human preference judgments or simulator rollouts (Bo et al., 30 Sep 2025).

For policy optimization, REVER uses Grouped Relative Policy Optimization (GRPO). The per-sample advantage is reported as

$$\hat{A}_i = \frac{r_i - \operatorname{mean}(\{r_1,\ldots,r_B\})}{\operatorname{std}(\{r_1,\ldots,r_B\})},$$

with a PPO-style objective regularized by a KL term to a reference policy. This places REVER within the broader class of RL fine-tuning methods for sequence models, but its reward is specialized to structured embodied plans rather than textual preference alignment.

4. Runtime architecture: planner, controller, and verifier

At inference time, REVER forms a hierarchical planning and execution framework. A user supplies a natural-language instruction. RoboFarseer observes the scene and produces a step-wise, skill-based manipulation plan formatted in the allowed atomic grammar. A low-level controller then executes the selected atomic skill. After execution, the same VLM acts as an execution monitor by comparing before-action and after-action images and predicting whether the step was completed (Bo et al., 30 Sep 2025).

This runtime loop has five stages in the paper’s description:

1. natural-language instruction input,
2. VLM plan generation,
3. low-level execution of a skill,
4. visual completion verification,
5. progression to the next skill or replanning on failure or timeout.

The architecture is therefore not purely deliberative. It is a closed-loop system in which planning and monitoring are integrated. The paper states that this enables robust long-horizon behavior under unpredictable real-world conditions, because the robot advances only after explicit confirmation of step completion (Bo et al., 30 Sep 2025).

5. Empirical performance and benchmark results

REVER is evaluated on LEAP-L, LEAP-U, ShareRobot-Planning, EgoPlan-Bench2, RoboVQA, and MCQ versions of these planning tasks. The reported baselines include proprietary VLMs such as Gemini-2.5-Pro/Flash, GPT-4.1, GPT-4o, and Claude-Sonnet-4, as well as open-source models such as Qwen2.5-VL-72B/32B and RoboBrain2-7B/32B (Bo et al., 30 Sep 2025).

On MCQ planning, RoboFarseer is reported to outperform all open-source competitors by at least 9 points, despite being a 7B model. On open-ended plan generation, the paper reports up to 76% bipartite matching accuracy (LEAP-L), compared with 24% for Gemini-2.5-Pro, and states that RoboFarseer surpasses the best baseline by more than 40% (Bo et al., 30 Sep 2025).

For real-world household tasks, the detailed examples report the following success rates:

Scenario	Success w/VLM	Success w/o VLM
Bring food/drinks	90%	10%
Tidy desktop (fruits)	80%	40%
Brew tea	70%	0%

The abstract summarizes this as a boost in overall success of roughly 60% compared with the same low-level controller without the planner (Bo et al., 30 Sep 2025). The paper also reports that the controller-only system averaged 14% success and failed completely on more abstract multi-stage tasks.

The error analysis attributes 43.6% of failures to low-level control/execution and 16.2% to reasoning errors. This numerical breakdown is significant because it localizes the dominant remaining bottleneck after planner training: not the generation of task structure, but execution fidelity under real-world dynamics (Bo et al., 30 Sep 2025).

6. Significance, release status, and nomenclature

REVER’s principal contribution is the combination of three elements: a real-world, automatically annotated long-horizon manipulation dataset; a deterministic, structured reward for plan quality; and a dual-use VLM that performs both planning and step verification. Within the paper’s framing, this makes it possible to fine-tune embodied planners without human preference data, simulators, or noisy LLM-as-a-judge proxies (Bo et al., 30 Sep 2025).

The paper states that all model weights, datasets (LEAP-L and LEAP-U), and code will be released, positioning REVER as an intended open research artifact rather than only a benchmark submission. It also presents the framework as a data and evaluation resource for subsequent embodied planning work.

The name REVER should be distinguished from several unrelated systems with similar orthography. In logic programming, rever denotes a reversible debugger for Prolog based on a Landauer embedding of SLD resolution (Vidal, 2020). In algorithmic recourse, ReVer denotes a region-verification method based on mixed-integer quadratically constrained programming for identifying confined regions with fixed predictions (Lawless et al., 22 Feb 2025). In reversible computing, ReveR denotes a software simulator of a reversible processor with stack-based control flow (Vlasov, 2011). None of these systems concerns embodied manipulation planning, and the all-caps acronym REVER in robotics refers specifically to Reinforced Embodied Planning with Verifiable Reward for Real-World Robotic Manipulation (Bo et al., 30 Sep 2025).