Every arm move on a backend that adopts it is paced at the controlled point and
checked for an unrequested wrist turn before anything moves. The semantics are
Yulun's RoboDojo toolkit timing (tools/move_pose/_smooth.py), so a backend whose
global planner answers a joint path (any planner) times it the same way. Two implementations hold them:
the TOPP-RA + Ruckig timing worker, the default, and
ora/environment/controllers/motion_pace.py, the hand-written port, the
fallback for an environment without the timing
interpreter. Every paced move's receipt says which one ran.
The request
ora.contracts.motion_speed holds the request both the agent and the
environment read. A policy call may name:
| Argument | Meaning |
|---|---|
speed |
fast (the default), normal or careful |
speed_m_s |
instead of speed: any top speed of the controlled point above 0 m/s |
slow_approaching |
true also holds the last 2 cm of each arm's path to careful, entered without a stop; refused with careful and with speed_m_s at or below 0.1 m/s |
| Preset | Controlled point | Reached in | Joints (every joint, the ceiling) |
|---|---|---|---|
fast |
no Cartesian cap | — | 4 rad/s, 40 rad/s² (RoboDojo, ARX X5 motion profile v2: 4.5 rad/s, 60 rad/s², certified at 5000 rad/s³; profiles) |
normal |
0.3 m/s, 60 deg/s | 1 m/s², 200 deg/s² | 2.5 rad/s, 15 rad/s² |
careful |
0.1 m/s, 20 deg/s | 0.5 m/s², 100 deg/s² | 1.2 rad/s, 8 rad/s² |
speed_m_s = v |
v m/s, max(20, 200 v) deg/s | both in 0.25 s | fast's (the preset's 4 rad/s and 40 rad/s², whatever a robot profile names) |
A backend lowers the joint caps to what its executor can follow and never
raises them, so speed is limited at the controlled point first and each joint
stays the ceiling: a fast request may not be reached, a slow one practically
always is. A speed never picks a path: the interaction label does, at every
speed, so a slow free_space or a slow precision move past 5 cm or 15 degrees
takes the planned route, capped along the whole of it.
The motion action carries the request as the optional speed of an
ora-motion-action.v3 move_pose ({"speed": preset or "custom", "slow_approaching": bool}, plus speed_m_s with custom). A call that names
no speed option carries no speed and runs at the default.
Pacing a planner's path
motion_pace.pace_path(path, fk, ...) is the one entry point, whichever
implementation runs. It takes the planner's joint path (start first) and the
caller's forward kinematics of the controlled point, and builds the grid:
- Rows within 1e-6 rad of the row before them are dropped
(
distinct_rows); the first and last rows stay exact. A planner's timed output repeats its start and goal. - Consecutive rows are joined by straight joint lines (as an executor
tracking them does) and nodes are spread evenly along them, at most
0.02 rad apart (
joint_path_grid). A row where the joint direction turns by more than 20 degrees is a corner: it stays a node and the move stops there. Smooth planner paths have none (at most 6 degrees on the recorded LIBERO plans).
The controlled point is measured at every node with the caller's forward
kinematics, so neither implementation knows a robot. pace_path takes an
optional robot, which names the jerk limits below; everything else in its
signature and its PacedPath is the same for both.
The timing worker
pace_path uses the worker whenever the process has one
(motion_timing.client): a backend selects it with motion_timing.configure
(LIBERO, from runtime.motion_planner.timing; RoboTwin, RoboCasa365 and the YAM
station, from runtime.motion_timing through motion_timing.bind_preflight), or else
ORA_TIMING_PYTHON names its interpreter. The worker, ora/environment/planners/timing/, runs as its own
process under a small CPU interpreter holding toppra 0.6.10, ruckig 0.19.4 and
their dependencies (requirements.py there, about 250 MB; ora setup builds
it as the motion-timing component). Both libraries are MIT licensed. It takes
one retime request and answers the path sampled at the backend's control tick
(contract).
- Pieces. The path is cut at its corners into pieces that start and end at rest. Each is a cubic spline in joint space through the nodes, parameterized by joint arc length.
- TOPP-RA finds the fastest progress along each piece under every cap at
once, each at 97% (a cap holds at gridpoints only): every joint's speed and
acceleration (the preset's, lowered to the backend's ceiling), and the
controlled point's speed and turn rate, which are bounds on the path speed
squared,
x <= (v / sigma'(s))^2, and its ramp, the tangential accelerationsigma'(s) u + sigma''(s) x.sigmaandthetaare the controlled point's arc length and turn along the path, fitted through the caller's poses.slow_approachingadds the careful caps, joints included, from the gridpoint at or before 2 cm from the end; the profile slows into the zone without a stop. Ramps hold at both ends of every grid segment. - From rest. TOPP-RA has no jerk, and a joint at rest cannot take an
acceleration step. Both ends of a piece therefore also stay below the speed
a constant jerk (half the joints' limit) reaches from rest,
x <= 6^(4/3) / 4 * J^(2/3) * d^(4/3)atdalong the path from that end, on a grid spaced cubically there. - Ticks. The profile is sampled at whole ticks, stretched uniformly so the last tick ends exactly on the goal; a stretch only lowers every cap's use.
- Ruckig (Community edition) certifies the rows at the joints' hardware
jerk limits, per tick and state to state: from each row's velocity and
acceleration, as the rows themselves give them, it must reach the next row
in exactly one tick (
DurationDiscretization.Discrete). A tick it cannot is timed again without the discretization: an executor taking Ruckig's shortest duration runs ahead of or behind the rows by that difference times the controlled point's speed there. Those distances may add up to 1 mm along a move (max_deviation_m), and no such tick may be off by more than a quarter of a tick. Past that the move is re-solved with every acceleration cap lowered by 20%, up to 8 times (acceleration_scale). The rows are always samples of the path, which is the path the planner checked for collisions. - Wrist and budget are
motion_pace's, on the timed rows. A cut re-solves node prefixes, each rest to rest, and never falls inside a large wrist turn.
Ruckig's intermediate_positions is never set: the Community wheel sends
waypoints to a remote API. A test holds this
(tests/ora/environment/planners/timing/test_ruckig_guard.py in CI, and a spy
on every Ruckig input under the timing interpreter). Lower jerk than the
hardware's has to come from lower acceleration caps; Ruckig cannot follow a path
smoothly at a jerk the timing does not respect.
Jerk limits
motion_timing.JOINT_JERK_LIMITS holds each robot's hardware limit per joint,
and pace_path(robot=...) names one:
| Robot | rad/s³ per joint | Source |
|---|---|---|
franka_panda |
7500, 3750, 5000, 6250, 7500, 10000, 10000 | Franka, Robot and interface specifications |
arx_x5, yam, aloha_agilex |
1000 on every joint | unverified; no vendor document gives the X5's, and the 500 in the SDK's robot file is a planner setting |
| any other, or none | 1000 on every joint | unverified |
TODO: the ARX X5's, the YAM's and RoboTwin's ALOHA-AgileX arms' values are not published. Replace the
conservative default with a vendor value or a measurement before a real move
relies on them; receipts carry jerk_source, so unverified is visible on
every move until then.
A pace may name its own jerk (joint_jerk_rad_s3 in explicit caps, the toolkit
Pace.joint_jerk_rad_s3); no preset does. motion_timing.pace_jerk certifies the
move at that jerk where the robot's is unverified, with jerk_source: "pace",
and never above a documented one (the pace's is then a ceiling per joint and the
source stays the robot's). RoboDojo's ARX X5 motion profile v2 names 5000 rad/s³
for its fast (profiles); every other move of the
X5 keeps the default below.
The YAM is the one real robot in this table. Its 1000 rad/s³ is a declared value, not I2RT's: the i2rt source (v1.4.0) names no joint jerk limit (only the DM motors' own acceleration-limit register, which ORA does not set), and no vendor figure was found. The station's own acceleration caps bind long before it (YAM): the rows the worker answers reach at most 169 rad/s³ by finite differences at the 20 ms tick, so a real move is limited by those caps, not by the declared jerk.
The X5 stays at 1000 because lowering it does not make the moves gentler. On 245
recorded paths (2026-10-31), 500 lengthens fast from a median of 9 ticks to 11
and sends 28 paths to the fallback timing instead of 16, and those have no jerk
limit at all: the largest TCP speed rises from 1.24 to 1.48 m/s. normal does not
notice (17 ticks at the median either way, every path certified).
Changes from the fallback
The caps' semantics are the same. Three things differ on purpose:
ramp_freeis gone: every move keeps its ramps, however short.- Caps hold at 97%, so a move's top speed is about 0.97 of the cap and
planned_peak_linear_m_ssays so. - Moves carry a jerk-limited start and stop.
The fallback timing
Without a timing interpreter, pace_path keeps the hand-written timing, a port
of the toolkit's. So does a path the worker answers timing_infeasible, which
no recorded LIBERO plan was; its receipt says why. A worker that is configured
but fails is an error, never a silent fallback.
With a Cartesian ramp, the nodes are spread again so that every segment has the
same length over the acceleration cap that binds it (linear length over the
linear ramp, turn over the turn ramp, joint step over the joint acceleration;
paced_grid).
The timing keeps one speed per node in grid segments per second. Speed caps hold inside every segment, but the acceleration passes carry a node's speed from one segment into the next. Adjacent segments of different binding length (a repeated row is a segment of length zero) would therefore step the controlled point's speed at the node and skip its ramp. The even and cost-even grids prevent that.
A small forward-backward pass (a TOPP) then finds the fastest
progress under every cap at once, and knots samples it at the backend's
control tick, stretched to whole ticks so no cap is exceeded.
slow_approaching adds a careful zone that starts at the grid node at or
before 2 cm from the end, so the whole last 2 cm is slow. A segment that ends
short of the move's goal (a pre-contact segment) leaves it out. peaks
reports the top speed and turn rate the planned path reaches under every cap,
joints included.
tests/ora/environment/controllers/test_motion_pace_parity.py keeps these
presets and the toolkit's equal. The toolkit's own timing is gone: it asks this
fallback, or the worker, through kinematics.pace_path (see RoboDojo).
Its straight lines (3 mm / 1.5 degrees) were already even, and there its slow zone held within 0.2%. On planner grids with repeated or uneven rows it showed the same overshoot the scoping measured below.
A TOPP-RA scoping on the 219 recorded LIBERO plans (2026-10-31) found both defects in the first version, which timed the planner's rows as they came. With the fixes, every tick of every move of 2 cm or more keeps its ramp:
| Speed | Ramp, before (max) | Ramp, after (max) |
|---|---|---|
normal |
3.6× | 1.03× |
careful |
2.4× | 1.01× |
normal + slow_approaching |
3.5× | 1.01× |
speed_m_s 0.05 |
3.0× | 1.03× |
The ramp ratio is the per-tick tangential acceleration over the ramp; the
residual is tick discretization. The slow zone's top speed went from 1.25× to
1.00× of careful's. Moves got longer: normal +19% in total, normal +
slow_approaching +15%, careful and speed_m_s +2–3%, fast +1%.
The fallback still runs moves under 2 cm and 5 degrees at constant speed without ramps.
The two compared
Both implementations, on the 219 recorded V2 LIBERO plans and the 3 fixture paths (2026-10-31, 50 ms tick, 1 rad/s joint ceiling, Panda jerk limits, offline). Three plans are refused as unrequested wrist turns by both. Every figure is measured at the tick from the answered rows with one independent Panda forward kinematics, not the kinematics the timing was given. The ramp ratio includes the first and last tick of the move, from and to rest.
| Speed | Timing | Duration p50 / p95 / max (s) | Total (s) | Top speed / cap (max) | Moves with a tick over cap | Ramp / limit (max) | Slow zone / careful (max) | Joint jerk p50 / max (rad/s³) |
|---|---|---|---|---|---|---|---|---|
fast |
fallback | 0.45 / 1.85 / 3.35 | 146.4 | — | — | — | — | 157 / 315 |
fast |
worker | 0.45 / 1.90 / 3.45 | 150.2 | — | — | — | — | 140 / 322 |
normal |
fallback | 0.85 / 2.45 / 3.55 | 239.6 | 0.999 | 0 | 5.909 | — | 33 / 100 |
normal |
worker | 0.90 / 2.50 / 3.65 | 245.7 | 0.970 | 0 | 0.969 | — | 34 / 104 |
careful |
fallback | 1.85 / 6.15 / 9.70 | 549.7 | 1.002 | 5 | 3.997 | — | 12 / 39 |
careful |
worker | 1.85 / 6.35 / 10.00 | 564.6 | 0.970 | 0 | 0.969 | — | 14 / 42 |
normal + slow_approaching |
fallback | 1.05 / 3.20 / 4.70 | 293.4 | 1.000 | 0 | 3.997 | 1.000 | 36 / 120 |
normal + slow_approaching |
worker | 1.05 / 3.30 / 4.85 | 297.2 | 0.971 | 0 | 0.970 | 0.971 | 38 / 121 |
speed_m_s 0.05 |
fallback | 3.40 / 9.75 / 12.90 | 911.4 | 1.004 | 28 | 4.998 | — | 6 / 16 |
speed_m_s 0.05 |
worker | 3.40 / 9.90 / 13.30 | 922.5 | 0.970 | 0 | 0.970 | — | 5 / 17 |
The worker kept every cap on every tick of all 1095 timed moves; each took one
attempt, and at most 2 ticks of a fast move needed Ruckig's shortest duration
(at most 0.47 mm). The fallback's largest ramp ratios are the moves
it runs without ramps. A solve takes 5 to 7 ms at the median and
at most 27 ms; the worker starts in about 2.5 s, once per run.
The evidence covers LIBERO's Franka paths only. At other settings, with fast
and the unverified 1000 rad/s³, the worker lowers its acceleration more often and
a few moves reach the fallback: none of 219 at a 50 ms tick and 1 rad/s, 10 of
219 at a 40 ms tick and 4 rad/s. The other presets take one attempt there too.
The wrist
Before anything moves:
- Unrequested turn. The controlled point may turn at most 45 degrees more
along the path than from its start to its planned end orientation. Beyond
that the wrist is going the long way round, typically at its last joint's
limit, and the move is refused with
paced_path_wrist_unwind(path_turn_deg,requested_turn_deg,unrequested_turn_degand the wrist report); the refusal asks for a target orientation nearer the current one, and themove_posehelp of each environment-planned surface says what was tried before it (below). On 219 recorded LIBERO global plans the largest detour of an accepted plan was 31 degrees; the three refused plans each turned the hand 65 to 69 degrees beyond the request, two of them with the wrist joint turning more than a half-turn. - Planner detour. Before the pacing sees it, the cuRobo V2 worker reads
each pose plan by the same rule and compares it with straight joint lines to
the same pose: to the plan's own goal joints, when the plan turns the hand past
the rule (trajectory optimisation detouring on a pure translation, as on
RoboTwin, where such lines turned 0 to 7 degrees against the plans' 48 to
156); and to the goal's nearest 2 pi equivalent inside the joint limits, for
every plan whose goal lies more than half a turn away on a joint that has room
for one (the ALOHA's +/-4.2 rad; its wrist is the joint that winds, while a
Panda's or an X5's limits leave no such room); and, when the plan turns past
the rule, to the other IK solutions of the pose the planner's attempts kept
(the eight nearest the start, each at its nearest equivalent in range: at the
Panda's last-joint limit another arm branch can hold the same orientation with
the wrist in range). The lines and, when the rule accepts it, the plan are
ranked as the pacing reads them, within the rule first and then the smallest
path turn, the plan winning a tie, rather than taken in the order the planner
found them; the best line
that passes the planner's own checks (every row inside the joint limits and
clear of the robot itself and of the goal's world, the whole line clear of the
world a joint path to that goal is checked in) is answered instead of the
plan. The pose is unchanged; the plan answer's
detail.wrist_detourkeeps each candidate's turns and outcome,chosenandstatus(replaced,kept). A goal at the far end of the last joint's range with no equivalent in range, where the lines turn the long way too, is kept for the pacing to refuse (cuRobo V2 planner worker). - Jaw twin. A pose move (
move_pose,move_to,rotate_*) whose path is refused withpaced_path_wrist_unwindon LIBERO, RoboCasa365 or RoboLab, with the jaws commanded open (the gripper's held directive opens; on LIBERO, whose directive ramps, the last accepted jaw target must not becloseeither), is admitted once more to its jaw twin: the target turned a half-turn about the hand's approach axis (local +z of the grip site or TCP), which a symmetric parallel jaw grips the same way and which lies half a turn away on the last joint, inside its range where the request was not (ora/environment/controllers/jaw_flip_retry.py). The twin runs only when the planner and the pacing admit it; the receipt'smotion.wrist.jaw_flip_retrythen says so (applied: true,reason,turn_deg: 180,requested_orientation_xyzw,executed_orientation_xyzw,refused_unrequested_turn_deg), and arrival and the pose error are judged at the twin; the action'sargumentskeep the request. When the twin is refused too, the original refusal stands and itsmotion.refused.jaw_flip_retrysays the twin was tried (applied: false,twin_refusedwith the twin's code). A jaw that may hold something keeps the request, since the load would turn with the hand; a recovery's joint goal and an executed probe plan are never retried. A dry run asks the same retry and keeps the twin's plan for the real call, its path segment carryingjaw_flip_retryand its last segment ending at the twin, so a preview never promises what the real call refuses. RoboDojo's toolkit already picks the nearer jaw twin before planning (lib.motion_plan.orientation), and RoboTwin does not retry. - Budget. A path needing more ticks than one action may spend is refused
(
paced_motion_budget, withtick_budgetandneeded_ticks), or, on a backend that cuts moves to their budget, cut to the longest first part that fits; a cut never falls inside a monotonic wrist-joint turn of 90 degrees or more, and a move that starts with one is refused withunsplit_span. - Report. The wrist joint (the backend's last wrist joint) from the start
through every planned knot:
start_deg,end_deg,min_deg,max_deg,travel_deg(the sum of its turns, which both ends alone can hide) andmin_limit_margin_deg, beside the path'spath_turn_degandrequested_turn_deg.
Receipts
A paced move's receipt reports motion.speed (speed, speed_m_s when given,
slow_approaching, the caps linear_m_s, angular_deg_s,
joint_speed_deg_s, planned_peak_linear_m_s, planned_peak_angular_deg_s,
and with slow_approaching slow_approach_m and the slow caps),
motion.wrist, planned_ticks and duration_s; the keys of motion.speed
are RoboDojo's. A move that ran its jaw twin adds motion.wrist.jaw_flip_retry,
and a wrist refusal whose twin was tried adds motion.refused.jaw_flip_retry
(the wrist); both reach the policy with the rest of motion.
On RoboTwin motion.wrist holds one report per moved arm, under
its name, the peaks are the largest over the arms, and motion.timing holds one
entry per moved arm. A move with no paced
route (a local route, RoboLab's servo) reports motion.speed with the request
and its caps only; RoboLab's leaves out the joint cap, which does not apply to
it.
The sealed receipt (native/receipts/) also carries motion.timing and each
segment's pacing.timing: implementation
(toppra_ruckig or motion_pace), and for the worker the library versions,
jerk_source, attempts, acceleration_scale, ruckig_extended_segments,
max_deviation_m, solve_ms and verification, each cap's largest ratio over
the ticks; for the fallback, reason. The run's metadata holds
motion_timing_binding.
Nothing the policy can read names a library. Every copy of a receipt in a place
the policy can read (the observation an environment publishes, the policy-state
chain, the context a session reads, a script's robot view built from it) is
ora.contracts.policy_receipt of it: without motion.timing, pacing.timing,
and the planner's own record, planner.schema and planner.canonical_artifact.
The public projections never read those keys, so the delivered text is the same.
A backend embeds policy_receipt(receipt) in its observation (LIBERO, RoboTwin,
RoboCasa365 and RoboLab do); the Supervisor
refuses an observation whose embedded receipt still holds timing evidence. The
copy the session keeps for its trace (native/agent-artifacts/, kind
environment_receipt) is not a Context Artifact, so artifact_read cannot open
it (tests/ora/agent/evidence/test_policy_reachable_receipts.py).
Backends
| Backend | Adoption |
|---|---|
| RoboDojo (default) | Every route of the toolkit's motion tools (move_pose, move_to, rotate_wrist, rotate_pitch, grasp_execute's arm stages, recover_pose, return_home) is timed through kinematics.pace_path, one row per native action, in the worker. The interaction label picks the route at every speed, as on every other backend: speed and speed_m_s change only the pace, and expect_contact is the whole straight line at any length; see below |
| LIBERO / LIBERO-Pro (default) | Every global planner route (move_pose, move_to, rotate_wrist, rotate_pitch, recover_pose, an executed probe plan) is paced in the worker, by the timing worker; see below |
| RoboTwin (default) | Every validated global plan (move_pose, move_to, rotate_wrist, rotate_pitch, recover_pose, the stages of grasp_execute) is paced in the worker; both arms of a two-arm move share one timeline; a local DLS stage spreads each servo step over the physics steps the caps need; see below |
| RoboCasa365 (default) | Every admitted arm path is paced in the worker, the interaction's per-tick steps staying the ceiling; move_base is outside it; see below |
| RoboLab (default) | A planned path is timed and wrist-checked in the worker. On the Cartesian servo (a contact approach, a short move) the speed caps the step per tick (step_caps); see below |
YAM station (runtime.motion_timing, off by default) |
Every arm motion (move_pose, move_free_space, recover_motion) is timed by the worker on the station's own IK path, under its interaction's caps, before the per-tick checks; without the switch the station's fixed-speed timing; see below |
RoboDojo
The toolkit lib holds the path and the Pace; the environment times it.
lib.motion_plan.timing.timed sends each arm's joint path, one stretch between
forced stops at a time, as kinematics.pace_path (speed in the explicit wire form
{"speed": "explicit", "caps", "slow_caps", "slow_approaching"}, so a tool of its own
may use any Pace), and environment/backends/robodojo/shared_motion.py answers with
motion_pace.pace_path: 40 ms tick, wrist joint6 limits +/-3.14 rad, robot arx_x5.
The answer is a recorded kinematics answer, so a replayed tool rebuilds its action
without a timing worker, and it names no library: the timing evidence of each move
stays in native/motion-planner/timing.jsonl. ORA_TIMING_PYTHON is bound by
preflight as on RoboTwin (runtime.motion_timing), for a free-play scene as for a
benchmark episode.
Two arms are timed one by one and put on one timeline: the shorter move is slowed
uniformly, which keeps every cap, and they start and stop together. Under a budget
each arm is cut on its own, so two arms may stop at different fractions of their
paths; part_of_move reports the smaller. The wrist check runs on every route but
recover_pose and return_home, whose paths unwind on purpose. A joint-line bridge
over an IK hole is no longer whole under a budget cut (large wrist turns are).
The hand-written timing the toolkit used to hold had two defects this removes: its slow segment could run over speed on planner grids, and its ramp was skipped where the grid was coarse. On 245 recorded paths of 114 toolkit runs (2026-10-31):
| Speed | Ticks, median (hand-written to library) | Peak TCP speed, largest | Joint speed p99 |
|---|---|---|---|
normal, straight lines |
15 to 15 | 0.300 to 0.291 m/s | 2.43 to 2.23 rad/s |
fast, straight lines |
5 to 9 | 1.61 to 1.03 m/s | 3.97 to 3.81 rad/s |
fast, executed moves |
6 to 9.5 | 1.68 to 1.24 m/s | 3.98 to 3.98 rad/s |
fast takes about 1.7 times as long at the median: the X5 has no published jerk
limit, so the moves are certified at the unverified default (1000 rad/s^3,
jerk limits), and at a 40 ms tick that lowers the acceleration until
Ruckig can follow. Of the fast paths, 16 of 245 keep the fallback timing for that
move (timing_infeasible), as on RoboTwin.
RoboDojo motion profiles
What the toolkit runs at fast, and how its jaw commands move, is the ARX X5
motion profile the plan binds (runtime.motion_profile,
ora/policy/embodiments/arx-x5/motion-profile-v<N>.json,
binding); normal,
careful, speed_m_s and the recovery retrace never follow it. A plan without
one runs v1, the toolkit's built-in values.
| v1 (plans before 2026-11-15) | v2 (the default since) | |
|---|---|---|
fast joints |
4 rad/s, 40 rad/s², the X5's unverified 1000 rad/s³ | 4.5 rad/s (90% of the X5 actuator's 5 rad/s velocity_limit_sim), 60 rad/s², 5000 rad/s³ |
fast settle |
up to 5 native actions to 0.003 rad, 0.05 rad/s | the same |
| close | 2 openings/s, at most 5 mm lead, one settle look at the arm | the SDK limiter's full drive (10.8 mm lead), 5 mm once the finger stops (hold_lead_m), no look at an arm whose measured joint velocities are already below 0.05 rad/s (arm_settle.first_reading) |
| open releasing a close | 2 openings/s | full drive |
| end of a jaw command | within 0.03, or 3 still native actions | within 0.03, or 2 still native actions |
Why v2's fast names a jerk: on 12 sealed RoboDojo tool-call runs (2026-11-14/15,
7574 native actions, 78% of them follow_joint_trajectory), the fast moves'
planned peak joint speed was a median 1.9 rad/s and their peak acceleration a
median 14 rad/s²: the timing worker had backed the 40 rad/s² cap off to a median
0.51 of itself (4 attempts) before Ruckig certified the rows at 1000 rad/s³.
Re-timed offline by the same worker (each recorded path, timing_infeasible
ones left out), raising the caps alone barely helps: 244 paths need 2545 planned
native actions at v1's caps and 2479 at 4.5 rad/s and 60 rad/s² with the old
jerk (1.03x fewer); with 5000 rad/s³ as well, 258 paths need 1860 instead of
2728 (1.47x).
The X5 publishes no jerk; 5000 rad/s³ is within the 3750 to 10000 Franka documents
for its joints. Jaw commands spent their native actions travelling: a close at
2 openings/s took about 6 of its 10, then 3 to confirm a stall and 1 settle look,
and the arm was already at rest at every one of the 75 recorded closes.
Before and after, on the first 6 to 8 actions of five sealed RoboDojo runs
(arrange_largest_number_random, arrange_largest_number, align_blocks,
general_pickup, fold_clothes, layout 3, CUDA physics), each run once as
recorded and once under v2 from a fresh round of the same plant (2026-11-15).
Every recorded action replayed with its recorded native actions and final joints.
| Action | n | v1 native actions | v2 |
|---|---|---|---|
| fast move | 24 | 299 (12.5 each) | 218 (9.1 each) |
| close stopping on an object | 5 | 62 (12.4 each) | 28 (5.6 each) |
| close reaching the floor | 1 | 12 | 5 |
| open | 7 | 43 (6.1 each) | 23 (3.3 each) |
Every action ended as it did under v1 (the same execution status and failure code), every close on an object stalled within 0.006 of v1's opening, and no guard stopped a move. The largest per-move tracking error rose from 0.0021 rad to 0.0094 rad, under the bound's 0.012 rad floor; a v2 move settles one native action more often (the arm arrives with more lag).
LIBERO
planned_motion._pace_global_route hands the planner's trajectory to
pace_path with forward kinematics of the grip site, read from a scratch copy
of the measured MuJoCo state (harness_grip_site_fk,
robot_asset_geometry.panda_poses_at_joints; the plant never moves), the
arm's joint limits from the loaded model and the robot franka_panda.
The default baseline's runtime.motion_planner.timing selects the timing worker
under ORA_TIMING_PYTHON, which ora run --env libero requires. Preflight starts
it (check motion_timing_worker), and the isolated LIBERO worker, whose
environment is allowlisted, gets the interpreter preflight started from the
preflight binding (motion_timing: its path and sha256, checked again when the
worker starts it). A run without the field keeps the fallback, whatever the
environment names. One knot per 50 ms control tick;
every joint at most what the executor's controller follows
(hybrid_motion.libero_global_joint_ceilings): under motion profile v3, the
default, 0.55 rad/s and 15 rad/s² at every speed (each preset's joint caps are
above or, for careful's 8 rad/s², below them; v2 kept 1 rad/s); the wrist joint is
panda_joint7. The whole route must fit max_waypoints (2000) and
max_execution_ticks less the terminal settle; a longer one is refused
whole, never cut, so a move never stops part way through a wrist turn. The
JOINT_POSITION executor runs the knots timed: every knot gets at least one
tick, the 0.04 rad tolerance and the 8 ticks per knot still bound the lag, and
the terminal settle is unchanged. A route whose path does not move keeps the
untimed rule (no tick). A wrist refusal of a pose move's global segment retries
its jaw twin with the jaws open (planned_motion._jaw_twin_route,
the same plan request in the same world snapshot); the twin's plan is kept beside
the first as curobo/plans/action-NNNN-jaw-twin.json, and once it ran, the move's
settle, its local approach after a pre-contact pose and its pose error read the
twin of the target.
move_pose, move_to, rotate_wrist and rotate_pitch carry the request,
from the runtime handlers or from the toolkit tools, which send the same wire form
where the environment plans (_smooth.proposed_speed);
recover_pose and an executed probe plan run at the default. A move's
pre-contact segment (a staged contact_approach) leaves out the slow final
segment, which then belongs to its local approach. The bounded local OSC
segments are not timed but capped: each tick's commanded translation and
rotation are scaled to the caps times 50 ms (step_caps; within the last
2 cm the careful caps with slow_approaching), without ramps, and the
segment's loop budget grows by the fewest ticks the caps allow. At the default
speed the local segments are unchanged.
On the 219 recorded global plans of the planner comparison (Panda forward
kinematics, v2's 1 rad/s ceiling), the default pace takes 9 ticks (0.45 s) at the median and 69 at
most, normal 18 and 73, careful 37 and 200; at the default the grip site
peaks at about 1 m/s, which only the joints limit. Three plans are refused as
unrequested wrist turns.
The joint executor
The motion profile the plan binds (runtime.motion_profile) names the
RoboSuite JOINT_POSITION controller the global route runs on.
hybrid_motion.libero_joint_controller reads it and
worker_environment.joint_position_controller_config builds it, for a live
segment and for its replay alike:
| v2 (frozen plans) | v3 (motion-profile-v3.json, the default) |
|
|---|---|---|
| Controller | RoboSuite's file: kp 50, damping ratio 1 | kp 50 (joint_controller_kp), damping ratio 1 |
| Reach: farthest the goal sits from the measured joints | 0.05 rad | 0.2 rad (joint_command_step_rad, RoboSuite's output_max) |
| A knot's first tick aims at | the knot | the knot plus 2 / sqrt(kp) (0.283 s) times the knot's speed (lead_joint_targets: central differences, the last knot at rest) |
| Pacing ceiling | 1 rad/s (one 0.05 rad step a tick), no acceleration cap | joint_follow_speed_rad_s 0.55 rad/s, joint_follow_accel_rad_s2 15 rad/s² |
| Terminal settle ends | every joint within 0.005 rad of the goal and the grip site within 15 mm / 5 degrees | that, or no joint moved more than terminal_settle_rest_step_rad (0.002 rad) over the last tick and the grip site is within the local route's 5 mm / 0.05 rad (libero_settle_at_rest) |
Each command is the aim's offset from the measured joints divided by the reach
and clipped to ±1, so the controller's goal is the aim itself whenever it lies
within the reach. A critically damped controller follows a knot that moves at
v with a lag of (2 / sqrt(kp)) v; the lead removes that lag, and v3 admits a
follow speed only where the lead stays inside the reach (2 / sqrt(kp) times
0.55 rad/s is 0.156 rad of 0.2). The knot, not the aim, still gates progress
(0.04 rad, 8 ticks); a knot the arm has not met after its first tick is aimed at
itself, so the path holds there; the terminal settle aims at the goal. A settle
that ends at rest inside the local bound leaves nothing for the sparse move's
local settle (global_route_met_the_local_bound), so the move ends there; the
settle's settled_by and per-tick trace say which rule ended it.
Under v2 the pacing allowed 1 rad/s, but a goal at most 0.05 rad ahead holds a
kp 50 controller near 0.008 rad per tick, 0.16 rad/s: every knot waited about 6
ticks. On 18 LIBERO runs of ORA 559102a58 under PEAR's step limits, the first
move of an episode, from LIBERO's start posture, took 50 to 305 control steps
(median 164.5) for 18 to 58 paced knots, 5.3 times its plan, 10 of them in the
terminal settle. The same first moves, from the same starts, through the real
worker (ora qualify libero motion's session, no policy):
| First move (seed 0) | Speed | v2: knots, steps (sealed run, replay) | v3: knots, steps (knot ticks + settle) | v3 end residual |
|---|---|---|---|---|
libero_spatial-t02 |
normal | 24, 107 (107) | 33, 41 (33 + 8) | 2.3 mm, 0.002 rad |
libero_spatial-t03 |
normal | 58, 305 (305) | 82, 101 (98 + 3) | 3.8 mm, 0.016 rad |
libero_object-t00 |
fast (default) | 38, 248 (248) | 66, 73 (67 + 6) | 2.6 mm, 0.016 rad |
libero_goal-t04 |
normal | 42, 221 (221) | 60, 75 (71 + 4) | 3.5 mm, 0.010 rad |
libero_spatial-t07 |
normal | 19, 50 (50) | 19, 24 (19 + 5) | 4.9 mm, 0.002 rad |
libero_object-t09 |
fast (default) | 35, 233 (233) | 61, 75 (69 + 6) | 2.3 mm, 0.015 rad |
v2 repeats the sealed runs' step counts and end poses exactly. The settle ended
at rest in all six v3 moves (3 to 8 ticks; under the v2 rule the same kp 50 moves
needed 7 to 10). The controller's unclipped torque, measured on every physics
substep (torque in tracking/joint-action-NNNN.json), stayed inside the
actuator range RoboSuite clips to (80 N m for joints 1 to 5, 12 N m for 6 and
7) on these moves and on the 14 qualification cases: at most 66.6 N m on joint 2
and 7.0 N m on joint 7, no substep clipped. kp 150 (1 rad/s) was measured and
refused: with 15 rad/s² it reached 90 N m on joint 2 and 20 N m on joint 7 and
stopped two first moves on waypoint_tracking_timeout; with 7.5 rad/s² it
clipped 1245 of 5700 qualification substeps. A v3 run records the gains in its
controller replay (metadata.joint_controller) and a replay loads exactly them;
a run bound to v2 records none and replays on RoboSuite's defaults, bit for bit
as before.
The straight OSC line (v4)
Motion profile v4, the default for new LIBERO plans, is v3 with an osc_transit
section. A planned free_space move whose plan keeps the grip site within
max_path_deviation_m (2 cm) of the straight line from the start to the target,
and whose hand turns at most max_rotation_rad (45 degrees), runs along that
straight line on LIBERO's OSC controller instead of the joint path
(controllers/osc_transit.py, planned_motion._free_space_route_choice). The
deviation is read at the paced knots, from the measured start, by the grip-site
forward kinematics the pacing uses. Every other planned move keeps the joint path:
a pre-contact segment or a recovery, a move with slow_approaching, an executed
plan_ref (it runs the plan its dry run showed), a larger turn, or a plan that
bows out further.
This changes what the plan vouches for. The planner checked its own joint path,
the whole arm on it; on the line the controller chooses the arm's posture, so of
the line only the gripper's path lies within 2 cm of what the planner checked.
The arm's links are not checked there. A force the wrist sensor measures above
the 40 N telemetry threshold (sensing.force_telemetry_threshold_n) stops the
line where it stands (osc_transit_force_limit); a contact on an arm link that
does not reach the wrist sensor is not seen.
The line is paced at the request's Cartesian caps, no faster than the OSC
controller follows: 0.25 m/s and 1.5 rad/s (follow_speed_m_s,
follow_angular_rad_s), reached at 2 m/s² and 12 rad/s². Each tick aims at the
line's pose 2 / sqrt(osc_kp) (0.163 s, kp 150 of LIBERO's osc_pose.json) ahead
by its own speed, within the controller's 0.05 m / 0.5 rad reach, and the local
OSC loop then settles onto the target within the local 5 mm / 0.05 rad bound, at
most settle_ticks (20) more ticks. fast and normal therefore differ little
here (both are capped at 0.25 m/s; normal ramps at 1 m/s²), and on the joint path
both meet the 0.55 rad/s joint ceiling first; careful keeps 0.1 m/s on both.
The move's sparse receipt says which route ran and why (arms.right.route_choice),
its motion gives the line's planned_ticks and its controls are the
libero_osc_pose entries of the controller replay, so a replay is bit for bit as
for any local move. A dry run answers with the same choice: route: osc_line
and the line's ticks.
Measured through the real worker from the same six starts as above. Every action each sealed run submitted, re-executed in order from the same start (open loop, no policy), took:
| Run | Actions | v2 steps (= sealed) | v3 steps | v4 steps (OSC lines) |
|---|---|---|---|---|
libero_spatial-t02 |
6 | 235 | 160 | 118 (2) |
libero_spatial-t03 |
1 | 305 | 101 | 101 (0) |
libero_object-t00 |
4 | 334 | 118 | 117 (1) |
libero_goal-t04 |
4 | 325 | 139 | 137 (1) |
libero_spatial-t07 |
6 | 247 | 117 | 94 (3) |
libero_object-t09 |
4 | 291 | 121 | 121 (0) |
Of the six first moves, from LIBERO's start pose at 0.18 to 0.30 m, one ran as
the line (libero_spatial-t07, 0.18 m, no turn: 24 ticks); four turned the hand
102 to 145 degrees and one's plan bowed 2.3 cm off the line, so they kept the
joint path. Their median cost was 74 ticks at fast, 74 at normal and 113 at
careful, the numbers the move_pose text publishes
(motion_settle.LIBERO_FIRST_MOVE_TICKS). All six later free-space moves that
moved ran as the line, at 9 to 33 ticks where v3 took 11 to 73. The 14-case qualification
passed with the two free-space cases on the line (10 cm in 23 ticks, a 45-degree
combined move in 16; v3: 19 and 35).
RoboTwin
ora/environment/backends/robotwin/pacing.py hands each validated plan to
pace_path with the public TCP's forward kinematics
(kinematics._pinocchio_public_pose_xyzw), before the dense control sequence is
built. One knot per physics step (4 ms); the wrist joint is joint6 of the
moved arm; the worker certifies its jerk as aloha_agilex, at the unverified
default (pacing.ROBOT). The default baseline's runtime.motion_timing selects
the timing worker under ORA_TIMING_PYTHON, which ora run --env robotwin requires;
preflight starts it (motion_timing_worker), and the worker takes the interpreter
from that check in the run's preflight.json at its first round
(motion_timing.bind_preflight), refusing a changed sha256. The joint ceilings are
1.9 rad/s and 1.1 rad/s², set so that the
default is no faster than the planner's own timing it replaces (below). The
whole route must fit plan_validation.maximum_waypoints
(5000) and the transaction's physics steps less one waypoint's wait; a longer
one is refused whole. The measured-convergence transaction writes the knots as
its stages, each at least one physics step, so a stage that waits only slows
the move. The knots' velocity targets are their central differences: the
joint drives (stiffness 1000, damping 200) track a moving target through their
velocity term, so a wrong target would add lag.
Each arm of a two-arm move is paced alone, then the shorter move is slowed
uniformly onto the longer one's timeline, which keeps its caps; because pacing
changes when each arm is where, the paced pair goes through the inter-arm
clearance check again before anything moves. A pre-contact segment leaves out
the slow final segment, as on LIBERO. recover_pose and the stages of
grasp_execute run at the default.
A local DLS stage follows no planned path. The servo re-anchors on the measured
joints every iteration and the drives lag their targets, so shrinking the step
would only slow it without bound; instead each iteration's full step runs as a
straight joint line over as many physics steps as its predicted TCP translation
and turn need under the caps (pacing.local_substeps; within the last 2 cm the
careful caps with slow_approaching), with that line's velocity and no ramps. At
the default speed the local stages are unchanged.
On 6903 recorded arm moves of 394 sealed runs (planner rows through real
URDF kinematics, 0.6 µm from the recorded TCP; 2026-10-31), the planner's own
timing reaches 1.97 rad/s at the joints at p99 (3.1 at most) and 1.54 m/s at
the TCP at most. The vendored planner's bounds as ceilings (3 rad/s, 3 rad/s²)
made the default 0.79 of the planner's duration at the median with 1.53× its
peak speed, because the planner's profile stays below the acceleration it plans
with. At 1.9 rad/s and 1.1 rad/s² the default takes 347 physics steps (1.39 s)
at the median and 785 at p95, 1.31× the planner's duration (at least 1.23× on 95%
of moves); per move its peak TCP speed is 0.93× the planner's at the median and
1.0× at p95, and every percentile of joint and TCP speed stays below the
planner's (joint p50 0.78 against 0.81 rad/s, p99 1.85 against 1.97, TCP at most
1.16 against 1.54 m/s). normal peaks at 0.301 m/s, careful at 0.100 and
speed_m_s 0.05 at 0.051, within 2% of each cap. The linear ramp shows steps at
grid nodes on raw 4 ms ticks where the joint term binds; averaged over 40 ms it
holds at p99 (0.61 m/s² for normal's 1, 0.50 for careful's 0.5). 124 moves
(1.8%, in 70 runs) are refused as unrequested wrist turns, up to 457 degrees of
path turn; the largest accepted detour is 44 degrees. Knots lie on chords
between grid nodes up to 0.02 rad apart: 0.1 mrad at p95 from the planner's
polyline, 5 mrad and 0.84 mm of TCP at most, the goal exact. Tracking in
simulation is not measured by this offline pass.
Through the timing worker (ORA_TIMING_PYTHON, the same moves, aloha_agilex
at the unverified 1000 rad/s³) the default takes 1.41 s at the median, 1.33× the
planner's duration (at least 1.25× on 95% of moves); its per-move peak TCP speed
is 0.92× the planner's at the median and 0.98× at p95, joint p99 1.82 rad/s and
the TCP at most 0.85 m/s. normal, careful and speed_m_s 0.05 peak at 0.301,
0.1005 and 0.0501 m/s; the same 124 moves are refused as wrist unwinds and 6 at
0.05 m/s by the budget. 54 of the 6779 default moves (0.8%) are
timing_infeasible (Ruckig cannot follow them at that jerk) and keep the
fallback timing above, which says so in its motion.timing; over all five speeds
9 timed moves needed a lowered acceleration scale (0.8 or 0.64).
RoboCasa365
ora/environment/backends/robocasa/motion.py (pace_arm_path) hands the
admitted joint path to pace_path with grip-site forward kinematics
(kinematics.grip_poses) at the plan's torso height, one knot per 50 ms control
tick, wrist joint robot0_joint7; the worker certifies its jerk at the Panda's
published limits (franka_panda), bound as on RoboTwin (runtime.motion_timing,
motion_timing.bind_preflight at start). Each joint keeps the interaction's per-tick
step as its ceiling (ARM_JOINT_STEP_RAD: 1, 0.5 or 0.24 rad/s). The
interaction's grip-site step (ARM_STEP_TRANSLATION_M, ARM_STEP_ROTATION_RAD)
holds too: a timing that breaks it is timed again at a lower joint ceiling, so
joint_speed_deg_s then reports the lowered cap. The path must fit 130 ticks,
the action's 150 less the 20-tick settle allowance; a longer one is refused
whole. follow_path streams one knot per tick, and arrival, blocked and contact
rules are unchanged.
Pacing runs before the torso moves, so a refusal spends no native action, and a
refused move does not replace recover_pose's previous. A wrist refusal of a
pose move retries its jaw twin with the jaws commanded open (motion.jaw_twin_path):
the twin is admitted on the arm alone at the measured torso height and paced
like the request. After a torso move the
re-solved path is timed again at the measured height; if that timing is refused
the admitted timing stands, because the lift has already moved. recover_pose
runs at the default. move_base is outside the speed options.
The joint paths are not recorded, so the offline pass (2026-10-31) reconstructed
79 moves of 12 sealed runs as straight joint lines between the receipts' measured
joints, skipping 37 lift-and-traverse moves; straight-line IK paths are only
approximated by that. Speeds hold at 0.298, 0.100 and 0.050 m/s for normal,
careful and speed_m_s 0.05, ramps within 1%. Eight moves (10%) would be
refused as unrequested wrist turns, one of them an approximated IK line, so this
number is an estimate of the live rate. Through the timing worker (franka_panda)
every move certifies at the first attempt; peaks stay at 0.97 of each cap (the
worker holds caps at 97%), the default takes 0.70 s at the median, and the same
8 moves are refused as unrequested wrist turns (3 at careful and 5 at 0.05 m/s
by the budget).
RoboLab
A move that plans (environment/backends/robolab/shared_motion.py: free_space or
precision, more than 50 mm or 15 degrees) is paced by pace_path at the 15 Hz tick
with the franka_panda jerk table, joint ceilings of 1.9 rad/s and 2.5 rad/s2 and the
wrist check on panda_joint7, one row per native action; the timing worker is bound
from the run's preflight, as on RoboTwin. A refusal (paced_path_wrist_unwind,
paced_motion_budget above 300 ticks) moves nothing; a wrist refusal of a pose
move with the jaws commanded open first retries its jaw twin
(shared_motion.pace_or_twin), and the servo then settles on the twin. The rows go to the arm as joint
targets, and the servo settles the last millimetres.
The servo, which takes a contact approach, a short move and a move the planner cannot
answer, has no joint path: RoboLab's differential IK solves inside the simulator, one
tick at a time. A request lowers the carrot step toward the next waypoint to the caps
over one 15 Hz tick (step_caps), below the interaction's own step and without ramps;
the slow zone counts the path left through the remaining waypoints, and the action's
tick budget grows by the fewest ticks the caps allow. At the default nothing is
capped. No path is timed there, so no wrist check runs on the servo route, and the
help says so.
YAM
The bimanual I2RT YAM station (environment/backends/yam/) plans its own paths: each
arm's Cartesian line (a free-space move lifts, traverses and descends) sampled every
2 mm and 0.01 rad and solved by warm-started IK. Its own timing gives each sample the
time the strictest of the interaction's TCP speed, turn rate and the 0.6 rad/s joint cap
allows, and interpolates linearly at the 50 Hz control tick: a motion starts and stops at
full speed, with no acceleration or jerk limit. That timing stays the default.
runtime.motion_timing (ora play --motion-timing;
{"implementation": "toppra_ruckig", "python_env": "ORA_TIMING_PYTHON"}, nothing else
admitted) hands the same samples to the worker (backends/yam/shared_motion.py). The
request is the explicit wire form with the station's caps per interaction
(controllers/yam_station.py), each reached from rest in TIMING_RAMP_S (0.25 s, the
ramp of a numeric speed request, declared rather than measured on the arms):
| Interaction | TCP | Turn | TCP ramp | Joints |
|---|---|---|---|---|
free_space |
0.12 m/s | 0.6 rad/s | 0.48 m/s², 2.4 rad/s² | 0.6 rad/s, 2.4 rad/s² |
precision |
0.05 m/s | 0.3 rad/s | 0.2 m/s², 1.2 rad/s² | 0.6 rad/s, 2.4 rad/s² |
contact_approach |
0.025 m/s | 0.2 rad/s | 0.1 m/s², 0.8 rad/s² | 0.6 rad/s, 2.4 rad/s² |
The jerk is certified at yam's unverified 1000 rad/s³ (jerk limits).
Each straight piece of the path is timed on its own, rest to rest, so the arm stops at
the lift's and the traverse's corners and its rows pass through them exactly; timed as
one path, a lift-traverse-descend corner (60 to 150 degrees in joint space) is one
Ruckig cannot follow at that jerk. recover_motion's joint line is timed for the arm
that travels furthest, at half the joint cap (0.3 rad/s, 1.2 rad/s²), and the other arm
follows the same progress. The wrist is reported, not refused: the path is the
station's own line to the requested orientation. A path needs at most
TIMING_BUDGET_TICKS (6000 ticks, two minutes), else paced_motion_budget.
The rows replace the fixed-speed ticks before the per-tick checks, so the joint limits
(widened to a start just past them, as at rest on the cell), the table clearance and the
inter-arm distance are checked on the ticks the arms will follow, and a dry run keeps
the timed schedule for the real call. The worker is bound as on RoboTwin: preflight
starts it (motion_timing_worker) and the session reads that check from the run's
preflight.json at start; a direct session takes ORA_TIMING_PYTHON, and without
either the station times its moves itself. native/timing/binding.json names what was
bound. A receipt then carries motion: speed and wrist per arm, planned_ticks,
duration_s and, in the sealed receipt only, timing per arm (implementation, and
the worker's evidence of each piece under segments, or yam_fixed_speed and its
reason). Without the switch no receipt has motion, so nothing the model reads
changes.
With runtime.motion_planner (ora play --motion-planner) the path is the shared
planner's instead (backends/yam/shared_planner.py), and either timing times it the same
way: a free-space plan is one piece, rest to rest, and a precision or contact line's
knots lie 1 cm (or 0.05 rad of turn) apart. A receipt then carries motion with or
without the timing switch, and its sealed copy alone holds motion.planned_by, which says
per arm what planned it (curobo_v2 and its route plan or line, or yam_mink_ik and
why).
Measured on 150 random admitted moves on the station model (2026-11-14, both arms, 104 single-segment and 46 lift-traverse-descend, worker on this workstation's CPU), every move timed by the worker at the first attempt, reaching the same final joints exactly:
| Fixed-speed timing | Shared timing | |
|---|---|---|
Duration, free_space p50 / p95 |
2.40 / 3.19 s | 3.16 / 4.07 s |
Duration, precision p50 / p95 |
1.56 / 2.14 s | 1.86 / 2.46 s |
Duration, contact_approach p50 / p95 |
1.15 / 1.71 s | 1.45 / 2.01 s |
| Duration ratio p50 (free / precision / contact) | 1 | 1.31 / 1.19 / 1.25 |
| TCP speed at the first tick, over the cap | 1.00 | 0.04 |
| Peak TCP speed over the cap, max | 1.005 | 0.970 |
| Joint acceleration p50 / max | 13.4 / 59.7 rad/s² | 1.10 / 2.33 rad/s² |
| Joint jerk p50 / max (finite differences) | 672 / 2985 rad/s³ | 38 / 169 rad/s³ |
| Joint speed max | 0.600 rad/s | 0.582 rad/s |
A solve takes 5 ms at the median and 15 ms at most; planning a whole motion with it, IK included, 65 ms at the median and 1.3 s at most (the first, which starts the worker). Tracking on the real arms is not measured yet; that measurement decides whether the switch becomes the default.