💻 computer science

FORGE-plus: Force-Budgeted Recovery for Contact-Rich Assembly with a Frozen LLM Supervisor

FORGE-plus introduces a two-layer framework that leverages a frozen LLM to assign force ceilings and select recovery maneuvers based on textual signatures, enabling a low-level controller to achieve robust, breakage-free contact-rich assembly with tight clearances and slip recovery without ever directly controlling force or exceeding safety limits.

Original authors: Kyupaeck Jeff Rah, Midum Oh

Published 2026-07-24

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Kyupaeck Jeff Rah, Midum Oh

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a world where robots are like clumsy toddlers trying to build with a box of LEGOs, but these LEGOs are made of glass, and the instructions are written in a language the robot doesn't speak. This is the challenge of contact-rich assembly: teaching a machine to gently push, slide, and snap parts together without breaking them. In the past, robots learned this by trial and error, often smashing the parts until they figured out the right force. But what if the parts are too fragile to smash?

To solve this, scientists use a mix of Reinforcement Learning (RL)—where a robot learns by getting points for success and penalties for mistakes—and Large Language Models (LLMs), the same kind of AI that can write stories or answer questions. The big question has been: How do we tell the robot how hard to push, and what should it do if it gets stuck? If a robot jams a screw, the natural instinct is to "push harder." But if you're holding a fragile glass bottle, pushing harder is the fastest way to turn it into a pile of shards. This paper explores a new way to teach robots to be gentle, smart, and safe, using a simulation where the "parts" can break if the force gets too high.

The Robot with a "Don't Touch That" Sign

Meet FORGE-plus, a new system designed to help robots assemble delicate things, like putting a glass bottle into a wine rack or sliding a tiny gear onto a shaft with almost no room to wiggle. The researchers built a two-layer brain for the robot, and it works a bit like a strict boss and a quick-thinking mechanic.

The Boss (The Frozen LLM):
Before the robot even touches the object, a "frozen" AI (a smart text-reader that doesn't learn or change during the task) looks at the object's name and description. It's like a boss reading a label that says "Fragile Glass" or "Steel Gear." Based on this text, the boss sets a force ceiling. Think of this as a speed limit sign for force. If the object is a fragile bottle, the boss says, "You can push with a maximum of 8.8 Newtons of force." If it's a tough steel gear, the limit is higher. Crucially, the robot cannot ask the boss to change this limit later, even if it gets stuck.

The Mechanic (The Fast Control Loop):
The robot's actual hand moves at lightning speed, guided by a fast computer loop. This loop has a hard "clamp" that acts like a safety valve. No matter what the robot's brain thinks, the clamp physically stops the robot from pushing harder than the boss's limit. If the robot tries to push with 10 Newtons, the clamp instantly cuts it down to the limit. This ensures that even if the robot makes a mistake, it can't break the object by pushing too hard.

What Happens When Things Go Wrong?

In the real world, things get jammed. Maybe the bottle hits the rim of the rack, or the gear gets tilted inside the gripper. In the past, robots might have tried to "press harder" to force their way through. The researchers tested this "press harder" strategy, and it was a disaster. On one type of gripper, it did nothing but waste time; on another, it smashed 96% of the fragile parts.

FORGE-plus takes a different approach. When the robot gets stuck, it doesn't ask the boss to raise the limit. Instead, it looks at a force signature. Imagine the robot is listening to the "sound" of the contact through its sensors. A jammed bottle sounds different than a stuck gear. The robot sends this "sound" (which is just a short text description of the forces) to the boss. The boss then picks a recovery move from a fixed menu, like "wiggle," "rotate," or "let go and try again."

The magic is that the robot never increases the force limit. It just tries different moves within the safe limit. If the bottle is wedged, the robot might rotate it slightly to find a gap, rather than shoving it down.

The Results: A Simulation Success Story

The researchers tested this in a very realistic computer simulation (using Isaac Lab) with two different robot hands: a Robotiq gripper and a Franka Panda hand. They used two main tasks:

The Bottle: Putting a fragile glass bottle into a rack.
The Gear: Sliding a gear onto a shaft with a tiny 0.4 mm gap (thinner than a human hair).

The Good News:
The system worked incredibly well in the simulation. A single robot "brain" (a checkpoint) managed to successfully seat both the fragile and the tough gears 256 times out of 256 without breaking a single one. It also learned when to let go of the object perfectly, with zero bad releases. Even when the robot slipped and grabbed the gear at a bad angle, the system used the force signature to realize, "Hey, I'm holding this crooked," and decided to put it back on the table and pick it up again. This "re-grasp" strategy saved the day, recovering 40% to 64% of the jams depending on the robot hand.

The Bad News (and the Important Lessons):
The paper is also famous for what it didn't work. The researchers tried to use a standard learning method called PPO (which usually helps robots learn by exploring random moves). They found that at such a tiny 0.4 mm clearance, the robot's random "exploration" moves were so big that they broke the fragile parts before the robot could even learn how to fit them. It's like trying to thread a needle by throwing the needle at the thread; you'll never get it right, and you'll break the needle.

They also found that if you try to teach the robot to be "perfectly optimal" by letting it push right up to the breaking point, it actually fails more often. Because the robot's movements have a little bit of "overshoot" (it pushes a tiny bit too hard before stopping), a limit set exactly at the breaking point still results in broken parts. The "safe" limit set by the boss (based on the object's identity) was actually better than the "perfect" limit calculated by a cheat code.

Why This Matters

This paper doesn't claim to have built a robot that can do this in a real factory yet; it's all a simulation. But it proves a powerful idea: Safety doesn't come from the robot being smart enough to know when to stop; it comes from a hard limit that the robot cannot cross.

By separating the "thinking" (the boss setting the limit) from the "doing" (the fast clamp enforcing it), the system ensures that the robot can try to solve problems without ever becoming destructive. It shows that for fragile tasks, the best strategy isn't to push harder, but to be smarter about how you push, and to have a strict rule that says, "No matter what, you cannot push this hard."

In the end, FORGE-plus suggests that the future of delicate robot work isn't about building stronger, smarter AI that can guess the right force, but about building systems that are forced to be gentle, using a "force budget" that the robot respects no matter what.

Technical Summary: FORGE-plus

Problem Statement

Force-conditioned Reinforcement Learning (RL) skills have demonstrated success in contact-rich assembly tasks by respecting a commanded force ceiling ( $F_{max}$ ). However, two critical gaps remain in deploying these skills for fragile objects:

Who sets the ceiling? Current methods often autotune $F_{max}$ to maximize success rates. This approach fails when a single system must handle both robust (e.g., steel) and fragile (e.g., nylon or glass) parts, as a ceiling sufficient for the former will destroy the latter.
What to do on failure? When an insertion fails, the intuitive recovery strategy—"press harder"—is precisely the action that destroys fragile components. Existing vision-based failure reasoners (e.g., REFLECT, DoReMi) operate at the task level and often miss the subtle distinctions between failure modes (e.g., wedging vs. cross-threading) that are evident only in force traces, not visual pixels.

Methodology: FORGE-plus Architecture

FORGE-plus introduces a two-layer system designed to enforce safety without relying on the LLM for real-time control authority. The system operates entirely in simulation (Isaac Lab) with rigid-body dynamics and modeled breakage.

1. The Two-Layer System

Slow Layer (Frozen LLM Supervisor):
- Budget-Setter: Before an episode, a frozen, text-only LLM reads the object's identity (name, material, geometry tags) and outputs a per-object force ceiling ( $F_{max}$ ). It does not see images or instance-specific breakage data.
- Recovery-Selector: Upon detecting a failure, the LLM reads a compact text "force signature" (derived from force/torque history, contact duration, and slip events) and selects a recovery maneuver from a fixed menu (e.g., retract_and_reapproach, wiggle_search, rotate_align, regrasp, abort).
- Constraint: The menu explicitly excludes any option to "increase the ceiling." The LLM's output is overwritten server-side to ensure $F_{max}$ remains immutable during recovery.
Fast Layer (Force-Conditioned RL Skill):
- A force-conditioned MLP policy (trained via Behavior Cloning and DAgger) executes the insertion.
- Hard Clamp: A safety clamp in the fast control loop (60–120 Hz) saturates all commanded forces to the $F_{max}$ set by the LLM. This ensures the LLM never has direct authority over the physical force applied.
- Release Head: A learned linear head (bypassing the main policy trunk) decides when to release the object based on raw observations.

2. Evaluation Design (Non-Circularity)

The evaluation is designed to prevent circular reasoning regarding fragility:

Hidden Breakage: The breaking force ( $F_{break}$ ) is sampled per episode from a distribution and is never observed by the policy, the LLM, or the signature encoder. It is visible only to the evaluator.
Safety Invariants: $F_{max}$ is fixed during recovery, and force authority resides strictly in the fast control loop.

Key Contributions

1. Architecture and Benchmark

The paper presents a unified architecture for force-budgeted assembly under per-object fragility. It introduces a non-circular breakage metric and a benchmark involving two distinct tasks:

Fragile Bottle Placement: Inserting a wine bottle into a rack (simulated fragile class with $F_{break} \approx 22$ N).
Tight-Clearance Gear Insertion: Inserting a gear with 0.4 mm diametral clearance (simulated fragile ABS gear with $F_{break} \approx 38 \pm 5$ N).
Embodiments: Experiments run on two grippers: Robotiq 2F-140 and Franka Panda hand.

2. Full-Cycle Results

A single unified checkpoint (a "weight soup" of policies trained on both fragile and robust classes) achieved:

Clean Gates: 256/256 successful clean insertions with zero breaks on both fragile and robust gear classes using the Robotiq 2F-140.
Release: 256/256 successful learned releases with zero "bad releases" (premature or failed releases).
Physical Flow: A fully physical table-pick flow (no teleportation or kinematic pinning) completed 64/64 episodes with a mean peak insertion force of 5.4 N.

3. Recovery Efficacy vs. Baselines

Under injected disturbances (rim wedges and 5 mm in-grip slips):

Force-Signature Recovery: The proposed system recovered 40% of jams (Robotiq) and 64% of jams (Franka) by routing specific force signatures to the correct recovery primitive (e.g., regrasp for tilted grips).
Press-Harder Baseline: This baseline (modeled on Tactile-VLA's published behavior) showed two distinct failure modes:
- Robotiq 2F-140: 100% futile (timeouts) because the tilted bore never engaged the load, rendering force escalation useless.
- Franka Panda: 96% destructive, breaking fragile parts by escalating force.
Vision-LLM Proxy: A menu-sampling proxy for vision-only reasoners achieved lower success rates (28% and 32%) because it could not distinguish the force signature of a tilted grip from other failures.

4. Negative Results as Findings

The paper rigorously reports what does not work:

PPO Failure: On-policy PPO training fails at 0.4 mm clearance on the Robotiq 2F-140; the exploration noise required to find the funnel is inherently destructive to fragile parts.
Tiny-Std Polish: Fine-tuning a working Behavior Cloning (BC) policy with PPO (low std) destroys the policy within 25 iterations due to gradient amplification.
Oracle Budget: Even an "oracle" setting $F_{max} = F_{break} - \epsilon$ fails (50% breakage) because controller overshoot exceeds the budget. This proves that a safe budget must account for the controller's overshoot distribution, not just the breakage threshold.
Release Head Designs: Three natural designs for a learned release head failed; only an input-skip linear head (bypassing the trunk) succeeded.

Significance and Claims

The paper claims that FORGE-plus provides a structural solution to the "who sets the ceiling" and "what to do on failure" problems in contact-rich assembly:

Identity-Derived Budgets: A conservative budget derived from object identity outperforms an "oracle" budget because it accounts for control overshoot, ensuring safety without needing to know the specific instance's breakage threshold.
Force-Grounded Recovery: Recovery strategies must be grounded in force signatures, not vision. The force signature is the only signal capable of distinguishing a "regrasp" need (tilted grip) from other failures, outperforming vision-based selection by a factor of ~2.
The Failure of "Press Harder": The natural recovery of increasing force is proven to be either futile or destructive depending on the gripper and failure mode, never the correct solution for fragile assembly.
Safety Separation: Safety is guaranteed by the hard clamp in the fast loop, not the LLM. The LLM acts only as a semantic selector for motion primitives, never as a force authority.

The authors emphasize that these results are simulation-only with rigid-body physics and modeled breakage. No sim-to-real transfer is claimed, though the underlying FORGE-style force conditioning is noted as having prior transfer success. The work serves as a rigorous benchmark and a set of negative findings to guide future research in fragile manipulation.