Built, and opening soon
Foundations of Robotics and Physical AI
Program 1 of the GAGE Robotics and Physical AI path. Start at zero and leave able to build, program, and simulate a real robot: the math, Python and C++, Linux, electronics, sensors, actuators, the ROS 2 software stack, and your first simulator.
After completing this program, you will be able to:
From Code to Real Hardware
The bridge nobody teaches: simulated code onto real machines, flashing firmware, trusting real sensors, surviving real power. Most courses never leave the simulator.
Curriculum · 15 modules
- Your robotics command center: the AI copilot, your dev machine, and the simulation stack
- Simulate first: the practice loop that elite robotics programs run on
- Your map of the robotics path: the Launchpad you are in now and the road ahead
- How to learn robotics fast: deliberate practice, the build log, and learning in the open
- The debugging mindset and the safety habits to build from day one
- The definition of a robot: sensing, computation, and action in the physical world
- The sense, plan, act loop as the universal architecture of every robot
- The five layers: perception, state estimation, planning, control, actuation
- Open-loop versus closed-loop control, and why feedback changes everything
- Degrees of freedom and the idea of configuration space
- The robot families: manipulators, mobile robots, aerial, legged, and humanoid
- Where latency and error enter the loop and compound
- Why robotics is hard: the world is noisy, partial, and unforgiving
- Vectors, points, and reference frames in 2D and 3D
- Matrices as linear transformations of space
- Rotation matrices and their properties
- Homogeneous transformation matrices that combine rotation and translation
- Euler angles, the axis-angle form, and gimbal lock
- Quaternions and why robots prefer them for rotation
- Probability basics for reasoning about noisy sensors
- Derivatives, gradients, and why optimization underlies control and learning
- Doing linear algebra in code with NumPy
- Setting up Python, virtual environments, and packages for robotics
- Core Python: data structures, functions, and classes
- NumPy for fast numerical computation
- Reading sensor data and handling continuous streams
- Visualizing data and signals with Matplotlib
- Writing clean, modular, reusable robot code
- Debugging and logging when a robot misbehaves
- Why production robotics runs on C++ for speed and control
- C++ fundamentals: types, pointers, and references
- Classes, RAII, and managing memory safely
- The standard template library for robotics code
- Building C++ projects with CMake
- Real-time considerations that shape C++ on robots
- Bridging Python and C++ in one robotics stack
- The Linux command line every robot runs on
- The filesystem, permissions, and processes
- Bash scripting to automate setup and tasks
- Version control with Git and GitHub
- Reproducible robotics environments with Docker
- Working on remote robots over SSH
- Standing up a complete robotics development machine
- Voltage, current, resistance, and Ohm's law
- Power, batteries, and distributing power on a robot
- Microcontrollers versus single-board computers
- GPIO, PWM, and reading and driving the physical world
- How common sensors connect and communicate
- Motor drivers and H-bridges
- Wiring, grounding, and avoiding releasing the magic smoke
- The Arduino, ESP32, Raspberry Pi, and Jetson families
- DC and brushless motors and how they produce motion
- Servo motors and closed-loop position control
- Stepper motors and open-loop positioning
- Gear ratios and the torque versus speed tradeoff
- Encoders for measuring rotation and position
- Linear actuators, pneumatics, and hydraulics
- Mechanisms: linkages, belts, and drivetrains
- Choosing the right actuator for a given job
- Proprioception versus exteroception
- Encoders, IMUs, and inertial sensing
- Ultrasonic and infrared distance sensing
- LiDAR and time-of-flight ranging
- Cameras: monocular, stereo, and RGB-D depth
- Radar and its all-weather advantage
- Force, torque, and tactile sensing for contact
- GPS and why it fails indoors
- Sensor noise, bias, drift, and the need for calibration
- What ROS 2 is and the coordination problem it solves
- Installing ROS 2 and the workspace and package model
- Nodes, topics, and the publish and subscribe pattern
- Services for requests and actions for long tasks
- Messages and defining your own interfaces
- Launch files and parameters for whole systems
- The ROS 2 command-line tools for introspection
- Writing your first publisher and subscriber
- Why simulation is where you learn, break things, and iterate safely
- Installing and running the Gazebo simulator
- Spawning a robot into a simulated world
- Connecting Gazebo to ROS 2
- Driving a simulated robot from your code
- Reading simulated cameras, LiDAR, and IMU
- Building a simple world to test in
- The bridge nobody teaches: getting simulated code onto a real machine
- Flashing firmware to an ESP32 or STM32
- Booting a Jetson or Raspberry Pi and running your program on it
- Driving real GPIO, PWM, and motors from your code
- Reading a real sensor and trusting, or doubting, its numbers
- Your first real motion: closing the loop on physical hardware
- What changes the moment code leaves the simulator
- Reading a schematic and following a signal through it
- Pull-up and pull-down resistors, and when and why to use them
- Level shifting and protecting an input pin
- Wiring a sensor to a microcontroller safely
- Choosing a battery chemistry and sizing it for runtime
- Charging, protection, and avoiding a battery fire
- Power distribution, regulation, and surviving a brownout
- Measuring real current draw and budgeting power
- Structuring a robot codebase so it stays manageable
- Writing automated tests for your nodes
- Using a debugger instead of scattering print statements
- Logging in a way that helps the future you
- Git branching, pull requests, and code review on a team
- Tracking issues and integrating work without breaking the robot
- Designing software so future changes are easy
- Capstone overview: the mission, the deliverable, and scoping it to win
- Building your robot and its world: URDF, Gazebo, and a world you design
- Wiring it through ROS 2: nodes, topics, and teleoperated control
- Reading the robot's senses: simulated camera, LiDAR, and IMU
- Closing the loop: driving autonomously around your world
- Demonstrate, document, and defend: your first portfolio piece
Every topic listed here is built and written. The program opens soon, and nothing above can be started or bought before then.
How mastery is proven
Completion is not the bar here. Every claim on your credential is earned through assessment, and your final Mastery Score is built from two halves. The first half is where the teach-back lives.
Every topic ends two ways: a server-graded check (pass at 80% or the next topic stays gated) and a teach-back, where you explain the lesson in your own words and it is graded against the lesson itself on four dimensions. A topic’s score is the average of the two, and the running average across topics is half of your Mastery Score.
Finish every topic and face the summit: a timed, open book final exam of scenario judgment (open book on purpose: we test judgment, not memory), or a rubric-graded capstone project you actually build.
Your credential lives at a permanent signed URL. Employers scan it, see every verified competency with real scores, and can ask it questions grounded in what you actually passed.
Scenario responses are graded on four dimensions no multiple-choice exam can measure:
One focused 30-minute session per topic on the required path. The depth (full read, audio, slides, infographic, prompts) is there when you want it, never forced.
Your passed explanations become part of your credential. An employer who scans it can read how you explained each topic, in your words, if you choose to share them. You own your work and the dossier is off until you turn it on.
9 Content Formats Per Topic
Every topic delivers knowledge through multiple modalities for deeper retention.
Built sourced, shipped verified
Every topic is researched against real, cited sources, then scanned for gaps, bias, hallucination, and outdated material before it ships. Every review pass is logged with evidence, so the quality bar is verifiable, not a claim. The content you learn from has been pressure-tested before it reaches you.
The curriculum above is finished and every topic is named. It opens soon. Leave your email and we will tell you the day it does, and nothing else.
Frequently Asked Questions
No. The program adapts to your role: executive, technical, legal, clinical, or any other.
Every topic is researched against real sources and checked for gaps, bias, hallucination, and outdated material before it ships. When the rules move, the content moves with them.
A completion record with your assessment score. Pass every core topic and the program mastery exam to earn your signed GAGE credential: a living record anyone can verify in seconds by scanning its QR seal. Bonus tracks add visible evidence but never gate the credential.
No. The program is simulate-first on purpose, which is how serious robotics programs actually run: you build and break things in Gazebo where mistakes cost nothing. Module 11 then covers getting that same code onto real hardware, including flashing firmware, for when you want it.
Both, and the program is clear about which job each one is for. Python is where you prototype and reason; C++ is what production robotics runs on when speed and control matter. Modules 3 and 4 teach them in that order for that reason.
Many certification bodies accept self-reported outside training: IAPP members, for example, can self-report relevant non-IAPP training at 1 CPE per hour of study, validated by proof of completion or an assessment, within 90 days of the activity. Your GAGE credential is built for exactly that kind of proof: it records the program and every mastery assessment you passed, with scores, at a link your certifying body can open. Check your own body's policy before relying on it.