HOIST: Humanoid Optimization with Imitation and Sample-Efficient Tuning for Manipulating Suspended Loads

Abstract

Manipulating suspended payloads with humanoid robots is challenging because the robot can only influence an underactuated, oscillatory load through whole-body motion and intermittent contact. Imitation learning provides safe initial behavior but does not directly optimize final placement, while reinforcement learning from scratch is unsafe and sample-inefficient on real humanoids. We present HOIST–Humanoid Optimized with Imitation and Sample-efficient Tuning for manipulating suspended loads. HOIST first finetunes a high-level vision-language-action (VLA) policy from virtual-reality (VR) teleoperation demonstrations and executes its commands through a whole-body controller. It then uses VLA rollouts and iterative batched RL to improve placement accuracy and stopping behavior. Experiments in simulation and on a real humanoid show that HOIST improves over imitation-only and additional-demonstration baselines; compared with pure VLA rollouts, HOIST reduces translational placement error by 19.9 $cm$ and raw angular error by 3.56$^\circ$, demonstrating the potential of humanoids for underactuated material-handling tasks.

Introduction

Hoisting is a common material-handling operation across construction, manufacturing, and shipbuilding. In construction, cranes transport and install room-sized prefabricated building modules through congested sites and align them with structural interfaces (Zhu et al. 2022). In manufacturing, overhead or multi-cable cranes support the transport and precision assembly of large workpieces whose size and mass exceed the payload capacity of conventional robot manipulators (Hoffman and Asada 2020). In shipbuilding, large hull blocks and offshore-plant modules are erected using single- or multi-crane lifts, for which coupled crane-payload dynamics directly affect operational safety (Ku and Ha 2014). These examples span different scales and workflows, but share the same basic structure: lifting equipment provides high load capacity and long-range transport, while a suspended payload must be guided through a constrained workspace and accurately aligned with its final installation interface. Improving this last stage of hoisting is therefore important not only for construction automation, but also for flexible manufacturing and large-scale assembly.

Despite its importance, near-field load guidance remains labor-intensive and hazardous. Workers commonly stand close to the suspended object to guide, stabilize, rotate, or push it into alignment, where delayed payload response and residual swing create struck-by and caught-between hazards  (National Institute for Occupational Safety and Health 2021, 2006; U.S. Bureau of Labor Statistics 2023; Occupational Safety and Health Administration 2011). Existing automation does not fully address this role. Anti-sway and trajectory controllers act through the crane and generally require access to the lifting system, while fixed robot arms have limited workspace and must be installed at each placement location. Wheeled mobile manipulators extend the reachable workspace, but their planar mobility and limited whole-body redundancy are often ill-suited to uneven or cluttered worksites and to interactions that require simultaneous base repositioning, balance regulation, torso motion, bimanual contact, and forceful pushing. Hoisting guidance is consequently a whole-body loco-manipulation problem rather than an arm-only manipulation task.

Humanoid robots are well matched to these requirements. Their legged mobility, human-scale reach, articulated torso, and two arms allow them to move through human-designed environments, vary their contact height and posture, and use the whole body to manipulate large objects while maintaining balance  (Yoshida et al. 2007; Murooka et al. 2015; Zhang et al. 2025). Fig. 1 illustrates both real hoisting operations and our lab setup, motivating the question: can humanoid robots safely operate around underactuated material-handling systems that are currently handled by human workers?

We study this question through humanoid hoisting: using a humanoid robot to position an externally suspended payload through whole-body motion and contact-rich manipulation. Unlike standard pick-and-place or tabletop manipulation, the robot cannot directly control the payload pose or velocity; it can only influence the payload through base motion, arm motion, body posture, and contact forces. The payload therefore behaves like an underactuated pendulum, a structure widely studied in crane modeling and anti-sway control (Abdel-Rahman et al. 2003; Ramli et al. 2017; Qiang et al. 2021; Mojallizadeh et al. 2023). It may continue moving after the robot stops, overshoot the target, or retain residual oscillation. We therefore position humanoid hoisting as a new whole-body loco-manipulation problem, where success depends not only on feasible humanoid motion, but also on contact timing and stopping behavior for a dynamically active payload. VR teleoperation offers a practical way to collect demonstrations for initializing humanoid hoisting behaviors (Zhang et al. 2018; Rosen et al. 2018; Han 2023). However, imitation learning does not directly optimize final placement accuracy and may accumulate errors during closed-loop execution (Ross et al. 2011). Conversely, training from scratch with RL on a real humanoid is unsafe and sample-inefficient in this contact-rich setting (Rajeswaran et al. 2017; Wagenmaker et al. 2025).

We present HOIST–Humanoid Optimized with Imitation and Sample-efficient Tuning for manipulating suspended loads. HOIST first uses VR whole body teleoperation collected demonstrations to finetune a high-level vision-language-action (VLA) policy, whose planner-level commands are executed by a whole-body controller. It then collects autonomous rollouts and applies iterative batched RL refinement with hoisting-specific rewards to improve placement accuracy and stopping behavior. This combines safe imitation initialization with task-level reward optimization, avoiding unsafe tabula-rasa exploration while addressing objectives not captured by imitation alone. Our contributions are:

• We introduce humanoid hoisting, a whole-body loco-manipulation problem involving an externally suspended, indirectly driven, and oscillatory payload, opening a direction for humanoids to operate underactuated material-handling systems.

• We present HOIST, which combines VR teleoperation, supervised VLA finetuning, fixed whole-body execution, and sample-efficient RL refinement for suspended-payload manipulation.

• We evaluate suspended-payload positioning in simulation and on a real humanoid, comparing additional demonstrations with RL refinement and analyzing how rollout count and input modalities affect placement accuracy.

Related Work

Robotic hoisting and suspended-payload control

Robotic systems have been widely studied for construction automation and material handling (Bock and Linner 2016; Xu and De Soto 2020), where hoisting heavy payloads is common. Because suspended loads exhibit pendulum-like dynamics, prior work has studied modeling, trajectory planning, input shaping, and anti-sway control for crane and cable-suspended systems (Abdel-Rahman et al. 2003; Ramli et al. 2017; Qiang et al. 2021; Hoffman and Asada 2020). These methods typically control the lifting mechanism directly, whereas humanoid hoisting can only influence an externally suspended payload through intermittent whole-body contact. Recent work has studied non-prehensile tool-object manipulation using language-level planning and feedback control (Lee et al. 2026), but the tool is directly held by the robot and the manipulated object is not externally suspended. Our work therefore reformulates suspended-payload positioning as humanoid-assisted local manipulation, where the robot acts as an external contact-rich agent rather than part of the crane controller.

Humanoid whole-body control and loco-manipulation

Humanoid whole-body control has advanced from motion tracking to real humanoid systems with richer high-level interfaces (Peng, Abbeel, et al. 2018; Peng, Kanazawa, et al. 2018; Allshire et al. 2025; Luo, Yuan, Wang, Li, Chen, Castaneda, et al. 2025; Bjorck et al. 2025; Luo, Yuan, Wang, Li, Chen, Castañeda, et al. 2025). Humanoid loco-manipulation further studies coordinated locomotion, balance, and contact-rich interaction through motion priors, residual policies, and compliance regulation (Yoshida et al. 2007; Zhang et al. 2025; Zhao et al. 2025; Chen et al. 2025). Surveys of industrial human-robot collaboration identify safety, adaptation, communication, and learning from human partners as central challenges for collaborative robots (Hjorth and Chrysostomou 2022; Mukherjee et al. 2022). For contact-rich mobile manipulation, learned variable-impedance control can combine RGB-D and force/torque observations with human demonstrations to improve compliant execution (Zhou et al. 2025). However, most prior tasks involve rigid or quasi-static objects whose motion is constrained by the robot or environment. In contrast, suspended payloads remain dynamically active after contact, making success depend on contact timing, accurate placement, and stopping behavior.

Reinforcement learning for robot control

Reinforcement learning can optimize robot behavior from task rewards and environment interaction, including high-dimensional contact-rich manipulation (Rajeswaran et al. 2017; Elguea-Aguinaco et al. 2023). Reviews of smart robotic manufacturing position robot learning as an important enabling technology while emphasizing data efficiency, generalization, and safe deployment as persistent challenges (Liu et al. 2022). Hierarchical contact-policy learning further shows that complex contact behaviors can be decomposed into reusable lower-level skills and higher-level sequencing policies (Simonič et al. 2024). However, applying RL directly to humanoid hoisting is unsafe and sample-inefficient: early exploration may cause unstable motion, hard contacts, over-pushing, or large residual swing, motivating safety-aware and demonstration-guided learning (Garcıa and Fernández 2015; Gu et al. 2023). Our approach avoids tabula-rasa exploration by starting from a teleoperation-finetuned VLA policy and using RL to refine high-level commands from limited rollouts, optimizing placement and stopping while preserving safe demonstrated behavior (Wagenmaker et al. 2025).

Methodology

This section describes the technical formulation and implementation of HOIST. We first formalize the complete descent–guidance–landing episode, including the exogenous hoist motion, initialization, termination, and evaluation criteria. We then present the teleoperation data collection, high-level VLA policy, whole-body controller, and RL refinement procedure used to improve terminal payload placement.

Problem formulation

We consider humanoid hoisting, where a humanoid robot assists the local positioning and landing of an externally suspended payload while an external hoist lowers it toward a target region. The episode contains three phases: (i) the robot approaches while the payload is suspended and begins to descend, (ii) the robot establishes contact and guides its position and yaw during descent, and (iii) the robot reduces contact and stops as the payload reaches the terminal landing height. The robot does not actuate the hoist or suspension mechanism. The vertical hoist motion is an exogenous input, whereas the humanoid can influence the payload only through whole-body motion and intermittent contact forces. The task therefore couples locomotion and balance, contact timing, horizontal placement, descent-dependent pendulum dynamics, landing, and residual swing.

The payload is a $54\,\mathrm{cm}\times54\,\mathrm{cm}\times50\,\mathrm{cm}$ box with mass $2.5\,\mathrm{kg}$, suspended above a target zone. At the beginning of every episode, the suspension configuration and payload pose are reset to the same nominal state. In particular, the payload center is initialized at a fixed offset from the target center in the horizontal $x$-$y$ plane. This offset is chosen such that the payload’s unguided vertical descent lies outside the target footprint. Consequently, lowering alone cannot produce a successful placement: the humanoid must establish contact and create sufficient horizontal displacement toward the target. If the robot fails to push or loses effective contact, the payload reaches the terminal height outside the target area.

We model humanoid hoisting as a task-conditioned, partially observed, closed-loop control problem. At each high-level decision step $t$, the policy receives the observation $$\begin{equation} \mathbf{o}_t = \left\{ \mathbf{I}^{\mathrm{ego,rgb}}_t, \mathbf{D}^{\mathrm{ego}}_t, \mathbf{I}^{\mathrm{side,rgb}}_t, \mathbf{x}^{r}_t, \mathbf{v}^{\mathrm{ego}}_t, \ell, \mathbf{c}^{\mathrm{nav}}_{t-1} \right\}, \end{equation}$$ where $\mathbf{I}^{\mathrm{ego,rgb}}_t$ and $\mathbf{D}^{\mathrm{ego}}_t$ are the humanoid onboard RGB and depth observations, $\mathbf{I}^{\mathrm{side,rgb}}_t$ is an external side-view image that captures the payload, target, and ongoing descent, $\mathbf{x}^{r}_t$ denotes the humanoid proprioceptive state, $\mathbf{v}^{\mathrm{ego}}_t$ is the ego-velocity input, $\ell$ is the language instruction, and $\mathbf{c}^{\mathrm{nav}}_{t-1}$ is the previous navigation command. The proprioceptive state $\mathbf{x}^{r}_t$ includes joint states and base/IMU information. We do not assume direct contact-force sensing or explicit payload pose, velocity, cable length, hoist phase, or landing-state input. These latent task variables must instead be inferred from the image history and robot state, making the descending task partially observed.

The high-level policy does not output joint torques. Instead, it predicts the next $H$ high-level planner-command increments: $$\begin{equation} \Delta \mathbf{U}_t = \pi_{\theta}(\mathbf{o}_t) = \left( \Delta \mathbf{u}_{t}, \Delta \mathbf{u}_{t+1}, \ldots, \Delta \mathbf{u}_{t+H-1} \right), \end{equation}$$ where $\pi_{\theta}$ is the learned high-level VLA policy with parameters $\theta$, $H$ is the action-chunk horizon, and $\Delta \mathbf{U}_t$ is the predicted command-increment chunk at time $t$.

Each single-step command increment $\Delta \mathbf{u}_{\tau}$ updates the head target, left-hand target, right-hand target, navigation command, and desired base height: $$\begin{equation} \Delta \mathbf{u}_{\tau} = \left[ \Delta \mathbf{y}^{\mathrm{head}}_{\tau}, \Delta \mathbf{y}^{L}_{\tau}, \Delta \mathbf{y}^{R}_{\tau}, \Delta \mathbf{c}^{\mathrm{nav}}_{\tau}, \Delta h^{\mathrm{base}}_{\tau} \right], \quad \tau=t,\ldots,t+H-1. \end{equation}$$ Here, $\tau$ indexes a future high-level step within the predicted command chunk, $\mathbf{y}^{\mathrm{head}}_{\tau}$ is the head tracking target, $\mathbf{y}^{L}_{\tau}$ and $\mathbf{y}^{R}_{\tau}$ are the left- and right-hand tracking targets, $\mathbf{c}^{\mathrm{nav}}_{\tau}$ is the navigation command, and $h^{\mathrm{base}}_{\tau}$ is the desired base-height command. There is deliberately no crane, winch, or descent command in $\Delta\mathbf{u}_{\tau}$: the lowering trajectory is generated externally and is not controlled by either the VLA policy or the whole-body controller.

The corresponding full planner command at time $t$ is $$\begin{equation} \mathbf{u}_{t} = \left[ \mathbf{y}^{\mathrm{head}}_{t}, \mathbf{y}^{L}_{t}, \mathbf{y}^{R}_{t}, \mathbf{c}^{\mathrm{nav}}_{t}, h^{\mathrm{base}}_{t} \right]. \end{equation}$$ In words, the VLA policy only decides short-horizon task-level motions, such as where the hands and body should move next; the low-level controller converts these commands into balanced whole-body motion.

The execution stack maintains the previous full planner command $\mathbf{u}_{t-1}$, while the policy receives only the previous navigation command $\mathbf{c}^{\mathrm{nav}}_{t-1}$ as an explicit command-history input. At execution time, we apply the first increment in the chunk to update the current planner command: $$\begin{equation} \mathbf{u}_t = \mathbf{u}_{t-1} + \Delta \mathbf{u}_t. \end{equation}$$ The updated command is then executed by a humanoid whole-body control stack: $$\begin{equation} \mathbf{a}^{\mathrm{motor}}_t = \pi_{\mathrm{wbc}} \left( \mathbf{x}^{r}_t, \mathbf{u}_t \right), \end{equation}$$ where $\pi_{\mathrm{wbc}}$ is a fixed decoupled whole-body controller (Luo, Yuan, Wang, Li, Chen, Castaneda, et al. 2025), and $\mathbf{a}^{\mathrm{motor}}_t$ denotes the low-level motor command. This hierarchy lets the learned policy operate at the task-command level, while whole-body tracking, balance, and joint-level stabilization are handled by the fixed execution stack.

Overview of HOIST

Our method consists of three stages: teleoperation data collection, supervised VLA finetuning, and RL refinement. First, a human operator uses a VR headset and controllers to teleoperate the humanoid robot through the hoisting task. Second, we use the collected teleoperation data to finetune A high-level VLA policy, so that the humanoid can autonomously generate hoisting-related planner commands from visual observations and task instructions. Third, we deploy the finetuned VLA policy to collect autonomous rollouts and use these rollouts for iterative batched flow-matching-steering RL (Wagenmaker et al. 2025) refinement.

Teleoperation data collection

We collect whole-body hoisting demonstrations using a PICO VR headset and controllers. During each demonstration, the operator controls the humanoid through the complete task sequence, including approaching the suspended payload, establishing bimanual contact, coordinating base and upper-body motion to guide the payload, and terminating the pushing motion near the target. The teleoperation interface produces the same planner-level command representation defined in Section 3.1, so the recorded demonstrations remain compatible with the fixed whole-body execution stack used during autonomous deployment.

Each demonstration trajectory is represented as $$\begin{equation} \tau_i = \left( \left\{ \left(o_t,u_t^{\mathrm{demo}},a_t^{\mathrm{motor}}\right) \right\}_{t=1}^{T_i}, y_i \right), \end{equation}$$ where $o_t$ is the multimodal observation defined in Section 3.1, $u_t^{\mathrm{demo}}$ is the planner-level command generated from VR teleoperation, $a_t^{\mathrm{motor}}$ is the motor command produced by the fixed whole-body controller, and $y_i$ contains trajectory-level outcomes such as terminal payload placement and residual motion. The sensing modalities and planner-command variables are therefore not redefined here. The VLA operates at 50 Hz in our implementation.

Following the relative-command formulation introduced in Section 3.1, the recorded teleoperation commands are converted into supervised action-chunk targets $$\begin{equation} \Delta U_t^{\mathrm{demo}} = \left( \Delta u_t^{\mathrm{demo}}, \ldots, \Delta u_{t+H-1}^{\mathrm{demo}} \right), \qquad \Delta u_\tau^{\mathrm{demo}} = u_\tau^{\mathrm{demo}}-u_{\tau-1}^{\mathrm{demo}}, \end{equation}$$ with an action-chunk horizon of $H=24$. The per-step command dimensions are those defined in Eq. (3). This preprocessing converts the teleoperated planner trajectories into the same relative action representation predicted by the high-level policy while preserving short-horizon temporal structure for coordinated pushing and stopping.

These demonstrations serve two purposes. First, they constrain the initial learned policy to motions that have already been executed safely through the humanoid whole-body controller. Second, they expose the VLA to task-specific visual and dynamical transitions, including payload approach, contact establishment, payload displacement, and stopping near the landing region. The resulting supervised dataset therefore initializes HOIST close to a feasible whole-body behavior distribution before any reinforcement-learning refinement is performed.

High-level VLA policy

The high-level policy is initialized from GR00T N1.6 (Bjorck et al. 2025) and modified for suspended-payload manipulation. Its input-output interface is the one formalized in Section 3.1: the policy maps the multimodal observation $o_t$ to a short-horizon planner-command chunk $\Delta U_t$, rather than directly predicting joint positions or torques. This separation allows the learned policy to focus on task-level decisions such as approaching, maintaining contact, coordinating bimanual pushing, repositioning the base, and stopping, while balance and joint-level stabilization remain delegated to the pretrained execution layer.

HOIST augments the pretrained VLA with modalities that are especially relevant to contact-rich hoisting. Ego-view and side-view RGB observations provide semantic context for the humanoid, suspended payload, and target region. The previous navigation command is introduced as an additional conditioning signal to the vision-language representation so that the policy can account for ongoing commanded base motion. A dedicated depth encoder processes the onboard depth observation, while robot-state and ego-velocity features are provided to the flow-matching action expert. These additions allow action generation to depend jointly on scene appearance, local geometry, and the humanoid’s current motion state without requiring explicit payload pose or contact-force measurements.

Let $h_t^{\mathrm{VLM}}$ denote the visual-language representation produced by the VLM backbone, while $z_t^{\mathrm{state}}$ and $z_t^{\mathrm{depth}}$ denote the encoded robot-state and depth features. The flow-matching action expert generates the planner-command trajectory conditioned on these representations and an initially sampled noise tensor. In our implementation, the horizon is $H=24$, consistent with Section 3.1, and four flow-matching denoising steps are used to transform the initial noise into the final command chunk.

Supervised finetuning minimizes the discrepancy between the predicted action chunks and the teleoperated targets $\Delta U_t^{\mathrm{demo}}$. To avoid unnecessarily modifying the pretrained foundation representation, we update only the final four VLM layers, the flow-matching action expert, and the encoders associated with the newly introduced modalities. The remaining VLM layers and the downstream whole-body controller are frozen. Training is performed for 10,000 optimization steps with a batch size of 96 and an initial learning rate of $1\times10^{-4}$ using cosine decay.

Humanoid whole-body controller

HOIST uses the GR00T Whole-Body Control deployment stack (Luo, Yuan, Wang, Li, Chen, Castaneda, et al. 2025) as a fixed low-level execution module. The command accumulation and low-level execution equations are already given in Eqs. (5) and (6), respectively. In this hierarchy, the VLA operates in planner-command space, whereas the whole-body controller converts the resulting targets into dynamically feasible humanoid motion while handling whole-body tracking, locomotion, posture regulation, balance, and joint-level stabilization.

The whole-body controller is kept frozen throughout both VLA finetuning and RL refinement. We do not adapt the low-level controller to the suspended payload in the current implementation. Thus, all task learning occurs through the planner-command interface, and any correction learned by HOIST must propagate through the fixed controller and the resulting physical humanoid-payload interaction.

Reinforcement-learning refinement

Supervised VLA finetuning provides a feasible initial policy but optimizes imitation accuracy rather than the terminal outcome of the hoisting task. During autonomous deployment, small errors in base motion, contact timing, pushing duration, or stopping commands alter subsequent observations and can accumulate into systematic placement bias. Rather than updating the complete VLA using a small number of real-robot trials, HOIST performs reinforcement learning in the initial-noise space of the frozen flow-matching action expert.

After supervised finetuning, the VLA policy $\pi_{\mathrm{VLA}}^{*}$ and whole-body controller $\pi_{\mathrm{WBC}}$ are frozen. We use a lightweight Soft Actor-Critic (SAC) actor-critic module (Haarnoja et al. 2018) $(\mu_\theta,Q_\phi)$. At each high-level decision step, the actor predicts a deterministic replacement for the initial noise used by the flow-matching action expert, $$\begin{equation} a_t^{\mathrm{RL}} = \mu_\theta(o_t), \qquad a_t^{\mathrm{RL}} \in \mathbb{R}^{24\times25}. \end{equation}$$ The two dimensions correspond to the 24-step action-chunk horizon and the 25-dimensional per-step planner-command representation defined by the command interface in Section 3.1. Instead of sampling the original initial-noise tensor, HOIST substitutes the actor output, $$\begin{equation} \epsilon_t^{\mathrm{init}} \leftarrow s_k\,a_t^{\mathrm{RL}}, \end{equation}$$ where $s_k$ controls the steering magnitude at refinement iteration $k$. The frozen flow-matching action expert then transforms this steered initial noise into a complete planner-command chunk. Because the underlying VLA weights are unchanged, reinforcement learning does not construct a new action policy from scratch; it modifies which trajectory is selected from the action distribution already learned from demonstrations.

Each generated command chunk is executed through the same frozen whole-body controller, allowing the resulting command perturbation to propagate through locomotion, contact, and suspended-payload dynamics. After the terminal landing and settling event, the payload pose is measured and compared with the target pose. We define the terminal reward using normalized translational and yaw errors, $$\begin{equation} r_T = \exp\!\left( -\left[ 1.5\left(\frac{\Delta x}{100\,\mathrm{mm}}\right)^2 + 1.0\left(\frac{\Delta y}{80\,\mathrm{mm}}\right)^2 + 1.0\left(\frac{|\Delta\psi|}{30^\circ}\right)^2 \right] \right). \end{equation}$$ This terminal-only reward directly optimizes the final task objective and avoids introducing intermediate shaping terms that could bias the robot toward a particular pushing strategy.

Training follows an iterative batched rollout-and-update procedure. Starting from the supervised VLA policy, HOIST collects $N=10$ autonomous hoisting rollouts per refinement iteration. The resulting transitions, initial-noise actions, and terminal rewards are appended to an accumulated offline replay buffer. The SAC actor-critic is then updated using the accumulated rollout data before the refined steering policy is redeployed to collect the next batch. In our experiments, this process is repeated for up to three iterations, corresponding to 30 autonomous task rollouts.

Only the noise-steering actor-critic is updated during this stage; the GR00T N1.6 backbone, flow-matching action generator, and SONIC whole-body controller remain frozen. We additionally cache VLM features because the visual-language backbone does not change during RL, avoiding repeated visual-language encoding during actor–critic optimization. The RL module is trained with a batch size of 256, a learning rate of $3\times10^{-4}$, and 20,000 gradient updates per refinement iteration.

Experiments and Results

Experiment setup

We evaluate HOIST in simulation and on a real humanoid platform. Each trial starts with the payload away from the target; the humanoid must position it through contact without actuating the suspension mechanism. In each domain, VLA-50 is finetuned on $50$ teleoperated demonstrations, VLA-80 uses $80$ demonstrations, and HOIST starts from VLA-50 before applying up to $30$ same-domain RL rollouts. All methods use the same frozen GR00T whole-body execution stack, isolating changes to the high-level command policy.

Evaluation metrics

Let $(x_T, y_T, \psi_T)$ denote the payload-center pose measured after the terminal descent/landing event and settling window, and let $(x^{\star}, y^{\star}, \psi^{\star})$ denote the target pose. We report two terminal placement metrics: the Manhattan position error $$\begin{equation} e_M = \left|x_T-x^{\star}\right|+\left|y_T-y^{\star}\right|, \end{equation}$$ and the absolute yaw error $$\begin{equation} e_\psi = \left|\mathrm{wrap}(\psi_T-\psi^{\star})\right|. \end{equation}$$ For an interpretable task-level success criterion, we set a translational tolerance of $e_M\leq7\,\mathrm{cm}$ and an orientation tolerance of $e_\psi\leq30^\circ$. A trial is successful only when both conditions are satisfied after landing and settling. These thresholds are applied uniformly to all methods and domains and are used only for evaluation; the RL reward continues to use the normalized component-wise terminal errors defined in Eq. 11.

Reinforcement-learning progression

Table 1 reports placement accuracy after each batch of RL rollouts. The rollout feedback substantially corrects the placement bias of the VLA-50 initialization, although improvement is not strictly monotonic after every batch.

Figures 5 and 6 show the trial-level distributions underlying the aggregate results in Table 1.

Both the +20 and +30 RL policies have mean $e_M$ and $e_\psi$ below the specified success thresholds in simulation and on the real platform. The +30 policy is nevertheless worse than +20 on some metrics, most notably simulation placement and real-platform yaw. We interpret this as a practical convergence plateau: by +20 rollouts, refinement has already entered the task-tolerance region, so an additional small rollout batch produces limited net improvement and finite-sample rollout, optimization, and evaluation variability can cause non-monotonic fluctuations. Thus, +30 should be viewed as another tolerance-satisfying policy rather than a uniformly better checkpoint.

Reinforcement learning versus additional demonstrations

Table 2 compares additional demonstrations with same-domain RL rollouts after the initial $50$ demonstrations. HOIST substantially reduces Manhattan placement error relative to VLA-80 in both domains, and its mean yaw and Manhattan errors remain within the success tolerances. Yaw is not uniformly improved on the real platform, so the comparison supports RL primarily as a mechanism for correcting the closed-loop translational placement errors that remain after imitation learning.

Observation-modality ablation

Table 3 evaluates the VLA policy before RL refinement under different input modalities. The goal is to measure whether depth and navigation-command conditioning improve the imitation-learned initialization. All rows use the same number of demonstrations and no RL rollouts.

Depth improves contact-geometry awareness, while navigation-command conditioning improves the use of current base motion. The combined variant performs best, supporting the use of both modalities before RL refinement.

Residual motion analysis

Table 4 reports the simulation IMU statistics used to quantify payload residual motion.

We further analyze payload dynamics throughout the lifting process using an IMU mounted on the suspended load. As shown in Fig. 8, compared with the imitation-only policy, HOIST yields higher accelerometer readings but reduces gyroscope responses by approximately half, suggesting reduced angular motion with more active corrective adjustments during lifting. Meanwhile, both learned policies exhibit lower accelerometer and gyroscope readings than human teleoperation demonstrations, which may reflect the more frequent closed-loop corrections performed by human operators.

Discussion and Limitation

The improvement from 30 RL rollouts suggests that the imitation-learned VLA policy has systematic deployment bias. Supervised finetuning matches expert actions on the demonstration distribution, but the learned policy is not executed under that same distribution: once deployed, its own prediction errors affect contact timing, pushing strength, and stopping behavior, producing a different closed-loop rollout distribution. Thus, the policy may consistently under-push, over-push, or stop at a biased terminal position.

Additional demonstrations add more expert-distribution data, but they do not directly identify this deployment-time bias. In contrast, autonomous rollouts reveal the biased trajectories generated by the current VLA policy itself. HOIST can then use task-level rewards to learn an initial-noise correction that steers the frozen policy away from these systematic errors. This makes RL rollouts more useful than extra demonstrations for correcting final placement accuracy.

Although the experiments use one physical payload configuration, the policy is not evaluated from an identical deterministic payload state in every trial. The payload is lowered before each run, and small differences in release position, cable length, sway phase and velocity, and contact timing propagate through its nonlinear, underactuated pendulum dynamics. Crane studies explicitly show that vertical hoisting and time-varying cable length alter the coupled sway dynamics and make stabilization more challenging (Abdel-Rahman et al. 2003; Zhang et al. 2020). Related slewing lifting systems can even exhibit chaotic instability under specific fast-cycle conditions with changing rope lengths and loads (Meehan 2025). Thus, the different descent responses across our repeated trials expose HOIST to latent-state and trajectory variation, providing evidence that it is not merely replaying or overfitting to one fixed payload trajectory.

The primary limitation of the current system lies in the low-level whole-body controller, which has not been fine-tuned for interaction with suspended payloads. Specifically, the policy can only influence robot execution through a limited interface consisting of navigation commands, head pose, base height, and bimanual hand poses, without explicitly adapting the applied force to different payload weights. Consequently, the system struggles to generate sufficiently large and adaptive forces when manipulating heavier objects, limiting its ability to handle heavy payloads.

Conclusion

We presented HOIST, which initializes humanoid hoisting from teleoperated demonstrations and improves final placement through rollout-level RL while keeping the whole-body controller fixed. The learned initial-noise correction changes command sequences, which propagate through humanoid-payload contact dynamics to reduce final placement error and residual swing. Future work will expand payload and suspension conditions, add force-adaptive control mechanism, and study coordination between multiple humanoid robots.

HOIST Algorithm

Algorithm 1: HOIST Training

1. Inputs: VR teleoperation demonstrations $\mathcal{D}$, pretrained VLA policy $\pi_\text{VLA}$ (GR00T N1.6), whole-body controller $f_\text{WBC}$ (SONIC, frozen throughout)

2. Output: Refined hoisting policy $(\pi_\text{VLA}^*, \mu_\theta^*, f_\text{WBC})$

3. Phase 1 — Supervised Finetuning

4. Collect VR teleoperation demonstrations with multimodal observations: $\tau_i = \bigl(\{o_t, u_t^\text{demo}, a_t^\text{motor}\}_{t=1}^{T_i},\, y_i\bigr)$

5. Each observation $o_t$ contains ego RGB/depth, side-view RGB, proprioception, ego velocity, navigation command, and language goal $y_i$

6. Convert teleoperation commands into VLA action chunks $\Delta U_t^\text{demo} = [\Delta u_t,\dots,\Delta u_{t+H-1}]$ with horizon $H{=}24$

7. Initialize from the pretrained GR00T N1.6 VLA and attach encoders for newly introduced modalities (depth, ego velocity, navigation command)

8. Supervise the flow-matching action expert to generate demonstration chunks conditioned on VLM features and robot state, using 4 denoise steps

9. Finetune the final 4 VLM layers, the action expert, and the new-modality encoders on $\mathcal{D}$; keep the remaining VLM backbone and $f_\text{WBC}$ frozen $\Rightarrow$ obtain $\pi_\text{VLA}^*$

10. Freeze $\pi_\text{VLA}^*$ and $f_\text{WBC}$; cache VLM features for rollout-level RL refinement

11. Phase 2 — Iterative Batched RL Refinement

12. Initialize noise-steering SAC actor-critic $(\mu_\theta, Q_\phi)$

13. For iteration $k = 1,2,\dots,K$:

    1. Collect $N=10$ autonomous rollouts using $(\pi^*_{\mathrm{VLA}}, \mu_\theta, f_{\mathrm{WBC}})$

    2. The actor deterministically predicts a replacement initial-noise tensor $$a_t^{\mathrm{RL}} = \mu_\theta(o_t), \quad a_t^{\mathrm{RL}} \in \mathbb{R}^{24 \times 25}$$

    3. Here, 24 is the action-chunk horizon, and 25 is the per-step planner-command dimension covering head target, left/right end-effector targets, navigation command, and base-height command

    4. Replace the flow-matching action expert’s initial noise with the scaled actor output: $$\epsilon_t^{\mathrm{init}} \leftarrow s_k \, a_t^{\mathrm{RL}}$$

    5. Execute the VLA action chunk through the frozen whole-body controller $f_{\mathrm{WBC}}$

    6. For each rollout $\tau_i$:

       1. Observe terminal payload pose $(\hat{x}, \hat{y}, \hat{\psi})$ and target $(x^*, y^*, \psi^*)$

       2. Compute terminal errors: $$\Delta x = \hat{x}-x^*, \quad \Delta y = \hat{y}-y^*, \quad \Delta \psi = \hat{\psi}-\psi^*$$

       3. Compute terminal reward: $$r_T = \exp\!\left(-\left[ 1.5\!\left(\tfrac{\Delta x}{100\,\text{mm}}\right)^{\!2} + 1.0\!\left(\tfrac{\Delta y}{80\,\text{mm}}\right)^{\!2} + 1.0\!\left(\tfrac{|\Delta\psi|}{30^\circ}\right)^{\!2} \right]\right)$$

    7. Convert rollouts into an offline replay buffer $\mathcal{B}_{0:kN}$

    8. Train/update $(\mu_\theta, Q_\phi)$ with offline SAC on $\mathcal{B}_{0:kN}$ for fixed gradient steps

    9. Resume from previous RL checkpoint for the next stage

14. Return refined hoisting policy $(\pi^*_{\mathrm{VLA}}, \mu^*_\theta, f_{\mathrm{WBC}})$

Implementation Details and Hyperparameters

CRediT authorship contribution statement

Songyang Liu: Writing – original draft, Methodology, Validation. Shunyu Yao: Writing – original draft, Methodology, Validation, Visualization. Dingyuan Huang: Resources. Shuai Li: Conceptualization, Writing – review & editing, Funding acquisition, Supervision.

Declaration of competing interest

The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.

Data availability

Data will be made available on request.

References