4.1 — Joint-Space and End-Effector Action Representations

Learning objectives

After this lesson, you should be able to:

• Distinguish joint-space and end-effector actions.
• Explain the difference between absolute and delta actions and what each does after a lost command.
• Explain why hand-space actions transfer better between different arms.
• List the cost of end-effector actions.

The one-sentence idea

An action definition is a contract between data, model and robot.

Joint space is robot-specific; hand space is shareable but needs conversion.

Two ways to say “move there”

An arm can be told what to do in two languages. In joint space you say what every joint angle should be (“shoulder 30°, elbow 90°”). In end-effector space you say where the hand should be (“2 cm to the right, 1 cm down”) and let a controller work out the joints. You met the geometry behind this in the kinematics prerequisites; this lesson asks which one a policy should output.

Both are used. ACT, trained on a two-arm low-cost robot, uses the joint positions of the human operator’s “leader” arms as its actions: 7 numbers per arm (six joints and a gripper), so 14 numbers for two arms.^[1] A policy and a dataset must agree on this definition, which is why lesson 3.1 told you to always ask what the numbers mean.

Absolute targets versus deltas

A second choice cuts across the first: should an action say where to go (an absolute target) or how much to move (a delta)? The difference shows up when something goes wrong. Imagine the robot misses a command, for example because the controller was busy. With deltas the missed motion is gone forever; with absolute targets the next command still aims at the right place:

import numpy as np
rng = np.random.default_rng(0)

plan = np.linspace(0.0, 1.0, 11)                      # the intended path of one joint: 0 -> 1 in 10 steps
drop = {4}                                             # the robot misses the command at step 4

def run(mode):
    pos = 0.0
    for t in range(1, 11):
        if t in drop:
            continue                                   # command lost
        if mode == "delta":
            pos += plan[t] - plan[t-1]                 # "move this much"
        else:
            pos = plan[t]                              # "go to this place"
    return pos

print("goal: 1.0")
print("delta commands end at   ", round(run("delta"), 3))
print("absolute targets end at ", round(run("absolute"), 3))

goal: 1.0
delta commands end at    0.9
absolute targets end at  1.0

Toy model. A single joint and one lost command, to show the principle. Real controllers add their own tracking error, which deltas also accumulate.

Absolute targets forgive mistakes; deltas let them accumulate (lesson 1.1). On the other hand, deltas are small numbers that look similar across scenes, which can make learning easier. Which is better depends on the robot and data, and the choice has to be written down as part of the dataset.

Why end-effector actions travel better between robots

Joint angles belong to one particular arm. The same hand path needs different joint angles on arms with different link lengths. A hand-space action means the same thing for both, and each robot converts it using its own geometry. Here two arms with different proportions follow the same hand target:

import numpy as np

def ik(target, L1, L2):
    x, y = target
    d2 = x*x + y*y
    cos_q2 = (d2 - L1*L1 - L2*L2) / (2*L1*L2)
    q2 = np.arccos(np.clip(cos_q2, -1, 1))
    q1 = np.arctan2(y, x) - np.arctan2(L2*np.sin(q2), L1 + L2*np.cos(q2))
    return np.degrees([q1, q2])

target = (1.2, 0.6)                                    # where the hand should be, in metres
for name, (L1, L2) in (("arm A (equal links)", (1.0, 1.0)), ("arm B (short upper link)", (0.8, 1.2))):
    print(name, "-> joint angles (degrees):", np.round(ik(target, L1, L2), 1).tolist())

arm A (equal links) -> joint angles (degrees): [-21.3, 95.7]
arm B (short upper link) -> joint angles (degrees): [-35.7, 98.4]

One hand target, two sets of joint angles. A model that outputs hand motions can be trained on both robots’ data; one that outputs joint angles cannot without conversion. This is part of why mixing data from many robots, as the Open X-Embodiment collaboration did with 22 robot embodiments,^[2] needs care over the action definition. The price of end-effector actions is the conversion step, which can fail near singular poses or outside the arm’s reach, and the robot interface (lesson 9.2) must handle that.

Common misconceptions

Engineering takeaways

1. Joint vs hand space.
2. Absolute vs delta.
3. Hand-space actions are easier to share across arms.
4. Document the definition with the dataset.

Say what the numbers mean before you train on them.

Knowledge check

Try each question first, then reveal the explanation.

What’s next

Next: whether to treat actions as words in a vocabulary or as real-valued vectors.

Back to the VLA roadmap