A robot arm with weak motors can still move a heavy object if it leans the object against a wall or shelf and lets the environment carry part of the load. Planners that find such "bracing" motions exist, but they take minutes, so the robot runs the plan blind and cannot respond when the object slips or the shelf is softer than modeled. We propose to treat the split of load between the robot's joints and the environment's contact forces as a resource-allocation problem that must be solved again at every control tick. We solve it with a small learned solver that copies the structure of a classical iterative algorithm, the same approach that has made wireless power and beamforming allocation fast enough to run in real time.
The opportunity follows from two results. Torque-Limited Manipulation Planning through Contact by Interleaving Graph Search and Trajectory Optimization showed that a Kinova Gen3 rated for 4.0 kg can move 4.7 kg by bracing, cutting actuator RMS torque by 12.24 to 34.85 Nm. Each plan, however, takes about 3 minutes, and the plan rests on artificial spring-damper contact smoothing whose stiffness errors cause tracking failures on the real robot. Separately, deep unfolding has shown large speedups on constrained allocation problems. Deep unfolding means turning a fixed number of iterations of an optimization algorithm into network layers and learning the step sizes and penalties. It made beamforming 24x faster in Deep Graph Unfolding for Beamforming in MU-MIMO Interference Networks and power allocation 58x faster in Graph-based Algorithm Unfolding for Energy-aware Power Allocation in Wireless Networks. Nobody has unfolded a solver for the stick-or-slip logic of contact, which is exactly what bracing requires.
Core Claim
We claim that a short-horizon model predictive controller for bracing can run at 50–100 Hz on a torque-limited arm with fewer torque-limit violations and fewer slip failures than an offline plan tracked by feedback. Model predictive control here means re-solving a small trajectory optimization over the next few hundred milliseconds at every tick. The controller's inner solver is an unfolded penalty-ADMM method for complementarity constraints. A graph neural network over the contact set chooses the per-iteration penalty and relaxation schedule. ADMM, the Alternating Direction Method of Multipliers, is a splitting algorithm that alternates cheap subproblem solves with dual updates. Complementarity constraints encode "a contact either sticks or slides along the friction-cone boundary, never both."
The new ingredient is not "learning to optimize for robots." Deep FlexQP: Accelerated Nonlinear Programming via Deep Unfolding already unfolds ADMM with LSTM-predicted penalties inside sequential quadratic programming and reports 4–16x speedups over OSQP. Its robotics tasks are collision avoidance and safety filtering, though, and its elastic $\ell_1$ relaxation handles smooth convex constraints, not stick-slip transitions. We extend unfolding to a relax-and-tighten homotopy on complementarity. We also borrow the wireless-allocation idea that the network should be equivariant over a variable set of interacting entries: users there, contacts here.
The Allocation Problem
At each tick we know the arm state, the estimated object pose, and a set of active or candidate contacts. Candidates are found by proximity between the object and environment surfaces and between the object and the gripper. The controller then solves the following problem over a horizon of $H$ steps:
$$\min_{\tau,\lambda,s}\ \sum_{t=1}^{H} \|x_t - x_t^{\mathrm{goal}}\|^2 + \beta \|\tau_t \oslash \tau_{\max}\|^2 \quad \text{s.t.}\quad |\tau_t| \le \tau_{\max},\ \ \lambda_{c,t}\in K_c,\ \ 0 \le s_{c,t} \perp g_c(\lambda_{c,t}) \ge 0 .$$
The symbols are as follows. $x_t$ is the object pose and $\tau_t$ the joint torques. $\oslash$ is elementwise division, so the torque term penalizes the fraction of each motor's budget used, and $\beta$ weights that term. $\lambda_{c,t}$ is the force at contact $c$. $K_c$ is its linearized friction cone. $s_{c,t}$ is its slip speed. $g_c$ is the distance of the contact force from the cone boundary. The $\perp$ symbol says slip can be nonzero only when the force sits on the cone boundary. The problem is also subject to discretized object and arm dynamics, which couple joint torques to contact forces through the contact Jacobians.
Read this way, the joints and environment contacts are suppliers with budgets: motor torque limits and friction cones. The object's required wrench is the demand. The graph coupling through Jacobians plays the role that interference plays in power allocation.
The standard way to handle the complementarity is to relax it to $s_{c,t}\, g_c \le \epsilon$ and drive $\epsilon$ to zero. Each relaxed problem can be split by ADMM into a box projection for torques, a cone projection per contact, and a linear dynamics solve. The resulting update laws are fixed and exact. Tuning the schedule of $\epsilon_k$ and the penalty $\rho_k$ is what makes this approach slow or unstable in practice, so that schedule is what we learn.
Research Program
We will build the unfolded solver as $K$ ADMM layers, with $K$ between 10 and 30. At each layer, a message-passing network runs on a heterogeneous graph whose nodes are joints, contacts, and the object, and whose edges follow the Jacobian couplings. The network reads current primal and dual residuals and outputs $\rho_k$, $\epsilon_k$, and a per-contact soft guess of the contact mode, which is used to warm the next cone projection. Weights are shared across layers and across contacts, following the parameter sharing that let UWMMSE train on 20 users and run on 100.
Two choices keep the method robust. First, the last layer always ends with exact projections onto the torque box and the friction cones, so torque limits hold by construction regardless of what the network outputs. Second, if the residual check fails, the controller falls back to the previous tick's shifted solution.
Training is unsupervised, with no solver labels. The loss is the objective plus constraint violation at the final layer, plus a penalty when the objective rises from one layer to the next. That last term is the monotonic regularizer that stabilized training in USCA. We train on randomized bracing scenes: object mass, friction, wall stiffness, and shelf geometry are sampled. We test on held-out ranges and on more contacts than were seen in training.
The analysis has two parts. We will check whether the learned $\epsilon$ schedules resemble hand-designed homotopies or exploit contact structure, for example by tightening environment contacts earlier than finger contacts. We will also measure how often the soft mode guesses agree with the mode of the converged solution.
Baselines
The naive reference point is free-space manipulation with no bracing, executed by the same arm and torque limits. At the Lazy INSAT payload it should fail or saturate. It tells us how much the environment is buying.
The strongest existing method on the exact question is Lazy INSAT itself, from Torque-Limited Manipulation Planning through Contact by Interleaving Graph Search and Trajectory Optimization. Its reported numbers are a 4.7 kg payload on a 4.0 kg-rated Kinova Gen3, RMS torque reductions of 12.24 to 34.85 Nm, and roughly 3 minutes of planning. We will rerun it in our simulated replica of that testbed to produce one plan per scene. That plan will then be tracked by a joint impedance controller at the same control rate as our method, so the comparison isolates "plan once" from "re-allocate every tick." Beating it means matching its torque reduction on nominal scenes while achieving higher success and fewer torque-limit violations when friction, stiffness, or object mass deviate from the planning model.
The strongest solver baseline solves the identical relaxed-complementarity MPC with OSQP for the ADMM subproblems, and separately with IPOPT on the full problem. Both are warm-started from the previous tick and use a hand-tuned $\epsilon$ schedule. Their tuning budget equals our training-time budget in wall-clock hours. For the speed comparison, the relevant prior number is the 4–16x speedup over OSQP reported in Deep FlexQP. No reported result was found on Lacuna for OSQP or IPOPT on contact-complementarity MPC for bracing, so we will establish that number ourselves.
A learned-warm-start baseline uses the same graph network to predict an initial solution and mode guess, then hands off to warm-started IPOPT. This is the most common alternative in learning-to-optimize work and the one most likely to match us.
Two ablations isolate the key ingredients. In the first, we unfold the same $K$ layers with a fixed, untuned schedule, which isolates the learned schedule. In the second, a black-box graph network maps the contact graph directly to torques and forces, followed by the same final projection, which isolates the value of embedding the ADMM updates.
For the occluded-grasping transfer experiment, the RL reference is SAC with compliant control from Learning to Grasp the Ungraspable with Emergent Extrinsic Dexterity. It reported 100% simulated success and 78% zero-shot real success. We will retrain it with a torque-limit penalty under the same torque caps we impose.
Why not just…?
Why not just run a warm-started OSQP or IPOPT on the same MPC? This is the most serious threat. With few contacts and a short horizon, each subproblem is small, and warm starting may keep solves under 10 ms. The weakness is not the size of the subproblems but the number of outer complementarity-tightening steps, and how erratically that count varies when contact modes switch. That variability is what makes a fixed deadline hard to meet. We will report the full latency distribution, including the 99th percentile, and the deadline-miss rate at 50 and 100 Hz, as functions of the contact count and horizon. If the warm-started solver meets the deadline with equal success in the regimes we care about, we will report that the unfolding is unnecessary there and restrict the claim to the larger contact counts where it is not.
Why not just train an RL policy with a torque penalty? Learned policies are fast. However, Learning to Grasp the Ungraspable with Emergent Extrinsic Dexterity reports that success fell to 0% when the wall was removed. Emergent Dexterity Via Diverse Resets and Large-Scale Reinforcement Learning describes such policies as brittle and dependent on per-task reward and curriculum engineering. A penalty also does not guarantee the torque limit. Our perturbation sweep measures torque violations and success for the retrained SAC policy directly. A policy that matches us on both metrics across held-out friction and stiffness would undercut the proposal.
Why not just plan offline with Lazy INSAT and rely on a compliant tracking controller? Compliance absorbs small errors, and if perturbations are mild this may suffice. Two pieces of evidence argue against it. Lazy INSAT itself attributes its real-world tracking error to stiffness model uncertainty. Manipulation with Shared Grasping lost half of its physical trials to accumulated drift without closed-loop correction. The perturbation magnitude at which the tracked offline plan begins to fail is the crossover point our experiments are designed to locate.
Why not just use a diffusion policy like DexDiff? DexDiff reports 70% simulated success. Its authors concede that iterative denoising latency hurts real-time smoothness and that push-to-wall is sensitive to friction it does not model. Nothing in a diffusion policy enforces contact force balance or torque limits. We treat it as a reference on the occluded-grasping suite rather than a primary competitor for bracing.
Proposed Experiments
The main testbed is a MuJoCo replica of the Kinova heavy-payload bracing setup from Lazy INSAT, with its torque limits. Payloads range from 3.5 to 5.0 kg. We randomize wall and shelf friction by ±50% and contact stiffness by an order of magnitude, and we inject impulse disturbances at random times. We measure task success; peak and RMS joint torque relative to $\tau_{\max}$; the count of torque-limit violations; slip events at environment contacts; and solve-latency distributions on a fixed CPU, including deadline-miss rate.
A second testbed checks that the solver generalizes beyond lifting. It uses the Robosuite/MuJoCo push-to-wall suite used by Learning to Grasp the Ungraspable with Emergent Extrinsic Dexterity and DexDiff, plus the grasp-constraining wall suite from Leveraging Extrinsic Dexterity for Occluded Grasping on Grasp Constraining Walls, which reported 100% simulated and 90% real success. On these suites we impose torque caps tighter than the original settings, so that bracing against the wall becomes necessary rather than optional.
The first decisive check runs at a fixed control rate. Under the nominal model, we expect to match Lazy INSAT's torque reduction. Under perturbed friction and stiffness, we expect higher success with zero torque-limit violations. A win only on nominal scenes would not support the claim.
The second decisive check is the comparison against warm-started OSQP/IPOPT and the learned-warm-start hybrid at equal deadlines. If either matches our success at our latency, the unfolding is not the right contribution.
The third check tests the equivariance claim. We train with up to four contacts and test with eight. Success should degrade gracefully, in the way UWMMSE held up when scaled from 20 to 100 users.
The fixed-schedule unfolding ablation tells us whether any gain comes from learning or merely from truncating ADMM at a fixed iteration count.
References
- Torque-Limited Manipulation Planning through Contact by Interleaving Graph Search and Trajectory Optimization
- Deep Graph Unfolding for Beamforming in MU-MIMO Interference Networks
- Graph-Based Algorithm Unfolding for Energy-Aware Power Allocation in Wireless Networks
- Deep FlexQP: Accelerated Nonlinear Programming via Deep Unfolding
- Learning to Grasp the Ungraspable with Emergent Extrinsic Dexterity
- Emergent Dexterity Via Diverse Resets and Large-Scale Reinforcement Learning
- Manipulation with Shared Grasping
- DexDiff: Towards Extrinsic Dexterity Manipulation of Ungraspable Objects in Unrestricted Environments
- Leveraging Extrinsic Dexterity for Occluded Grasping on Grasp Constraining Walls