Decision Algorithms // Bridging perception and action

Robotics Decision-Making

From noisy sensor data to intelligent action — explore the algorithms that enable autonomous robots to reason, plan, and adapt in complex environments.

Response

~1ms

Real-time

Safety

99.9%

Verified

Adaptation

Dynamic

Online

Explore Algorithms See Applications

robotics@decision — ~ Live

$ analyze pipeline --stage=decision

                    ┌─ DECISION PIPELINE ─────────────────────────┐

                    │ → Sensors: Lidar, Camera, IMU @ 1000Hz        │

                    │ → Perception: Object detection & SLAM        │

                    │ → State: EKF pose estimation                  │

                    │ → Planner: RRT* path + MPC trajectory        │

                    │ → Control: Force/torque commands            │

                    └─────────────────────────────────────────────────┘

                    STATUS: All systems operational

Sensors

→

Perception

→

State

Plan

→

Control

→

Act

Algorithms

12+

Core methods

Domains

Research areas

Applications

Real-world systems

Latency

~1ms

Real-time

Estimation Complete

Planning Complete

Control Active

Learning Pending

The Decision-Making Challenge

Robots operate in uncertain, dynamic environments. They must process multiple streams of noisy data and decide in milliseconds.

Core Constraints

Autonomous robots face four fundamental challenges: uncertainty in sensor data, hard real-time latency constraints, physical/safety limitations, and unexpected dynamic events. Decision-making algorithms must balance competing objectives while guaranteeing safety bounds.

The Algorithm Stack

Four foundational layers that transform raw perception into intelligent action.

Kalman Filters Classic

Optimal estimation for linear systems with Gaussian noise. Extended (EKF) and Unscented (UKF) variants handle nonlinearities.

O(n²) complexity Gaussian noise

Particle Filters MCL

Monte Carlo Localization for non-Gaussian distributions. Sample-based representation of belief state.

O(m·n) complexity Multi-modal

SLAM Mapping

Simultaneous Localization and Mapping. EKF-SLAM, GraphSLAM, and modern implementations like Cartographer.

Real-time capable Loop closure

Sensor Fusion Integration

Complementary and Kalman-filter fusion for IMU+lidar, camera+depth, multi-modal perception pipelines.

Multi-rate Redundancy

A* Search Graph

Heuristic graph search with optimality guarantees. D* and D* Lite for dynamic replanning in changing environments.

Complete Optimal

RRT/RRT* Sampling

Rapidly-exploring Random Trees for high-dimensional spaces. Asymptotically optimal, probabilistically complete.

High-dim Anytime

Trajectory Opt. CHOMP

CHOMP, TrajOpt, and STOMP for smooth, collision-free trajectories. Covariance-based optimization.

Smooth Constraints

Behavior Trees Task

Hierarchical task planning with reactive execution. State machines for mission-level decision logic.

Reactive Modular

PID Control Classic

Proportional-Integral-Derivative control. The workhorse of robotics for trajectory tracking and setpoint regulation.

Simple Robust

MPC Optimal

Model Predictive Control with receding horizon optimization. Handles constraints and multi-objective costs.

Constraints Predictive

LQR/LQG Linear

Linear Quadratic Regulator for optimal feedback control. LQG adds optimal state estimation.

Optimal Stable

Whole-Body IK

Whole-body control with operational space formulation, inverse kinematics, and torque optimization.

Multi-DOF Coordinated

Reinforcement Learning RL

DQN, PPO, SAC for learning policies from experience. Model-free and model-based approaches.

DQN/PPO/SAC Sample efficient

Imitation Learning BC

Behavior cloning from demonstrations. DAgger for iterative improvement with expert feedback.

Demonstrations Safe init

Sim-to-Real Transfer

Domain randomization, system identification, and domain adaptation for sim-to-real transfer.

Randomization Adaptation

Online Learning Adaptive

Continual learning, meta-learning, and fast adaptation for changing environments and tasks.

Continual Meta-RL

Decision Pipeline in Action

Click each stage to see how data flows through the decision-making pipeline.

Sensors Raw data

→

Perception Objects

→

State Pose estimate

→

Planner Path

→

Controller Commands

→

Actuators Motion

1. Sensors — Raw Data Input

Lidar scans return distance measurements, cameras provide RGB/D data, IMU reports acceleration and angular velocity. Each sensor operates at different rates (lidar: 10-20Hz, camera: 30Hz, IMU: 1000Hz) with varying noise characteristics. The first challenge is synchronizing and validating these heterogeneous streams.

2. Perception — Feature Extraction

Object detection networks (YOLO, Faster R-CNN) identify semantic entities. SLAM backends extract visual features for localization. Point cloud processing (PointNet, 3D detectors) builds scene understanding. Output is structured data: bounding boxes, point clouds, semantic labels.

3. State Estimation — Where Am I?

Filter algorithms (EKF, particle filter) fuse multi-modal sensor data to estimate robot pose (x, y, θ) and velocity. Covariance matrices represent uncertainty. This belief state enables robust decision-making despite noisy measurements.

4. Planning — What Should I Do?

Global planners (A*) compute optimal paths to goal. Local planners (RRT*, DWA) handle dynamic obstacles and constraints. Behavior trees encode mission logic. Output is a reference trajectory or set of waypoints.

5. Control — How Do I Execute?

Controllers (PID, MPC) compute low-level actuator commands to track the planned trajectory. Inverse dynamics or kinematics convert desired motion to motor torques/velocities. Feedforward terms compensate for gravity and friction.

6. Actuators — Physical Action

Motor controllers receive commands and drive physical motion. Encoders provide feedback for closed-loop control. The result is robot movement in the real world — completing the decision loop.

See It In Code

Core algorithms implemented in Python.

Kalman Filter

class KalmanFilter:
    def predict(self, u):
        self.x = self.F @ self.x + self.B @ u
        self.P = self.F @ self.P @ self.F.T + self.Q

    def update(self, z):
        K = self.P @ self.H.T @ inv(self.H @ self.P @ self.H.T + self.R)
        self.x = self.x + K @ (z - self.H @ self.x)
        self.P = (I - K @ self.H) @ self.P

A* Path Planning

def astar(start, goal, neighbors, heuristic):
    frontier = [(0, start)]
    came_from = {start: None}
    cost_so_far = {start: 0}

    while frontier:
        _, current = heappop(frontier)
        if current == goal:
            return reconstruct_path(came_from, current)

        for next_node in neighbors(current):
            new_cost = cost_so_far[current] + 1
            if next_node not in cost_so_far or new_cost < cost_so_far[next_node]:
                cost_so_far[next_node] = new_cost
                priority = new_cost + heuristic(next_node, goal)
                heappush(frontier, (priority, next_node))
                came_from[next_node] = current

Algorithm Selection Guide

Trade-offs matter — no silver bullet in robotics.

Algorithm	Speed	Optimality	Completeness	Dimensionality	Use Case
A*	Medium	✓	✓	Low (2D)	Global planning
RRT*	Fast	Asymptotic	Probabilistic	High	Arm planning
MPC	Slow	Local	—	Medium	Trajectory tracking
PID	Very Fast	—	—	Low	Simple control
DQN	Variable	—	—	High	Learning tasks
EKF	Fast	Optimal	—	Medium	Localization

Where These Algorithms Run

Real-world robotics systems in action today.

Autonomous Driving

Perception fusion, behavior planning, MPC control for safe navigation in complex traffic.

Manipulation

RRT for motion planning, force control, learning from demonstration for grasping.

Drones

EKF for state estimation, trajectory optimization, obstacle avoidance in 3D space.

Humanoids

Whole-body control, ZMP planning, reinforcement learning for locomotion.

Warehouse Robots

Navigation stacks, task planning, fleet coordination for logistics automation.

Medical Robotics

Precision control, haptic feedback, safety-critical planning for surgical assistance.

Learn More

Essential resources for deeper study.

Probabilistic Robotics

Thrun, Burgard, Fox — The foundational text

Planning Algorithms

LaValle — Comprehensive planning reference

ROS Navigation Stack

Production-grade navigation framework

OMPL

Open Motion Planning Library

Robots That Reason, Plan, and Adapt

The algorithms that bridge perception and action — making robots truly intelligent.

Try Veronica Console