An Octopus Inspired Soft Arm That Grasps By Feel

Why a robot should think with its arms

Most robots are built like a person giving orders to their hands. A central computer takes in everything the sensors report, works out what to do, and sends commands back out to the motors. This works beautifully in a factory, where the world is tidy and predictable. It works far less well underwater, in a pile of rubble, or anywhere messy and unstructured, because the central controller becomes a bottleneck. Every scrap of sensory data has to travel to the middle, get processed, and travel back, and as you add more sensors the traffic jam gets worse.

Biology solved this a long time ago by not centralizing everything. The octopus is the showpiece. Its eight arms are lined with suckers, each richly wired with nerves, and a large share of its nervous system sits out in those arms rather than in the central brain. When an arm touches something, local neural circuitry can trigger a grip reflex immediately, and a mid level system coordinates across the suckers, all without a round trip to the brain. The brain sets high level goals, but the arms handle the details. This is called distributed or peripheral control, and it is exactly the property that lets an octopus manipulate the world so fluidly.

Emanuela Del Dottore, Barbara Mazzolai, and their colleagues set out to build that idea into hardware. Soft robotic arms inspired by the octopus already existed, but they faced a stubborn tradeoff. Adding rich touch sensing to the suckers usually meant bulky electronics, thick wiring, or a reliance on an external computer to make sense of the signals, all of which fight against the softness and compactness that make these arms appealing in the first place. The challenge was to give every sucker a real sense of touch, including the direction of a contact, without ruining the soft body or drowning a central processor in data.

A suction cup that feels with light

The heart of the system is a suction cup that can feel. Rather than a pressure gauge or a camera, each cup uses light. Embedded in the stalk of the cup is a small circular board carrying three light emitting diodes and three light sensitive phototransistors, arranged alternately at one hundred and twenty degree spacing, all facing a reflective surface. When the soft cup presses against an object, the silicone deforms and changes how the light bounces back to each phototransistor. Read the three signals and you can recover not just how hard the contact is but which way it points.

The trick that makes this compact is that the sensor lives entirely inside the cup, with no external processing needed to interpret it. The force comes from a simple linear relationship with the summed light signal, and the direction comes from combining the three channels as a vector. The team measured a sensitivity around four hundred millivolts per newton in the zero to two newton range, which is the gentle regime that matters for handling delicate objects, and a directional accuracy with errors under eighteen degrees, dropping to an average under eight degrees near the rim. The sensor held up over hundreds of loading cycles with little drift, and endured tests of ten thousand cycles under load, and crucially it worked the same in air and underwater.

Two small design choices make this robust. A white colorant added to the base of the cup directs the light toward the phototransistors, and a black silicone layer shields the sensor from stray outside light. The team also subtracts the reading taken with the diodes off from the reading with them on, which cancels out ambient light, so the same cup works under changing illumination. These are the unglamorous details that decide whether a clever idea survives contact with the real world.

The suction cup design and material were optimized to achieve high sensitivity at low contact forces, aligning with the mechanical properties of the soft arm, which inherently limit the maximum contact force, especially at its periphery. Del Dottore and colleagues, on designing for gentle contact

From three light signals to a grasp

The math that turns raw light into a decision is refreshingly simple, which is part of why it can run on tiny microcontrollers in the arm. For a single cup, each phototransistor signal is treated as a vector pointing in that sensor’s direction, and their sum gives the direction of the contact.

Here \(\mathbf{v}_{ij}\) is the contribution of phototransistor \(i\) on cup \(j\), and \(\alpha_j\) is the recovered contact angle for that cup. Then, to judge how the whole object is oriented relative to the arm, the contact directions from all ten cups are combined into one cumulative direction, and the object inclination follows as the angle of the normal to it.

The angle \(\beta\) captures whether the object lies perpendicular to the arm, where \(\beta\) is near zero, or runs along it, where \(\beta\) approaches ninety degrees. That single number is enough to choose a grasping strategy. This is the elegance of the approach. A rich pattern of touch across ten cups collapses into one interpretable quantity that a simple rule can act on.

Two layers of control, borrowed from the octopus

The control mirrors the octopus’s nervous system in two tiers. At the bottom sits what the authors call the local neural circuitry, one per suction cup. When a cup’s light signal rises above a threshold, meaning it has genuinely touched something, that cup immediately fires its own suction to grab on. This is a reflex, fast and local, and it does not wait for permission. It is the robotic version of a sucker clamping down the instant it feels prey.

Above that sits the peripheral layer, the stand in for the octopus’s peripheral nervous system. It watches the contact directions coming in from all the cups over a short window of about four seconds, computes the object inclination \(\beta\), and decides how the whole arm should move. Based on which cups are touching and the value of \(\beta\), it picks from a small set of behaviours. If the object is near the tip, the arm bends dorsally. If a single cup near the base touches, it bends ventrally. If several cups contact and the object lies at an angle, the arm twists clockwise or counterclockwise to wrap around it. When needed, this peripheral layer can override the local reflexes, for instance keeping suction active only on the cups that matter for the grasp.

What the current system deliberately leaves out is a central brain. There is no equivalent of the octopus’s central nervous system coordinating multiple arms or planning far ahead. The authors focus on a single arm imitating the peripheral layer, which is the part that makes distributed grasping work. It is an honest scoping choice, and it keeps the demonstration focused on the idea that matters, that a soft arm can grasp intelligently using local sensing and mid level coordination alone.

What it can actually do

The arm itself is a soft cone about forty one centimeters long, tapering from four centimeters wide at the base, cast in silicone and lined with ten suction cups in three sizes that shrink toward the tip. Three tendons pulled by motors bend and twist it, and a rotating joint at the base lets it sweep around to search its surroundings. It is close to neutrally buoyant, so it moves naturally underwater. Small water pumps supply the suction. All of the sensing and control runs on microcontrollers distributed along the arm and a master board at the base, with an external computer used only for watching the data during debugging, never for driving the grasp.

In underwater tests, the arm autonomously grasped a range of objects, cylindrical bottles, smaller items, and irregular shapes, placed at different positions and orientations. It could run a search behaviour, sweeping with its base joint until a cup detected contact, then reading the object’s pose and choosing a grasp. It correctly discriminated where along its length a touch happened and which direction it came from, and used that to reorient toward the object and wrap around it.

One nice demonstration had the arm grasp a small box holding a hundred gram weight, which weighs about eighty five grams force once buoyancy is subtracted underwater. Using only the touch signal and the calibrated relationship between light and force, the arm estimated the weight at around seventy two grams force, close enough to be useful. Being able to feel how heavy a grasped object is, without any scale or camera, is the kind of capability that distributed touch makes almost free.

Reproducing the sensing and grasp logic

The physical arm needs silicone casting and custom electronics, but the computational core, turning three light signals per cup into a contact direction, an object pose, and a grasp choice, is compact and reproducible. The implementation below writes exactly that pipeline. It models the optoelectronic response of each cup, recovers the contact direction from the three signals as the paper does, aggregates across cups into the object inclination, and applies the hierarchical grasp rules. A runnable smoke test checks that the recovered direction lands within the paper’s reported accuracy and that the grasp logic follows the stated rules.

# Distributed tactile sensing and hierarchical grasp selection, the
# computational core of the octopus-inspired arm from Del Dottore,
# Adhami, et al., "Peripheral control enabled by distributed sensing in
# an octopus-inspired soft robotic arm for autonomous underwater
# grasping" (Nature Machine Intelligence 2026). This is a sensing and
# control pipeline, not a trained network. It implements the paper's
# equations for contact direction, object pose, and grasp choice.

import torch
import math

# Three phototransistors per cup at 0, 120 and 240 degrees.
PHI = torch.tensor([0.0, 2 * math.pi / 3, 4 * math.pi / 3])
S_MAX = 66.7          # signal in mV at 0.5 N, from the paper
U_TH = 0.25           # normalized threshold that triggers local suction


def cup_signals(alpha, force_frac, noise=0.06):
    """Optoelectronic response of one cup to a contact from direction alpha.

    Each phototransistor reads a maximum when the contact points toward
    it and a minimum opposite, a raised cosine, scaled by contact force.
    """
    resp = 0.5 * (1.0 + torch.cos(alpha - PHI))
    sig = S_MAX * force_frac * resp
    sig = sig + noise * S_MAX * torch.randn(3)
    return torch.clamp(sig, min=0.0)


def contact_direction(sig):
    """Equations (1) and (2). Vector sum of the three channels, then angle."""
    vx = (sig * torch.cos(PHI)).sum()
    vy = (sig * torch.sin(PHI)).sum()
    mag = torch.sqrt(vx ** 2 + vy ** 2)
    return torch.atan2(vy, vx), mag


def object_inclination(cup_dirs):
    """Equations (3) and (4). Cumulative contact direction to object pose.

    Directions in the lower half plane are reflected up before summing,
    so the pose is defined on a half circle, matching the paper.
    """
    rx = sum(math.cos(a) for a in cup_dirs)
    ry = sum(abs(math.sin(a)) for a in cup_dirs)
    return (math.atan2(ry, rx) + math.pi / 2) % math.pi


def select_grasp(contacted, beta_deg):
    """Peripheral layer rules. contacted is the set of cup indices (0 to 9)."""
    distal = {7, 8, 9}                       # the three cups nearest the tip
    if any(i in distal for i in contacted): return "dorsal_bend"
    if len(contacted) == 1:                    return "ventral_bend"
    if len(contacted) > 4:                     return "suction_only"
    if beta_deg > 160 or beta_deg < 20:      return "ventral_bend"
    if 20 <= beta_deg <= 80:               return "clockwise_twist"
    if 100 <= beta_deg <= 160:             return "counterclockwise_twist"
    return "suction_only"


def smoke_test():
    """Check direction accuracy against the paper and verify grasp rules."""
    torch.manual_seed(0)

    # Direction accuracy over many random contacts.
    errors = []
    for _ in range(500):
        true_alpha = torch.rand(1).item() * 2 * math.pi - math.pi
        est, _ = contact_direction(cup_signals(torch.tensor(true_alpha), 0.8))
        d = abs((est.item() - true_alpha + math.pi) % (2 * math.pi) - math.pi)
        errors.append(math.degrees(d))
    mean_err = sum(errors) / len(errors)

    # Grasp rules on representative scenarios.
    scenarios = [
        ([0, 1, 2], 45, "clockwise_twist"),
        ([3], 10, "ventral_bend"),
        ([8], 90, "dorsal_bend"),
        ([0, 1, 2], 130, "counterclockwise_twist"),
        ([0, 1, 2], 170, "ventral_bend"),
    ]
    grasps_ok = all(select_grasp(c, b) == e for c, b, e in scenarios)

    assert mean_err < 8.0, "direction error should match the paper"
    assert grasps_ok, "grasp rules should follow the paper"
    print("mean contact direction error {:.1f} deg  (paper avg under 8)".format(mean_err))
    print("hierarchical grasp rules all correct")
    print("smoke test passed")


if __name__ == "__main__":
    smoke_test()

The honest note is that this is the arithmetic, not the arm. Real suction cups deform in messy ways, the light response drifts a little, and tendon pulls add crosstalk to the signals that the real controller has to tolerate. The mechanism is faithful, though. Three light channels become a contact direction, the directions across cups become an object pose, and a handful of rules turn that pose into a bend or a twist, which is exactly the pipeline the arm runs on its embedded boards.

Honest limitations

The authors are clear about what this prototype does not yet do. The grasping strategies are deliberately simple and not optimal, chosen to prove the concept rather than to handle every situation. The experiments used mostly cylindrical or small lightweight objects that do not float, and the authors say plainly that a wider set of objects, including heavier and floating ones, is future work. The near neutral buoyancy that makes the arm move so nicely underwater is also a convenience that a real application might not always enjoy.

There is also honest engineering messiness. Pulling the tendons to move the arm creates crosstalk in the sensor signals, since bending the soft body changes the light readings even without a new contact. The team turns this partly to their advantage, noting that the crosstalk is repeatable and could be used to infer the arm’s own posture in future work, but it remains a complication. And the current system models all target objects as similar cylindrical shapes, a simplification that let the demonstration succeed but that a general grasping system would have to move beyond.

The deeper limitation is scope, and the authors name it. There is no central brain, no coordination across multiple arms, and no long horizon planning, all of which a truly octopus like system would need. What they have shown is that the peripheral layer works, that a soft arm can sense and grasp autonomously through distributed touch. Building the higher levels on top, ideally with neuromorphic hardware that could jointly interpret touch and posture the way real neural circuits do, is the road ahead rather than a finished journey.

What this changes for soft robotics

The practical promise is machines that can work by feel in places cameras struggle, murky water, cluttered debris, the inside of a pipe, anywhere vision is blocked or unreliable. A soft arm that grasps through touch alone, with the sensing and quick decisions handled locally, is well suited to exactly the unstructured, delicate tasks that rigid centralized robots handle poorly. Underwater inspection and gentle sample collection are the obvious near term uses, and the compactness of the sensor means the approach could scale to arms with many more suckers.

The wider idea is architectural. By pushing perception and reflexes out to the periphery and sending only distilled information toward the center, the design sidesteps the communication and computation bottleneck that grows as you add sensors. That instinct, keep the fast loops local and reserve the center for coordination, recurs across robotics wherever contact and dexterity matter. For readers following that thread, this work sits alongside other robotics on the site that grapples with touch and manipulation, from the contact physics of friction under a robot gripper and the release dynamics of a robot throwing an object to how robots learn manipulation in the DySL-VLA model. You can browse the wider set through the robotics and autonomous systems pillar.

Conclusion

The core achievement of this work is a soft robotic arm that senses and grasps the way an octopus does, through distributed touch and local decision making rather than a central controller watching a camera. By embedding a compact optical sensor in every suction cup that reads both the force and the direction of a contact, and by layering a local grip reflex under a peripheral coordinator, the arm autonomously grasped objects underwater using feel alone.

The conceptual shift is from centralized to peripheral control. Where a conventional robot funnels all sensing to one processor and back, this arm handles the fast loops where the contact happens and sends only a distilled sense of the object toward the center. That is what lets it scale sensing to many cups without a bottleneck, and it is a direct lesson from the animal, whose arms do most of the thinking about grasping on their own.

The ideas reach beyond underwater grasping. The same distributed sensing and reflex plus coordination recipe applies to any soft manipulator that has to work by touch in a cluttered or invisible environment, and the optical suction sensor is compact enough to multiply across larger arms or whole gripping surfaces. Because the approach is agnostic to the exact body, adding sensing is a matter of adding cups rather than rebuilding the controller.

The limitations keep it honest. The grasping strategies are simple proofs of concept, the objects were mostly cylindrical and light, tendon motion muddies the signals, and there is as yet no central brain or multi arm coordination. None of this undercuts the demonstration, but it marks it as a strong foundation for a more capable system rather than the finished article, and the authors point clearly toward richer strategies and neuromorphic processing as the next steps.

What lingers is how much intelligence can live in a body rather than a brain. An octopus grabs a crab with its arm before its central brain has fully weighed in, and this robot shows that a machine can borrow that arrangement, feeling its way to a grasp with sensing and reflexes spread through a soft limb. Give a robot the right kind of body, wired to feel and to react where it touches the world, and it needs a lot less thinking at the center to do something genuinely useful.

Frequently asked questions