Dexterous Grasping of Deformable and Flexible Parts

Deformable object manipulation asks robots to grasp things whose shape changes because the robot is touching them: cloth, cable, tissue, a bag of chips. That single fact breaks most of the assumptions rigid-body robotics runs on, splitting the problem into five layers, sensing, modeling, gripper hardware, planning, and control, that all lean on each other to work at all. This piece walks through each layer and takes a position most coverage of this field won't: soft, compliant hardware beats better software as the near-term fix, because no model built this decade will fully capture what a piece of fabric does when you touch it.

Start with the assumptions rigid-object grasping gets to make and deformables refuse to honor. A rigid part has fixed geometry, so a gripper can plan a static approach and just run it. Contact forces follow from geometry and known stiffness, so you can predict what happens when metal meets metal. Pose tracking works because the object looks the same from frame to frame. None of that holds for a piece of fabric or a strip of chicken breast. The shape changes as the fingers close, the stiffness might be unknown or inconsistent across the batch, and self-occlusion during deformation wrecks whatever pose estimate the vision system had a second ago. Even companies with serious engineering budgets and warehouse-scale deployments, Covariant's picking systems and Boston Dynamics' Stretch among them, have not closed the gap with human performance on thin, deformable objects. That gap says the fix runs deeper than more GPUs. Researchers have started calling the alternative "imprecise dexterity," the idea that success comes from compliant, adaptive strategies that tolerate uncertainty rather than from controllers precise enough to erase it. The rest of this piece traces where that uncertainty comes from and how each layer of the system tries, with mixed success, to manage it.

How researchers classify deformable objects, and why the taxonomy shapes every downstream decision

Object taxonomy sounds like a filing exercise, the kind of thing a committee argues about over coffee. It isn't. The category an object falls into decides which tools even apply, which makes it a load-bearing part of the whole problem, not a footnote to it.

The standard split runs by dimensionality. Deformable linear objects, DLOs, cover cable, rope, and surgical suture: one-dimensional, high aspect ratio, and prone to tangling, which complicates handling in most robotics demonstrations. Planar deformable objects are cloth, fabric, garments, bedsheets: two-dimensional, with close to infinite degrees of freedom and self-occlusion so severe that a folded shirt can hide half its own geometry from every camera angle in the room. Volumetric soft objects, sponges, fruit, bags, biological tissue, add a third dimension where internal compression and hidden bruising matter as much as the surface. Then there are the industrial edge cases: flexible printed circuit boards and composite textiles that need to bend without snapping an electrical trace, stacking mechanical give on top of electrical function.

Cloth-like deformable objects, CDOs, get the most research attention, mostly because fabric has almost no resistance to compression. Push on a steel block and it pushes back; push on a t-shirt and it just folds. That one property means grasp planning for cloth has almost nothing in common with grasp planning for a soft ball, even though both get lumped under "deformable" in casual conversation.

High degrees of freedom aren't just a math headache. They cause the self-occlusion and unpredictable state changes that break standard perception pipelines further down the chain. A taxonomy proposed in December 2024, called T-DOM, tries to fix the sloppiness by classifying the deformations themselves rather than just object shape, covering garments, ropes, and surgical gloves with enough detail to separate manipulation skills that older schemes lumped together. This matters practically because a method tuned for rope, with its predictable bending modes, tends to fail badly on fabric, where deformation couples globally across the whole surface. Over-generalizing from one class to another shows up again and again in the literature as a quiet, easy-to-miss failure mode. Each object class hands off a different problem to sensing and modeling, which is exactly where the next layer picks up.

The sensing problem: what the robot needs to know about an object it is already deforming

Three estimation problems have to get solved at once, and none of them wait politely for the others to finish. Where is the object's surface right now? How stiff or elastic or plastic is the material? And how is that shape and material state changing as the manipulation continues? A rigid-object system answers the first question once and moves on. A deformable-object system has to keep answering it, continuously, while the answer keeps changing because of the very actions the robot is taking.

Vision alone fails in predictable ways. Self-occlusion runs severe on CDOs, since a fold can hide a whole region of the object from every camera in the cell. Wet or specular surfaces, think surgical tissue, throw glare that confuses depth estimation. And no camera, however good, can see internal stress or subsurface deformation; a bruise forming inside a peach stays invisible until it isn't.

Tactile sensing fills part of that gap, catching force thresholds and surface changes that matter enormously for fragile objects, but current tactile sensors still have real limits on coverage, sensitivity, and telling one kind of contact from another. Force and torque signals compound the problem because they're low-dimensional: they tell the robot that contact happened, not where exactly or what the local surface is doing at that point. That ambiguity is a documented failure mode for vision-language-action agents working in contact-rich tasks.

Some recent hardware chips away at this. Stretchable tactile arrays with strain insensitivity, reported in Nature Communications in 2024, paired visual and tactile learning across 24 objects in 6 categories, mixing rigid and deformable items, and reached an average reconstruction error of 1.8 centimeters across all test sequences. Sit with that number, because it draws a line rather than just impressing. An error of 1.8 cm is plenty good for handling a garment or a bag at warehouse scale. It's nowhere close to good enough for threading a surgical suture or placing a component on a flexible circuit board, where tolerances run in fractions of a millimeter. Past that line, current tactile sensing works. Before it, it doesn't yet, and averaging across easier categories doesn't change that math one bit.

Soft grippers add their own wrinkle. A soft finger deforms continuously by design, which means the robot needs a separate estimation system just to know what its own finger is doing, a proprioception problem stacked on top of the object-sensing problem. Machine-learning approaches that recover 3D finger pose from distributed capacitive sensors are underway, and this remains an open problem. None of this sensor data means anything, though, without a model to turn it into something a planner can use, which is where modeling comes in.

Modeling deformable objects well enough to plan with them

Every model of a deformable object trades off three things: expressiveness, whether it can capture the actual deformation; accuracy, whether it matches the real physics; and speed, whether it runs fast enough to steer a controller in real time. Pick two. That's not a rhetorical flourish. It's the actual wall every lab in this space runs into, over and over.

Finite element methods, FEM, sit on the accurate end. They're physically grounded and reliable when the material parameters are known, but they're heavy to compute and need those parameters up front, a problem when the parameters are exactly what the robot doesn't know yet. Mass-spring systems trade some of that fidelity for speed; they're easier to set up and run fast, but they don't track real material behavior as closely, so a mass-spring model of cloth might handle draping fine and get bending stiffness wrong. Neural implicit representations and learned latent-state models sit at the other extreme: data-driven, able to generalize across shapes, but expensive to train and close to a black box once trained, turning any debugging session into a research project of its own.

There's a structural issue underneath all three approaches, and it's worth naming plainly: most state-of-the-art methods are one-trick ponies, built around hard-coded shape features that work for one deformation mode, say, bending a tube, and fall apart the moment the object or task changes. A model tuned to predict how a cable bends has no reason to say anything useful about how a garment drapes.

Material property estimation makes this worse in a genuinely circular way. Elasticity and plasticity are rarely known ahead of time, so the robot has to work them out from the first moments of contact, meaning the model needs sensor data to calibrate itself, and the sensor data needs a model to be read correctly in the first place. Each depends on the other being solved first, which is a neat trick if you can pull it off and a stall if you can't.

Then there's the sim-to-real gap, and it doesn't stay contained to the object. Joint friction, stiction, and backlash in a real robot hand are routinely under-modeled in simulation, so even a physically accurate model of the cloth or cable runs inside a physically inaccurate model of the hand holding it. Errors from both sides stack.

One practical way out: build a gripper that passively absorbs some of that deformation, so the model doesn't have to be perfect to still work, since mechanical compliance substitutes for model accuracy, at least partway. That trade is the better bet, and it's the argument for the next layer.

Gripper design as the hardware choice that determines how hard the rest of the problem is

Grippers run on a spectrum from rigid to fully soft, and where a design sits on that spectrum decides how much work the rest of the system has to do. Rigid parallel-jaw or multi-finger grippers are well understood and can apply serious force, but they need accurate models and tight control to avoid crushing something that shouldn't be crushed. Soft and compliant grippers flip that trade: passive shape adaptation cuts down on how much sensing and control the system needs, but soft fingers bring their own headaches around proprioception and force transmission, the same finger-pose problem raised in the sensing section. Soft-rigid hybrids try to get both, a rigid frame for force transmission with a compliant surface for contact; a scoping review from 2025 asks directly whether these hybrid designs are actually ready for industrial requirements, an open question at present. Universal jamming grippers, which stiffen a granular medium around an object to conform to its shape, are moving from lab demo toward industrial use, with recent work focused on tuning them for a wider range of object types.

Here's where the position stated up top earns its keep, and it's worth being blunt about which side of the trade wins: hardware that gives passively beats software that has to calculate everything. One concrete example from 2025: a compliant pneumatic gripper using a linear pneumatic muscle as the actuator. The compliance here is built into the structure, not bolted on through sensors or software, since the actuator itself just gives when it should. A pressure closed-loop through a proportional regulator handles the adaptation, which means the design skips the need for extra sensors or a complicated low-level controller. That's the whole argument in miniature: better hardware absorbs work the model or the controller would otherwise have to do, and it does it cheaper than another six months of system identification would.

Soft hands fit unstructured settings well, deformable object handling, rehab devices that touch human skin, contact-heavy industrial tasks, but coordinating multiple soft fingers still needs precise timing and spatial arrangement, which doesn't come free just because the material is forgiving. The RBO Hand 3 is a documented example of a soft dexterous platform built around this idea. And for anyone trying to compare gripper designs on equal footing, the MultiGripperGrasp dataset from 2024 offers a shared baseline: grasps across 11 grippers and 345 objects, spanning two-finger to five-finger hands including a human hand model, all checked in simulation.

Thin objects remain a hard case no matter the gripper philosophy. Current pneumatic grippers generally struggle to lift deformable textiles cleanly, which is why a 2025 method takes on the narrower problem of single-edge lifting for textile objects, using a gripper built specifically for flexible, porous materials. The lesson holds across the whole layer: choosing a softer gripper doesn't make the overall problem easier so much as it moves the difficulty somewhere else, usually back onto sensing and proprioception. Softer hardware is still the right trade. It just isn't a free one.

Planning a grasp when the object's state during execution cannot be fully predicted in advance

Classical grasp planning treats geometry as fixed: measure the object, compute a stable grasp, run it. Deformables break the premise at its root, since the act of grasping is what changes the geometry. Planning and execution can't be cleanly separated when the plan's own assumptions expire the moment the fingers make contact.

That raises problems rigid objects never bring up. The planner has to guess how the object will deform as the gripper approaches and applies force, pick grasp points that stay stable through that deformation rather than just at the starting pose, and often manage multiple contact points spread across a surface instead of one stable grip, since deformables frequently need distributed support to avoid folding, sagging, or tearing.

A useful reference point here is DexGraspNet 2.0, presented at CoRL 2024, which showed zero-shot sim-to-real transfer for dexterous grasping in cluttered scenes, hitting a 90.70% real-world success rate on a LEAP hand mounted on a UR-5, with no fine-tuning on real-world data at all. That number is genuinely strong, and it's worth asking why it isn't the end of the story. It's measured mostly on rigid objects in clutter, already a hard problem, but a different hard than deformables present. Whether that success rate survives once the objects start bending under the fingers is still open, and closing the gap between rigid and deformable performance is one of the field's live problems.

Not every deformable object wants to be grasped at all, either. T-DOM's taxonomy separates out non-prehensile manipulation, pushing, sliding, pinning, as its own category of skill, because for some objects nudging beats grabbing outright. A single sheet of paper on a flat table resists a rigid two-finger gripper, so sliding it to the edge first works better, and robots are starting to learn the same lesson. In-hand manipulation adds another layer of constant replanning: work presented at IROS 2024 by Yu et al. looked at in-hand following of deformable linear objects, routing a cable or suture through the fingers, which means the plan has to update the whole time as the object's shape shifts mid-task. The planning layer, more than any other, is where a weak model gets caught out; a plan is only as good as the physics it was computed against.

Adaptive control and learning: closing the loop when the model is never quite right

No model of a real deformable object is complete, so the case for learning-based control over pure model-based control is fairly direct: a controller that adjusts based on sensor feedback beats one that just runs a plan and hopes the plan was right, and it isn't close.

D3Grasp, from September 2025, is a useful data point here. It trains a grasping strategy that avoids penetration and stays kinematically feasible without needing manual demonstrations or an explicit object model, learning instead from simulated interaction. Reported results show a 95.1% average real-world success rate across both rigid and deformable object benchmarks, ahead of prior methods across categories. That's the strongest real-world number currently in circulation for this kind of task, and it holds up under perceptual uncertainty and real-world disturbance, which matters more than a clean lab number would. Take the word "average" seriously, though. A category average of 95.1% can bury weaker numbers on the hardest deformable subsets inside a rounding error, so check the benchmark's scope before pinning that figure onto, say, surgical tissue handling.

A few other approaches show how domain knowledge gets baked directly into the learning signal rather than into the model. T-TD3, published in 2025 in IEEE Transactions on Automation Science and Engineering, is a reinforcement learning setup built specifically for stable grasping of deformable objects, using a tactile prior to keep training on track. Stress-guided RL, also from 2025, adds a stress-penalized term to the reward function itself, so the system gets discouraged from damaging fragile objects as part of how it learns, ahead of any safety filter applied afterward. And sim-to-real RL work slated for 2026 combines dense tactile feedback with joint torque sensing specifically to regulate physical contact during the sim-to-real jump, going straight at the coverage gaps that low-dimensional force signals leave behind.

Surgery is probably the sternest test case going. Work from 2024 reported the first successful visual sim-to-real transfer for deformable object manipulation in a surgical setting, notable because surgical tissue is fragile, the sterile field imposes hard limits on what the robot can touch and how, and the precision needed sits right at the edge of what current sensing can deliver.

The open problem across all of this is generalization, and it's the one nobody's papered over yet. Most of these policies get shown off on one object or one narrow category, and scaling that up to the full range of deformable objects a real facility handles, garments one day, produce the next, cable harnesses the day after, needs either huge amounts of training data or representations that carry over cleanly across different deformation modes. Neither exists yet in a form the field agrees is solved.

How the layers compound: why failure in one part of the system propagates through all the others

Trace the dependency chain and the shape of the whole problem becomes obvious. Sensor uncertainty feeds a corrupted state estimate into the model. An imprecise model hands the planner assumptions that are already wrong before the plan is even computed. The controller can patch some of that in real time, but only within the limits of what the sensing and the gripper hardware can actually recover; a controller can't fix information it never got in the first place.

Fragility is the clearest illustration of why this has to be treated as one system and not five separate ones. Keeping a robot from crushing a strawberry or tearing a suture line means the fragility constraint has to survive being passed from hardware compliance, through the sensing threshold, into the model's picture of internal stress, into the planner's cost function, and finally into the controller's reward signal. Skip that constraint at any single layer and the other four can't fully cover for it; a stress-aware reward function does nothing if the tactile sensor never caught the stress to begin with.

The sim-to-real gap follows the same logic, and it isn't one gap so much as a stack of smaller gaps piled on top of each other. Object physics in simulation is an approximation, tactile sensor behavior in simulation is a further approximation, and robot joint dynamics, friction, and backlash get approximated again on top of that. Each approximation is manageable on its own; the trouble comes from the compounding, so a policy trained in simulation is really trained against layered approximations of the real world, and the final real-world performance number reflects all of that error landing at once. That's the honest way to read every success-rate figure in this piece: the 90.70%, the 95.1%, the 1.8 centimeters. Each is a snapshot of how far the compounding has been pushed back, not proof that any single layer is finished, and the softer, cheaper hardware fix argued for here is still the fastest way to push it back further.