# A Paradox Named Moravec
In the 1980s, AI researcher Hans Moravec arrived at a startling observation now known as Moravec's Paradox: high-level reasoning is surprisingly easy for machines, while low-level perception and motor skills are surprisingly hard. In plain terms, computations we consider "intelligent" (logic, chess, translation) are simpler for a computer than the things a three-year-old does without thinking (walking, seeing, grasping an object).
Why? Because high-level mental processes are far newer in evolutionary terms — and perhaps we find them "hard" only because they're new for humans. But perception and motor skill are the product of hundreds of millions of years of evolutionary optimization — and we're not even aware of all their subtleties. When a child picks up a cup, they're running a control program no engineer has yet fully replicated.
Key insight: The problem isn't just a lack of AI. The problem is that the real world is dirty, continuous, uncertain, and physical — and software was never designed for such a world.
# The Robot Brain Lives in a World of Numbers
Let's simplify the problem. Suppose we give an AI model an image and tell it the picture shows a cup on a table. The model can respond with very high confidence:
vision_model.output
Object = Cup
Position = (x, y)
Class = Container
Confidence = 0.98
At the software level, the problem is clean and tidy. But a robot must face a real physical world, and every stage adds new uncertainty:
?
Where is the cup? — Vision
Camera calibration error, perspective, occlusion
?
Where should the hand go? — Grasp planning
Countless possible contact points, each with a different outcome
?
How fast to move? — Inverse kinematics
Joint limits, obstacles, real-time constraints
!
How much force to apply? — Contact control
Too much: it breaks. Too little: it drops
!
Is the cup slipping? — Tactile feedback
Detecting slip before it happens, within milliseconds
In the software world,
x = 100 means exactly 100. But in the physical world, something that was supposed to be 100 is slightly different due to vibration, friction, mechanical compliance, sensor error, motor latency, and changing contact surfaces. The computer works with numbers; the robot must work with reality.
# The Human Hand: A Mechanical Masterpiece
We usually think of the human hand as just a "grasping tool." But from an engineering perspective, it's close to a mechanical masterpiece:
27
bones in each hand
21–27
degrees of freedom (depending on kinematic model)
~17,000
tactile sensory units in the palm
30+
muscles involved in hand and wrist control
A large number of independent or nearly independent movements must be coordinated simultaneously. For comparison, consider a single finger: it has several joints with different ranges of motion, it isn't fully independent when moving, it's coupled with other tendons and muscles, and it constantly receives information through skin and touch. Now imagine this problem for five fingers. Then add the wrist. And now imagine all of these must be coordinated within a fraction of a second.
This means a simple human command — "pick up the cup" — in reality becomes a 9-stage engineering chain. Let's see each stage in plain language:
1
Vision — seeing
The camera sees the cup, the table, and the surroundings
2
Object Detection
Which parts of the image belong to the cup?
3
Pose Estimation
Where exactly is the cup, and at what orientation?
4
Grasp Planning
From which point, and with what finger configuration, should we grab?
5
Inverse Kinematics
What angle must each hand joint take to reach that point?
6
Trajectory Planning
At what speed and along which path should we approach the cup?
7
Motor Control
Sending commands to the motors, in real time
8
Force Control
Not so hard that it breaks, not so soft that it drops
9
Tactile Feedback
Sensing slip and movement, and correcting within milliseconds
All 9 stages must execute within a fraction of a second and without error — and failing at even one of them means the cup is dropped or broken.
# The Robot Mustn't Just "Move" — It Must Understand Force
Suppose you're holding a tennis ball. You just close your hand. But what if it's an egg instead of a tennis ball? The movement is nearly identical, but the required force is completely different:
Too much pressure → the egg breaks
Too little pressure → the egg drops
So the robot must know more than position. It must know "how much force am I applying right now?" and, even more importantly: "what effect is this force having?" This is where the sense of touch comes in.
Recent research has shown that high-resolution tactile sensors can significantly improve a robotic hand's ability to grasp and manipulate real objects. For example, a study in Nature Machine Intelligence introduced a robotic hand with extensive tactile coverage that uses very dense sensors for contact detection. The robot of the future doesn't just have "eyes" — it must also have skin.
# Humans Have a Cheap, Extraordinary Sensor: Skin
When you touch an object, your brain doesn't just have an image of it. Your skin tells you:
◈
Pressure
Magnitude and distribution of force across the contact surface
◈
Vibration & slip
Detecting micro-movements before the object falls
◈
Temperature
Identifying surface material and danger
◈
Force direction & contact area
Understanding interaction geometry without looking
For instance, when you push a phone across a table, you notice it has moved even without looking. Why? Because your hand senses extremely small changes in force. A typical robot, however, might need multiple sensors to obtain just part of this information.
And now a new problem: where should these sensors go? Fingertip? Side of the finger? Palm? Inside the joint? Outer surface? And if we add sensors:
sensors.log
Sensors ↑ → Weight ↑ → Wiring ↑
→ Processing ↑ → Failure Points ↑ → Cost ↑
So building a robotic hand isn't just about "adding motors." Every new capability can create new complexity.
# Where Do We Put the Motors?
Here one of the hardest design problems begins. Humans didn't put their motors in their hands. A significant portion of the muscles controlling the fingers are located in the forearm, and force is transmitted to the fingers through tendons. This design has a tremendous advantage: the finger stays light.
A robot can use a similar idea; for example, moving the motor away from the finger and transmitting force through cables or transmission mechanisms. But new problems immediately appear:
tendon_drive.warnings
Cable → Elasticity → Friction → Backlash
→ Position Error
Meaning the robot thinks the finger is in a specific position, but the actual mechanics differ slightly. In an industrial arm, this small discrepancy might be tolerable. But at a fingertip, it can be the difference between "a correct grasp" and "dropping the object."
# The Strange Problem of the "Last 20%"
In robotics there's a crucial pattern: the first part of a task is usually easy; the last part can be extremely hard. Suppose a robot must pick up a box from a table. 80–90% of the work might be simple:
phase_1 — easy.log
✓ See the box
✓ Move the arm
✓ Approach
✓ Position around the box
But then we reach the final part — where the real problem reveals itself:
phase_2 — hard.log
! Initial contact
! Force adjustment
! Micro-slip
! Finger correction
! Center-of-mass shift during lift
Why? Because physical contact can't be described by a fixed program. Two cups may look identical, yet one is slightly wetter, heavier, smoother, or more slippery. So the robot must constantly run this cycle:
control_loop.py
while not stable:
sense() → act() → sense() → correct()
This is no longer a simple movement — it's a closed control loop that must run in real time and under uncertainty.
# The Robot Must Be Both the "Hand" and the "Control Engineer"
To grasp an object, defining joint angles isn't enough. Suppose we define joint positions like this:
hand_state.py
q = [q_thumb, q_index, q_middle, q_ring, q_little]
# this vector is only part of the problem
The robot must simultaneously know:
position, velocity, force, torque, contact, slip — and then a controller must decide in real time:
controller.py
error = target - current
while error > threshold:
adjust_motor()
read_tactile()
estimate_force()
But even this is a major simplification. Because the real model must deal with joint dynamics, friction, compliance, sensor latency, and object behavior. In recent research, even manipulating simple objects with a robotic hand requires combining reinforcement learning, dynamics modeling, and tactile sensors.
# The Invisible Problem: Energy
Let's assume we want to build a truly powerful, fast, and precise robotic hand. Naturally, we add more motors. But:
design_spiral.log
Motor ↑ → Torque ↑ → Weight ↑
→ Power Consumption ↑ → Heat ↑
while weight > limit:
Motor ↑ → Battery ↑ → Weight ↑ → Motor ↑
A strange loop forms: when weight goes up, more powerful motors are needed; a stronger motor means a bigger battery; a bigger battery means more weight; and back to the start. In wearable systems and prosthetics this issue is very serious; recent research shows that actuator power density is one of the key constraints for building hands with high degrees of freedom and low weight.
Meaning even if we know what the hand should do, we still don't necessarily know how to deliver the required energy at an acceptable weight.
# Why Is a Simple Robotic Arm Easier Than a Humanoid Hand?
This distinction matters a lot. An industrial arm might have only six axes and work in a fully controlled environment:
The box is nearly always the same shape. The camera position is fixed. The work surface is defined. Lighting is controllable. The motion path is predictable.
But a humanoid hand must handle a phone, a cup, a screw, a piece of cloth, a spoon, an egg, a key, a card, a ball — all of them — with one general-purpose system. And here the gap becomes enormous:
Industrial arm: ~6 axes — one controlled, predictable world
Humanoid hand: 21+ DOF — an unlimited, undefinable world
The fundamental difference: the industrial arm is designed for a limited world. The human hand was designed for a world whose every state no one can define in advance.
# The Robotic Hand Must Actually Be an "Intelligent Body"
This is where a common misconception forms. We usually think about robots like this:
naive_architecture.txt
AI ↓ Robot
But in reality, for physical interaction we need something like this:
L7
AI — Decision-making
Goal understanding, planning, learning
L6
World Model
Predicting physics and consequences
L5
Motion Planning
Paths, timing, obstacle avoidance
L4
Control System
Real-time closed loops
L3
Actuators
Motors, grippers, force transmission
L2
Mechanical Body
Compliance, geometry, materials
L1
Sensors + Tactile Feedback
Electronic skin, force sensing, feeding back to AI
Meaning the robot's intelligence isn't only inside the GPU. Part of the intelligence must exist in the body itself. The hand's mechanics, finger compliance, sensor layout, and even the fingertip's shape can determine what the robot can learn and how it interacts with the world.
This is why recent research has moved toward soft designs, compliant structures, and integrated tactile sensors; these approaches can shift part of the control complexity into the physical structure itself.
# Maybe the Solution Isn't Building a "Human Hand"
This part is more interesting. We might assume that to build a better robot, we must copy the human hand exactly. But that may be wrong. Humans developed their hand over millions of years of evolution; the robot doesn't have to take the same path. For example, a robot can:
1. Have fewer joints.
2. Use underactuated fingers — mechanisms that produce naturally adaptive behavior with few motors.
3. Use soft materials for contact.
4. Distribute tactile sensors over a wide area.
5. Use learning to compensate for mechanical errors.
2. Use underactuated fingers — mechanisms that produce naturally adaptive behavior with few motors.
3. Use soft materials for contact.
4. Distribute tactile sensors over a wide area.
5. Use learning to compensate for mechanical errors.
In fact, one active research direction is exactly this: instead of adding endless joints and motors, leverage the cooperation of mechanics, sensors, and software. A soft hand with a limited number of actuators may outperform a hard, highly complex one in certain tasks. Studies published in Nature Communications have also shown that combining soft fingers with palm tactile sensors can create advantages for grasping and object recognition.
# The Real Problem Isn't "Intelligence" — It's the "Body"
This is perhaps the most important conclusion of this discussion. For years we assumed the path to intelligent robots looked roughly like this:
old_assumption.txt
better_AI ↓ better_robot
But reality looks more like this:
reality.txt
intelligence + vision + touch + actuators
+ mechanics + control + energy + body
↓
real robot
If we only improve AI but the hand still can't control the right force, the problem isn't solved. If we build extraordinary motors but have no sensors, the problem isn't solved. If we have excellent sensors but the controller can't respond in real time, the problem still isn't solved.
Unlike software, robotics is a chain: the weakest link can limit the entire system.
# So Why Is the Robot's Brain Easier to Build Than Its Hand?
Because the brain mostly deals with information; the hand must deal with reality.
The brain can say "this is a cup" — but the hand must prove it can actually hold it. The brain can compute a path — but the hand must cope with real friction, real weight, real vibration, and the object's real surface. The brain can make millions of decisions in a simulator — but the robotic hand must execute those decisions in the real world with motors, gears, cables, wires, batteries, sensors, and heat.
And that is a very big difference.
# The Future of Robotics May Not Start with a "Bigger Brain"
The next wave of robotics probably won't be built from larger AI models alone. We need robots that:
1. See better
2. Touch better
3. Sense force better
4. Consume less energy
5. Weigh less
6. And have smarter mechanics
2. Touch better
3. Sense force better
4. Consume less energy
5. Weigh less
6. And have smarter mechanics
New research is moving in exactly this direction: hands with denser tactile sensors, better actuators, compliant mechanisms, and learning methods that can use physical data for finer control.
Perhaps the biggest leap in robotics will finally happen when we realize the problem isn't that robots aren't smart enough yet — the problem is that their bodies aren't yet as smart as their brains.
takeaway.txt
The robot learned to think;
now it must learn to feel.
Building a brain is hard —
building a hand is harder.
now it must learn to feel.
Building a brain is hard —
building a hand is harder.
