05Control & Planning

The control technology that keeps a robot moving stably as intended; in embodied AI it usually means legged walking and balance.

Splits control into layers: a slow, high-level layer sets goals, and a fast, low-level layer tracks them and drives the motors.

The cerebellum in the brain-cerebellum split: the layer that turns high-level commands into fast, stable joint motions.

How many times per second a controller sends out commands, in Hz; its reciprocal is the control period.

How many times per second a learned policy is called to compute a new action, often lower than the control frequency below it.

A classic feedback controller that combines the current error, its accumulated history, and its rate of change into one output.

Feedback control based on how large an error is and how fast it's changing — PID with the integral term dropped.

A set of numbers measuring how fast, how stable, and how accurately a system's output reaches a target after a sudden change.

An actuator pinned at its limit while the integral term keeps accumulating, causing overshoot; anti-windup keeps that term in check during saturation.

Using a model to compute the needed control input in advance, and adding it directly, rather than waiting for an error to appear.

The highest signal frequency a closed-loop system can still keep up with, usually taken where the gain drops by 3 dB.

A control program that reads sensors, computes a command, and sends it to the motors on a fixed cycle, every cycle, on time.

The time gap between a sensor capturing data and the motor actually executing the corresponding action.

The fluctuation in when a periodic task actually runs versus its ideal timing — a key measure of real-time performance.

Writing out a mathematical model of the robot and its environment first, then deriving or optimizing control commands from it.

Using data and machine learning to build or improve a controller, rather than relying entirely on hand-derived equations and tuning.

Give a motor or joint a target angle or position, and the controller drives it there and holds it.

The higher level specifies a desired speed, and the drive makes the motor or robot move at that speed.

Commanding a joint directly with ‘how much torque to output,’ rather than ‘which angle to turn to.’

Nests several feedback loops, where the outer loop's output becomes the inner loop's target — like position over velocity over current.

Controlling a robot using each joint's own angle as the target and error, with every joint tracking its own desired trajectory.

The two coefficients, Kp and Kd, in joint PD control that determine how stiff and how stable a joint feels.

A single joint-motor command carrying target position, velocity, Kp, Kd, and feedforward torque, with the drive computing torque via a PD formula.

Switching a motor drive into a state where it can actively output torque (enable), or cutting that output off (disable).

Aligning each joint's encoder reading with the model's ‘zero degrees’ so the robot has a correct angle reference.

Three CiA 402 modes where the host sends a new position, velocity, or torque setpoint once every communication cycle.

A control mode where the host streams target joint angles or poses at a fixed rate and the controller just tracks them, without planning.

Transforming three-phase current into a coordinate frame that rotates with the rotor, then separately controlling the flux-producing and torque-producing current.

Precomputing the joint torque needed to hold up the robot's own weight and adding it feedforward so the arm doesn't sag.

Estimating the friction torque inside a joint and adding it into the control command ahead of time to cancel it out.

Letting a robot arm cancel out its own gravity and friction so a person can push it around with barely any force.

Using measured input-output data to work backward to a system's mathematical model and parameters.

Using a dynamics model to compute the torque needed, canceling nonlinearities, then applying PD control on top.

Using state feedback to exactly cancel nonlinear terms, turning the system into a linear one before designing a controller for it.

Using a nominal model to work backward to unknown disturbances like friction and payload, then canceling them out in the control input.

Lumping model error and external disturbances into one ‘total disturbance,’ estimating it in real time, and canceling it out.

Estimating unknown or changing parameters online while running, and automatically adjusting the controller accordingly.

Control design that guarantees stability and performance despite model inaccuracy, bounded parameter variation, and external disturbance.

A control method that forces the state onto a designed ‘sliding surface’ via switching, then slides it to the target with strong robustness.

Computing error and issuing commands based on the end-effector's position and orientation, rather than individual joint angles.

Computing desired end-effector acceleration and force directly, then converting them to joint torque through the robot's dynamics.

Controlling how much force a robot applies to an object, rather than just where it moves.

Control methods that let a robot yield to some set degree instead of fighting back when it contacts the environment.

Making a robot compliant when it meets force, like a spring and damper, instead of rigidly forcing its way to a target position.

Measures the external force applied, computes the resulting motion from a set mass-damper-spring relationship, and hands that to the position loop.

In contact tasks, splitting directions apart — controlling force where the robot is constrained, position where it is free.

Keeping a robot's end-effector applying a set, constant pressure against a contact surface — for example, holding 10 newtons.

Making every joint of a robot behave like a spring and damper, yielding compliantly when pushed instead of resisting rigidly.

Making the arm's end-effector behave like it's mounted on a spring and damper: it yields when pushed and springs back when released.

Impedance control whose stiffness and damping change in real time with the task phase or sensed force, stiff when needed and soft when needed.

Designing a controller from an energy standpoint, so the closed-loop system only ever dissipates energy, never creates it, and is thereby stable.

Letting a learned manipulation policy sense contact force or output stiffness, so it maintains contact without pressing too hard.

Feeding image error straight into the control loop, adjusting the robot's motion in real time as the camera watches.

A closed-loop vision-control method that computes camera or arm velocity directly from the pixel error of image feature points.

A visual servo method that first estimates the target's 3D pose from the image, then drives the robot to reduce the pose error.

Deciding where a robot should be and how fast at every moment in time — a path plus a schedule.

An intermediate point a robot is required to pass through during motion, used to constrain which route it takes.

Filling in a continuous, timed trajectory between a few given key points, such as a start, an end, and waypoints.

The two most common arm-motion commands: move through joint space, or make the end-effector travel in a straight line.

Writing and verifying a robot program in a 3D simulation on a computer first, then downloading it to the real robot to run.

A speed plan of constant acceleration, constant speed, then constant deceleration, tracing a trapezoid on a velocity-time graph.

A velocity plan that limits jerk so acceleration changes smoothly, making the speed-versus-time curve look like an S.

A smooth polynomial curve shaped by a handful of control points, often used to describe robot trajectories.

Connecting a sequence of waypoints into a smooth curve, continuous in both position and velocity, using piecewise cubic polynomials.

A point-to-point trajectory method that fits a fifth-degree polynomial matching position, velocity, and acceleration at both ends.

A trajectory that minimizes the integral of squared jerk (the rate of change of acceleration), giving smooth motion close to how a human hand moves.

A piecewise-polynomial trajectory minimizing the integral of squared snap (the 4th derivative of position), commonly used for quadrotor drones.

Attaching a timing schedule to a purely geometric path, deciding when each point is reached and how fast.

Given a fixed path, find the fastest possible timing schedule that still respects velocity, acceleration, and torque limits.

Keeping a robot's actual motion closely following a time-varying reference trajectory, driving the error toward zero.

For a system that repeats the same motion over and over, using last time's tracking error to correct next time's control input.

Splitting a motion command into several time-offset sub-commands so the vibrations they excite cancel each other out.

Filtering or penalizing a policy's output actions to remove high-frequency jitter, so joint motion stays smooth.

Breaking a complex motion into small, reusable, parameterizable building-block motions that get composed together when needed.

Encoding a demonstrated trajectory as a ‘spring-damper plus a learnable force term’ dynamical system, reproducible with a different endpoint or speed.

A movement primitive that represents a whole family of demonstrated trajectories as a Gaussian distribution, conditionable on via-points or goals.

Summarizing demonstrated trajectories with a handful of Gaussian distributions, then generating a matching motion for a new object position.

Finding, subject to the system's dynamics, a sequence of control inputs that minimizes total cost.

Writing ‘how to move’ as an optimization problem: satisfy the dynamics and constraints while minimizing a cost.

Uses a model to predict the near future at every step, optimizes an action sequence, executes only the first step, and repeats.

Minimizing a convex function over a convex feasible region — a problem where any local optimum found is also the global one.

An optimization problem with a quadratic objective and linear equality or inequality constraints, extremely common in control.

An iterative algorithm that solves nonlinear constrained optimization by repeatedly approximating it as a quadratic program.

The optimal feedback controller for a linear system: trading off state error against control effort, solving for a fixed gain u = −Kx.

A model-based estimator that reconstructs a system's unmeasured internal states in real time from its known inputs and outputs.

Fusing a model's prediction with a noisy measurement, weighted by how much each is trusted, to estimate a system's state.

Linearizes a nonlinear system around the current estimate, then applies the ordinary Kalman filter for state estimation.

When the state is only partially measured and noisy, first estimate it with a Kalman filter, then compute control with LQR.

A trajectory-optimization algorithm that repeatedly linearizes a nonlinear system along its current trajectory and solves an LQR each round.

A trajectory-optimization method that repeatedly makes a second-order approximation along the current trajectory and sweeps back and forth to improve the control sequence.

Cutting a trajectory into nodes, writing the dynamics as constraints between nodes, and turning the whole thing into one big optimization problem.

Cutting a long trajectory into segments, integrating each one separately, then stitching them together with continuity constraints.

Letting the optimizer decide, on its own, when and where to contact the environment, instead of fixing the contact order in advance.

MPC that uses a nonlinear dynamics model to predict the future and solves an optimization online every control cycle.

MPC that samples many candidate action sequences each cycle, scores them by simulation, and executes the best one's first step.

A sampling-based MPC that randomly samples large numbers of control sequences each cycle, simulates them, and averages them weighted by cost.

A gradient-free optimizer that repeatedly samples a batch, keeps the best, and refits the sampling distribution to them.

Learning to predict what the camera view will look like after an action, then picking whichever imagined action reaches the goal best.

The sequence and rhythm in which a legged animal or robot's legs lift and touch down while moving.

A quadruped gait where diagonal leg pairs touch down together and the two pairs alternate.

Deciding when each of a legged robot's feet touches down and lifts off, and the rhythm of its steps.

A number that cycles from 0 to 1, indicating where the robot currently is in its gait cycle.

A neural circuit or oscillator that produces rhythmic output on its own, with no rhythmic input, used to drive a gait.

Computing where and in what orientation a legged robot should plant each of its next footsteps.

A foot-placement rule that shifts the landing spot forward or back based on body speed to regulate a legged robot's forward motion.

Planning the path a legged robot's airborne foot follows from lift-off to landing during the swing phase of a gait.

Keeps a legged or humanoid robot from falling over while standing, walking, or being pushed.

A robot's ability to adjust its posture or take a step after being pushed or bumped, regaining balance without falling.

A three-tier response to being pushed while balancing: move the ankle, swing the torso, or take a step.

The part of walking when both feet are on the ground at once, as the body's support shifts from the rear foot to the front foot.

Generating stable biped gaits by looking ahead at a planned future ZMP trajectory and moving the center of mass to match it in advance.

Having a humanoid robot walk the way people do — knee straight, heel touching down first, then pushing off with the toe.

Using ‘virtual constraints’ to compress bipedal walking into a low-dimensional system, then designing and proving a gait stable.

Imagining virtual springs and dampers attached to the robot, then converting the forces they'd produce into joint torques.

Simplifying a legged robot to a single rigid body so MPC becomes a quadratic program that solves quickly to the global optimum.

Given the total force and torque the body needs, solving how much force each foot or finger should contribute.

Planning which body part — foot, hand, knee — contacts the environment where and in what order, to make use of that contact for leverage.

Computes commands for all of a humanoid's or legged robot's joints together, so several tasks are accomplished at once.

Using spare degrees of freedom to accomplish a secondary goal without disturbing the primary task.

Ranking a robot's simultaneous goals by importance so lower-priority tasks can never disturb higher-priority ones.

Solving multiple control objectives in strict priority order, layer by layer, so lower priorities never interfere with higher ones.

Training a neural network with reinforcement learning in simulation to directly control a legged robot's walking.

The standard training task where a legged robot walks according to a given forward, lateral, and turning speed.

Encoding gait phase as a pair of numbers, sin and cos, fed into the policy network so it knows the beat.

A neural network, trained with reinforcement learning in simulation, that coordinates a humanoid robot's entire body from one policy.

A humanoid setup where the lower body uses reinforcement learning to walk and balance, and the upper body uses inverse kinematics to control the arms.

A whole-body control task where a robot reproduces a reference motion, such as human motion-capture data, in real time.

Two related abilities for a humanoid: minimizing damage while it falls, and getting itself back up afterward.

The engineering layer, and job title, covering both deciding how to move and making the actuators follow that decision.

Computing a sequence of poses or a trajectory from start to goal that avoids collisions and satisfies constraints.

Finding, without collisions, a sequence of positions or poses to pass through from a start to a goal.

A robot senses an obstacle and adjusts its path or motion ahead of time so it doesn't run into it.

A grid map of the ground where each cell is labeled with a cost of passing through it, used for navigation planning and obstacle avoidance.

Navigation split into two layers: global planning finds a route across the whole map, local planning follows it while dodging nearby obstacles.

A classic algorithm that finds the shortest path from a start node to every other node in a graph with non-negative edge weights.

A shortest-path search algorithm that expands whichever node has the lowest cost so far plus estimated cost to the goal.

An A* variant that searches over a grid but tracks a vehicle's continuous position and heading, so the resulting path is actually drivable.

Recomputing a path or set of steps mid-execution in response to new information, instead of sticking to the original plan.

A graph-search algorithm that, as the map changes while a robot moves, patches only the affected part to quickly recompute the shortest path.

The goal generates an attractive force and obstacles generate repulsive forces; the robot moves along the combined force in real time.

Sampling, simulating, and scoring the velocities a robot could reach next, then picking the best one — a classic local obstacle-avoidance method.

A local motion planner that treats a timed trajectory as an elastic band, optimized in real time against obstacles and motion limits.

A path-tracking method that picks a lookahead point ahead on the path and steers along the arc needed to reach it.

A method that marks the set of velocities in velocity space that would cause a collision, then picks a safe one closest to what's desired.

Planning routes for a whole group of robots to their respective goals at the same time, guaranteeing none of them collide.

A robot repeatedly drives toward the boundary between known open space and unknown territory, mapping as it goes.

Planning a path that sweeps a robot, or its tool, across every reachable part of an area.

During planning, querying whether a given pose or path segment would make the robot hit itself or the environment.

Determining whether a robot's own links would collide with each other in a given pose.

Wrapping a complex object in a simple shape, like a box or sphere, for a quick first pass before exact collision checks.

A classic iterative algorithm that tells whether two convex shapes intersect and computes the distance between them.

A family of motion-planning methods that randomly sample points in configuration space and connect the collision-free ones into a path.

A planner property: whenever a solution exists, the chance of finding a feasible path approaches 1 as sampling increases.

A planning algorithm that first scatters random points into space and connects them into a road network, then searches it for a path.

A planning algorithm that grows a tree from the start by repeatedly sampling random points and reaching toward them, until a branch reaches the goal.

An extension of RRT that adds parent selection and rewiring so path cost converges to optimal as sampling increases.

After finding a path once, sampling only inside the ellipsoidal region that could still shorten it, so RRT* converges faster.

A planning algorithm that samples points in batches and searches them in a heuristic order to converge on an optimal path.

A path planner that grows two random trees, one from the start and one from the goal, and greedily connects them.

Post-processing a jagged planned path to cut out detours and round off corners, so the robot moves shorter and smoother.

Planning that satisfies obstacle avoidance and dynamics limits like velocity, acceleration, and torque together, producing a directly executable trajectory.

A 3D grid where every cell stores the true distance to the nearest obstacle, positive outside and negative inside, with a computable gradient.

A trajectory-optimization planner that uses gradient descent to push an initial trajectory away from obstacles while keeping it smooth.

A gradient-free trajectory optimizer that samples noisy trajectories around an initial guess and updates it by cost-weighted averaging.

A motion-planning method and open-source library that finds locally optimal, collision-free robot trajectories via sequential convex optimization.

Splitting free space into convex chunks connected into a graph, then using convex optimization to find a globally good, smooth trajectory.

A reactive control framework where each sub-goal contributes a desired acceleration and an importance matrix, combined by weighted sum.

An NVIDIA reactive motion-generation framework that synthesizes obstacle avoidance and joint-limit behavior in real time with provable stability.

Using a neural network trained on huge numbers of planning examples to learn to generate collision-free motion directly.

Computing where and how a gripper or dexterous hand should grip an object — position, orientation, and finger configuration.

An intermediate pose where the gripper pauses near an object, aligned with the grasp direction, just before the actual grasp.

A model where a system is always in exactly one of a fixed set of states, switching states according to fixed rules on each event.

A tree-structured way of organizing actions and conditions to decide what a robot should do next.

Given the current state and a goal, finding a sequence of high-level action steps that achieves it.

Planning that describes states and actions as logical symbols, then searches for an action sequence that reaches a goal.

A standard language for writing down actions' preconditions, effects, and a task's goal, for a general-purpose planner to solve.

Breaking a large task down, layer by layer, into directly executable actions using human-written ‘decomposition methods.’

A decision algorithm that estimates how good each choice is through large numbers of random simulations, growing a search tree as it goes.

Jointly solving both which actions to take and exactly how each action should move, at the same time.

Using a large language or vision-language model to break a high-level instruction into a sequence of sub-tasks a robot can execute.

A control scheme where the robot infers a human operator's intent and blends its own autonomous action with the person's input.

A safety function that stops a machine with a single action in an emergency — typically a red mushroom button on yellow.

A safety function that brings a robot to an automatic, controlled halt as soon as it detects an overload or hazard.

A joint stops chasing its target position and only resists motion with damping, letting the robot settle down gently.

A software-defined motion boundary set more conservatively than the mechanical limit, stopping the robot before it reaches the hard stop.

Clipping the controller's computed torque to what the motor can actually deliver, discarding whatever exceeds that.

A timer that requires a program to check in periodically and forces a safe state if it stops responding in time.

Detecting, in real time while the robot moves, that it has hit a person or object, and immediately stopping or yielding.

Estimating the external torque acting on a robot using only joint position, velocity, and motor torque — no force sensor needed.

The strategy a robot follows after detecting a collision — deciding whether to stop, go soft, or yield.

A collaborative-safety mode that lets a robot touch a person but caps contact force and pressure below injury thresholds.

A collaborative-robot safeguard that tracks human-robot distance in real time and slows or stops the robot once it gets too close.

Relying on automated protective functions to bring equipment to a safe state after a fault, with the reliability of that response quantified.

Rating scales for how reliably a machine's safety functions work: ISO 13849's PL a–e, and the IEC family's SIL.

The core international safety standard for industrial robot design and integration, revised with a new edition in 2025.

A 2016 ISO technical specification setting force and pressure limits for human contact with collaborative robots.

An international safety standard for mobile service, wearable-assist, and person-carrying robots that operate in close proximity to people's daily lives.

A safety standard, still being drafted, specifically for humanoid, quadruped, and other industrial mobile robots that need active balancing just to stay upright.

A theory for judging whether a disturbed system returns to equilibrium, typically proven using an ‘energy function’ that never increases.

An energy-like function that, as long as some control choice can always make it decrease, proves the system can be steered to its goal.

Writing ‘don't cross this boundary’ as a constraint, nudging the control command only minimally, and only when safety is close to being violated.

A layer between a policy and the actuators that only minimally overrides an action when it would otherwise be unsafe.

Solving a partial differential equation to compute the safe region — the set of states from which danger is guaranteed avoidable.