PolicyIK: High-Precision Inverse Kinematics for Robot Arms with Reinforcement Learning

Abstract: Inverse kinematics (IK) converts end-effector pose commands into joint motion, and many vision-language-action (VLA) policies rely on it to act on a given arm and to transfer across embodiments. Precise IK remains laborious: redundancy and singularities complicate the inverse mapping, execution depends on hand-tuned controllers, and training data on physical robots are costly to collect. We present PolicyIK, a goal-conditioned reinforcement learning policy for high-precision IK. It updates joint-position references from pose feedback and observes its accumulated reference relative to the measured joints, so it can retain the offset that the position controller needs at rest. Two-scale pose errors with an error-dependent action gain resolve millimeter residuals while preserving large motions. Progress and dwell rewards teach it to both reach the tolerance and stay within it. In simulation, a single attempt by the trained PPO policy keeps the mean errors over the final second within 1 mm and 0.2° on 93.5% of held-out tasks, and a deployment protocol raises success to 98.9%. When trained directly on a physical arm with an off-policy RL learner, PolicyIK achieves higher reaching and holding success than all four classical IK controllers under the same time budgets. In simulated pick-and-place, PolicyIK executes the end-effector commands of the $π_{0.5}$ VLA policy with 95.7% success. These results show that reinforcement learning can provide high-precision inverse kinematics for robot arms. Code is available at https://github.com/Tinaliu0123/PolicyIK.

• The paper introduces PolicyIK, a reinforcement learning-based method that achieves high-precision inverse kinematics for robot arms, with strict success requiring position error below $1$ mm and orientation error below $0.2^ ext{o}$.
• PolicyIK incorporates command-state feedback, multiscale pose representation, and adaptable error scaling, achieving a single-attempt strict success rate of $93.49%$ in simulations and $98.92%$ with retries, outperforming classical methods by up to $43$ percentage points.
• Able to transition effectively to real-world applications, PolicyIK validated on robotic hardware shows $76.17%$ holding success on physical tasks, a significant improvement over others who only achieved $28.3$ %.

Problem setting and contribution

“PolicyIK: High-Precision Inverse Kinematics for Robot Arms with Reinforcement Learning” (2611.05372) formulates inverse kinematics as closed-loop, goal-conditioned control rather than as a one-shot mapping from an end-effector pose to a joint configuration. The distinction is important for position-controlled manipulators: the joint configuration that produces a desired end-effector pose under ideal kinematics is not necessarily the joint-position reference required by a real or simulated servo system. Gravity, finite proportional gains, actuator limits, joint-limit constraints, model mismatch, and controller dynamics can produce a nonzero steady-state pose error even when the nominal inverse-kinematic solution is exact.

The paper targets full-pose regulation at substantially tighter tolerances than those commonly used in learned reaching benchmarks. Strict success requires both position error below $1$ mm and orientation error below $0.2^\circ$, evaluated using the mean error over the final second of a $5.3$-second simulated attempt. A stricter containment metric additionally requires every sample in the final evaluation window to satisfy both thresholds. This separates transient goal entry from sustained regulation, which is central to the paper’s analysis.

PolicyIK is a goal-conditioned RL policy that outputs increments to an accumulated joint-position reference. The policy is trained with PPO in simulation and with an off-policy actor–critic method, FlashSAC, directly on physical arms. Its principal methodological claims are that high-precision IK depends on three design decisions:

1. The command state must be observable: the policy observes the accumulated joint reference relative to the measured joint state.
2. Pose feedback must be multiscale: coarse and fine pose-error channels preserve sensitivity from large workspace motions down to submillimeter residuals.
3. The action magnitude must depend on error scale: large steps are used during transport and automatically reduced near the goal.

The reward further distinguishes improvement in the best achieved error from remaining inside the tolerance region. This explicitly trains both approach and dwell behavior rather than treating successful contact with the target as sufficient.

Figure 1: PolicyIK combines broad workspace reaching, millimeter-level full-pose regulation, and sustained hardware holding within $1$ mm and $0.2^\circ$.

Control formulation

At time $t$, the policy receives the robot state, goal pose, pose-error features, command-state feedback, previous action, and running-best error information. Its action $a_t$ updates a joint reference according to

$$z_t = \operatorname{clip}\left(z_{t-1}+\eta\,\beta(e_p,e_R)a_t\right),$$

where $\eta$ is the nominal action scale and $\beta(e_p,e_R)$ is an error-dependent gain. The fixed-gain joint-position controller then tracks $z_t$ for one control interval. The policy therefore does not directly command torque or measured-joint displacement; it controls the reference trajectory presented to an underlying servo loop.

This interface addresses a steady-state problem that is easy to miss in purely kinematic formulations. Under gravity and finite proportional gain, a static equilibrium generally requires a reference offset from the actual equilibrium configuration. If the policy acts relative to the measured joint state, it must continually regenerate this offset. When the action approaches zero, the arm can sag away from the desired pose. By accumulating actions in $z_t$, PolicyIK allows a zero action to preserve the offset. It also exposes

$d_t=z_{t-1}-q_t,$

which makes the command state explicit rather than forcing the policy to infer it from action history.

The authors provide a direct observability argument: once commands are integrated, the same measured joint state, goal, and action can lead to different future states depending on the previous reference. Consequently, the measured robot state alone is not Markovian for this control interface. The command-state feature is therefore not merely an additional input; it restores information needed to predict the effect of future actions.

Figure 2: The policy generates an increment to an accumulated joint reference, whose error-dependent scaling and servo tracking determine the realized motion.

Multiscale pose representation

PolicyIK represents the goal error using several complementary features. Three noncollinear end-effector keypoints encode translation and orientation as point-position discrepancies. In addition, the policy receives coarse and fine pose errors expressed in the current end-effector frame. The coarse channels use scales of $1$ cm and $20^\circ$, while the fine channels use $0.5$ mm and $0.25^\circ$.

This design responds to a normalization problem. If errors spanning centimeters and tens of degrees are normalized through a single workspace-scale representation, a residual of $1$ mm or $0.2^\circ$ occupies too little input range to support reliable correction. The fine representation increases the numerical salience of the terminal regime without discarding the coarse signal required for global motion.

The action gain provides the corresponding output-side mechanism. It remains near unity when either translation or rotation error is large and decreases toward a floor near the target. Thus, the same policy can produce large joint-reference changes during transport while retaining sufficiently small command increments for terminal regulation. The gain is error-dependent rather than time-dependent, so fine control engages whenever the system enters the relevant error regime.

The ablations support a division of labor between these mechanisms. Removing fine pose channels increases the median terminal position error from $0.25$ to $0.36$ mm and reduces strict success from $93.49\%$ to $88.41\%$. Replacing the adaptive gain with a fixed gain increases median entry time from $1.73$ to $2.28$ seconds and reduces strict success to $89.13\%$. Removing both components reduces strict success further to $85.27\%$. These results indicate that terminal precision is not obtained solely by increasing training scale or network capacity; it depends on preserving both fine error observability and an appropriate command resolution.

Reward design for reaching and holding

The sparse task objective is the indicator that both pose errors satisfy their thresholds. Since this signal is rarely observed from distant initial states, the implementation supplements it with tracking, progress, dwell, motion, and joint-limit terms.

A key design choice is to normalize position and orientation by their respective tolerances and combine them through the maximum normalized error,

$$\rho_t=\max\left\{\frac{e_p(t)}{1\ \mathrm{mm}}, \frac{e_R(t)}{0.2^\circ}\right\}.$$

The strict region is exactly $\rho_t\leq 1$. Using the maximum rather than a sum prevents progress in one coordinate from masking failure in the other. For example, reducing position error cannot compensate for an orientation error that remains outside tolerance.

The running minimum of $\rho_t$ supports a progress reward that pays only when the policy establishes a new best accuracy. Because the running minimum is monotonic, these payments do not reward repeated oscillations around the same error level. A potential-based shaping term supplies denser directional feedback, while a backslide penalty discourages degradation from the best achieved state. The dwell reward pays at every step inside the strict region. This is essential because the improvement reward becomes zero once the policy stops improving.

The reward ablations distinguish these effects quantitatively. Removing the progress terms decreases strict success by 1.83 percentage points. Removing the dwell reward has little effect on entry time but increases the fraction of tasks that enter the strict region and subsequently leave it from $2.43\%$ to $7.83\%$. The result supports the paper’s claim that entering and maintaining a high-precision pose are different learning problems and should receive separate reward signals.

Figure 3: Ablations show that command-state feedback, fine pose sensing, adaptive action scaling, and dwell/progress rewards affect terminal entry and sustained containment differently.

Simulation results

The main simulation evaluation uses a fixed-base 7-DoF OpenArm and 4,120 held-out start–goal pairs. Training and evaluation configurations are disjoint, and the evaluation goals are separated from training goals at the strict tolerance scale. PolicyIK is compared with a tuned UMI-RL implementation and classical DLS, resolved-rate QP, and kinematic MPC controllers.

The results are substantially different across learned and classical controllers:

Controller	Strict success	Coarse success	Median position error	Median orientation error
UMI-RL	$0.0\%$	$16.38\%$	$16.65$ mm	$4.25^\circ$
DLS	$50.41\%$	$64.42\%$	$0.94$ mm	$0.15^\circ$
QP	$56.21\%$	$63.98\%$	$0.57$ mm	$0.11^\circ$
MPC	$56.33\%$	$64.78\%$	$0.54$ mm	$0.10^\circ$
PolicyIK	$93.49\%$	$96.56\%$	$0.25$ mm	$0.04^\circ$

PolicyIK exceeds the tuned classical controllers by approximately 37–43 percentage points in strict success. Its single-attempt median terminal errors are $0.25$ mm and $0.04^\circ$, and it contains the pose at every sample in the final second on $92.4\%$ of tasks. On successful tasks, the median net end-effector motion during that final second is only $14\,\mu$m and $0.002^\circ$.

The deployment protocol raises strict success to $98.92\%$ at an average of $1.212$ attempts per task. It first applies an error-corrected goal when the terminal residual is small and otherwise uses transient goals to reconfigure the arm before retrying the original goal. This distinction matters for interpreting the result: $98.92\%$ is not a single-pass policy success rate, but a system-level result that includes a structured recovery procedure. The protocol mainly improves the tail of the error distribution; the median errors remain unchanged.

The paper attributes many classical-controller failures to joint-limit stalls. In $34$–$35\%$ of tasks, a classical controller remains near a joint limit during the terminal interval while failing even the coarse criterion. Such cases account for $71$–$81\%$ of their strict failures. PolicyIK avoids many of these failures by learning joint-reference trajectories that approach the target while respecting the coupled dynamics and command interface.

Figure 4: A representative joint-limit failure of QP produces a persistent pose plateau, whereas PolicyIK reaches the strict region without sustained joint-limit occupancy.

The comparison is favorable to PolicyIK but not entirely symmetric. The classical controllers receive exact simulator gravity compensation, whereas the principal PolicyIK result does not. The classical methods are also tuned on a separate task set, while PolicyIK relies on learned behavior and a different set of design assumptions. These choices do not invalidate the comparison, but they mean that the reported advantage should be interpreted as an end-to-end result for the chosen servo interface and task distribution rather than as a universal dominance result over all possible classical IK implementations.

Pick-and-place integration

The paper evaluates whether high-precision pose regulation transfers to a downstream VLA-controlled manipulation task. PolicyIK executes the end-effector commands of $\pi_{0.5}$ on ten adapted LIBERO-Object tasks. It is retrained for the side-mounted arm but receives no pick-and-place demonstrations or task-specific manipulation reward.

PolicyIK achieves $95.7\%$ success, compared with $96.7\%$ for hand-tuned DLS, $90.8\%$ for default DLS, and $90.8\%$ for hand-tuned QP.

Figure 5: PolicyIK supports VLA-directed pick-and-place, including grasps near the shoulder joint limit.

The result is not presented as a large improvement over the best hand-tuned baseline. Its significance is instead architectural: a policy trained only for pose regulation can serve as the low-level realization layer for a VLA policy without a Jacobian, online optimization, gravity feedforward, or pick-and-place training data. The advantage is concentrated near targets that place the shoulder joint close to its limit. In this setting, default DLS discards infeasible components of its step, while PolicyIK learns a reference trajectory that completes the approach under the same task interface.

Direct physical-robot training

A separate contribution is training PolicyIK directly on physical arms without initializing from simulation. The authors use FlashSAC with hindsight experience replay, near-goal replay sampling, demonstrations, a reverse curriculum, and a latent-alignment critic.

The latent-alignment critic addresses a mismatch between pose-space distance and temporal distance. Large rotations can require a joint-space detour in which the instantaneous end-effector error initially increases. A conventional critic based primarily on local pose similarity may therefore assign excessive value to geometrically close but temporally inappropriate states. The proposed critic encodes state–action and goal representations separately and predicts value from their latent difference. Near-goal replay and current-goal relabeling concentrate updates on the terminal correction and holding regime, while the reverse curriculum teaches terminal regulation before large reconfigurations.

On 60 physical OpenArm tasks with a $25$-second budget, PolicyIK obtains the following results:

Controller	Reached	Held for final $5$ s	Median position error	Median orientation error
DLS	$48/60$	$17/60$	$0.65$ mm	$0.13^\circ$
Resolved-rate QP	$48/60$	$16/60$	$0.57$ mm	$0.14^\circ$
Kinematic MPC	$46/60$	$15/60$	$0.81$ mm	$0.18^\circ$
Adapted OpenArm QP	$32/60$	$11/60$	$0.99$ mm	$0.23^\circ$
PolicyIK	$54/60$	$43/60$	$0.50$ mm	$0.12^\circ$

PolicyIK’s holding success is $71.7\%$, compared with at most $28.3\%$ for the classical controllers. The gap is larger for sustained regulation than for initial reaching: the classical controllers reach between $46$ and $48$ tasks, but hold only $15$–$17$ for the final five seconds. PolicyIK retains $43$ of its $45$ one-second holding successes when the required final hold is extended to five seconds.

This result directly supports the paper’s central control argument. A controller can reach a pose while still failing to maintain it because the required joint reference differs from the measured joint state. PolicyIK’s accumulated reference preserves that offset, while its dwell reward discourages the small corrective motions that repeatedly drive classical MPC outside the tolerance band.

The hardware study also includes xArm7 experiments. Both simulation-trained and hardware-trained PolicyIK achieve $60/60$ success on standard reaching and large-rotation task sets. On large rotations, this compares with $59/60$ for DLS, QP, and MPC and $45/60$ for the xArm7 built-in IK. These results suggest that the formulation is not restricted to the OpenArm, although the evaluation uses a limited number of fixed tasks and does not establish broad cross-robot generalization without retraining.

Computational cost and ablations

PolicyIK’s inference cost is low relative to the control period. The simulated actor requires $0.035$ ms for a batch-one CPU forward pass, compared with a $33$ ms control interval. Hardware learning is more computationally demanding, but the actor and latent-alignment critic updates take approximately $27$ ms on the onboard GPU, allowing two updates within a $100$ ms control period.

The ablations reveal that the largest degradation comes from removing the command-state representation or changing the reference anchor. Removing command-state feedback reduces strict success from $93.49\%$ to $$84.26\%. Re-anchoring the accumulated reference at the measured joints is much more damaging: coarse success remains$$95.90\%$, but strict success falls to$30.77\%$, median position error rises to$1.27$mm, and$82.46\%$ of tasks that enter the strict region fail to remain contained. This is a strong and somewhat counterintuitive result: an interface that preserves broad reaching can nevertheless be fundamentally inadequate for steady-state precision.

The same pattern appears in the distinction between coarse and strict metrics. Several ablations retain coarse success near $95\%$ while losing 5–63 percentage points of strict success. Consequently, conventional reach metrics would fail to expose the principal failure modes addressed by PolicyIK.

Limitations and open questions

The evaluation is restricted primarily to reachable, collision-free pose goals generated from known robot configurations. The simulation training distribution contains extensive sampling, but the policy is not evaluated on arbitrary unreachable goals, contact-rich constraints, obstacles requiring explicit collision avoidance, or substantial model changes. PolicyIK therefore does not replace feasibility checking or motion planning for general manipulation.

The approach also remains robot-specific in its training. The OpenArm and xArm7 results show that the formulation transfers as a design pattern, but the physical policies are trained separately, and the paper does not demonstrate zero-shot deployment across embodiments. The VLA experiment is simulated and uses a fixed operational-space adapter, so it does not establish equivalent performance under real visual perception, perception latency, or real object-contact uncertainty.

The deployment result of $98.92\%$ depends on up to eight transient-goal retries and an error-corrected goal mechanism. This is a useful system protocol, but it increases execution time and does not resolve tasks whose goals lie very close to joint limits. The remaining simulation failures are concentrated near such limits: failed goals have a median worst-joint distance of $1.3\%$ of the joint range, compared with $5.7\%$ for first-attempt successes.

Finally, the physical comparison uses 60 tasks and one principal arm, with controller parameters selected during hardware development. The large holding advantage is consistent across budgets and hold durations, but broader conclusions would require evaluations across payloads, friction and backlash conditions, calibration errors, sensing modalities, and dynamically changing contact loads. The paper leaves open whether the learned policy’s advantage persists when the target is not defined through accurate forward kinematics or when the arm must regulate against external disturbances.

Conclusion

PolicyIK presents high-precision IK as a learned closed-loop regulation problem over an accumulated joint-position reference. Its main technical contribution is not the use of RL alone, but the alignment of the action interface, state representation, error scaling, and reward with the requirements of terminal precision. Command-state feedback preserves the steady-state reference offset, multiscale pose features expose millimeter and subdegree residuals, adaptive action scaling reconciles transport with fine correction, and separate progress and dwell rewards distinguish reaching from holding.

Across 4,120 simulated tasks, the method achieves $93.49\%$ single-attempt strict success with median errors of $0.25$ mm and $0.04^\circ$, rising to $98.92\%$ with structured retries. On physical OpenArm tasks, it holds $43/60$ poses for five seconds, substantially exceeding the $11$–$17$ successes obtained by the classical baselines. The remaining open issue is not whether RL can produce precise IK under the paper’s controlled assumptions, but how reliably this formulation extends to unseen embodiments, imperfect pose estimation, changing dynamics, contact constraints, and goals near or beyond the feasible joint-limit manifold.