The boards that can actually think.
A robot is only as capable as the mind you give it. This is a directory of maker boards that can run Physical AI models, grouped by the role they play on the machine, from a few-dollar microcontroller to an edge-AI module that runs a full vision-action policy.
It has to run a real policy.
The gate for this directory is simple and strict: can it run a genuine Physical AI model (perception, or a learned policy) either on-device or by pairing with one that does? A robot locked to canned, pre-scripted behaviors is a toy, not a substrate. Every board here clears that gate.
Brains, reflexes, and accelerators.
You don't need the biggest board: you need the right one for the job. Most real builds combine a couple: a main brain, cheap reflexes, and sometimes a bolt-on accelerator.
Vision-action brains
Linux-class boards with enough compute and memory to run real perception, and, at the top, a full vision-action policy on-device, no laptop tether.
Tiny-ML microcontrollers
Cheap, low-power boards that run tiny models and drive the motors. Often the 'eyes' or reflexes paired with a Tier-A brain, or offloading heavy perception to a phone or laptop.
Accelerators & FPGA co-processors
Bolt-on compute: an M.2 NPU that takes the neural load off the main board, or an FPGA fabric for hard real-time sensor and motor work a CPU does poorly.
Vision is cheap. A real VLA is not.
Almost every low-cost NPU here (Hailo-8, Coral, the Rockchip and Kendryte engines) is an INT8 vision accelerator: excellent at detection, pose, and segmentation, but it won't run a full transformer vision-action model on the accelerator itself. A true on-device VLA needs a GPU-class brain (Jetson Orin or Thor) or an LLM-capable NPU with its own DRAM (Hailo-10H). Below that line, the policy runs on the host CPU while the NPU feeds it eyes, which is plenty for most maker builds.
What actually runs where, in 2026: a TinyML classifier or keyword-spotter on the microcontroller tier (Grove Vision, OpenMV); a 450M SmolVLA, a real vision-language-action policy, on a $249 Jetson Orin Nano Super or a Pi 5 with the AI HAT+ 2 (40 TOPS, enough to run local LLMs/VLMs); and a full foundation model (GR00T N1.7, π₀.₇) on a Jetson Thor. Even Gemma 4 runs on a bare Pi 5. Every tier can touch a VLA in simulation first, regardless of budget.
See the models, sims, and the teleop→train→deploy loop mapped: the Maker Atlas → · learn to build one: Connection Systems →
Full Linux-class boards.
The mind of the robot. The top of this tier runs a real vision-action policy on-device; the rest run rich perception and small or distilled policies.
NVIDIA Jetson AGX Thor
Blackwell GPU · 128 GB · 2,070 FP4 TFLOPS · $3,499The humanoid brain: runs large VLAs on the robot. Overkill for a simple rover.
NVIDIA Jetson Orin Nano Super
Ampere GPU · 8 GB · 67 INT8 TOPS · $249The default autonomous-robot brain: real-time vision, VLMs, distilled policies, the most mature edge-AI stack.
Radxa Rock 5 (RK3588)
8-core Arm · up to 32 GB · 6 TOPS NPU · ~$150Best-value full-Linux main brain; runs YOLO well and small LLMs/policies. Add an NPU for heavy nets.
Raspberry Pi 5 + AI HAT+ 2
Quad Cortex-A76 · Hailo-10H 40 TOPS INT4 + 8 GB · $80 + $130The most familiar Linux brain, now with on-HAT memory that runs local LLMs and VLMs, not just vision, the biggest community.
Particle Tachyon
Qualcomm QCM6490 · ~12 TOPS · 5G + Wi-Fi 6E · $249A connected edge brain for when the robot needs its own cellular link, not just perception.
BeagleY-AI
TI AM67A · 4 GB · 4 TOPS · $70 · OSHWA-openThe most-open main brain; multi-framework (ONNX + TFLite) on fully-published hardware.
CanMV-K230
Dual RISC-V · ~6 TOPS KPU · ~$49The cheap RISC-V vision brain / smart camera; MicroPython + OpenMV, real on-device detection.
Microcontroller-class boards.
Cheap, low-power, and tiny. Great as a robot's 'eyes' or reflexes, and the home for boards that teach embedded skills but can't host a policy.
Espressif ESP32-P4 / S3
Dual RISC-V or Xtensa + SIMD · camera + ISP (P4) · $3–50Smart-camera 'eyes' and tiny-robot reflexes; runs detection/pose on the CPU, feeds a bigger brain.
Raspberry Pi AI Camera (IMX500)
On-sensor neural accelerator · 8 MB · $70Inference runs inside the sensor: only the result crosses the wire, so the host CPU stays free.
OpenMV Cam N6
STM32N6 · Cortex-M55 + ST Neural-ART NPU (600 GOPS INT8) · 1 MP global shutter · $180A MicroPython smart camera that runs real CNNs on-device, YOLOv8n at 30+ FPS under 0.75 W. Calibrated vision in a few lines of Python; feeds a bigger brain over UART/SPI.
OpenMV AE3
Alif Ensemble E3 · dual Ethos-U55 NPUs (204+46 GOPS) · IMU + mic + ToF · $120The battery-grade OpenMV: YOLO at 30 FPS and 80 µA in deep sleep, the lowest-power board here that still runs a real NPU. Runs for years off a cell.
Milk-V Duo (SG2002)
RISC-V + Arm + ~1 TOPS TPU · $8A pocket Linux + NPU node: cheap actuation and light vision at the edge of a bigger build.
LuckFox Pico (RV1106)
Cortex-A7 + ~1 TOPS NPU + ISP · $14+Thumb-sized perception co-processor for small detection where space and power are tight.
uFerris (XIAO ESP32-C3)
Single-core RISC-V · 160 MHz · Wi-Fi/BLE · $25A Rust-on-embedded teaching board: reflexes, comms, and the on-ramp to embedded Rust. Not an AI brain: pair it with a Tier-A brain for the policy.
Co-processors, not standalone brains.
Bolt these onto a host: an M.2 NPU for heavy nets, or an FPGA fabric for hard real-time sensor and motor work.
Hailo-10H (M.2)
40 INT4 TOPS · own 4–8 GB DRAM · ~$130 (Pi AI HAT+ 2)The on-device LLM/VLM/VLA accelerator: its own memory lets a modest SBC run a real policy without a Jetson.
Hailo-8 (M.2)
26 TOPS INT8 · ~$70–220A high-FPS vision front-end (detection, pose, segmentation) bolted onto a Pi- or x86-class host.
SparkFun Alchitry Au / Cu
Artix-7 FPGA ($150) / iCE40 FPGA ($54, fully-open flow)Deterministic real-time: sensor sync, motor commutation, and small custom quantized-NN fabric a CPU can't hit.
Google Coral / Edge TPU
4 TOPS INT8 · TFLite-only · end-of-lifeLegacy: flagged, not recommended for new designs. Prefer Hailo or BeagleY-AI.
Eyes, depth, balance, and skin.
A brain is only as good as what it perceives. These are the cameras and sensors that pair with the boards above, the eyes, the depth, the balance, and the sense of touch that close a Physical AI loop.
ESP32-CAM
OV2640 · Wi-Fi · ~$8The cheapest eye of a printed rover, streams video and runs tiny detection via Edge Impulse.
Raspberry Pi AI Camera
Sony IMX500 · $70Inference runs inside the sensor; only the result crosses the wire, so the host CPU stays free.
OpenMV
N6 / AE3 · real NPUA smart camera that runs CNNs on-device, blob, tag, and YOLO in a few lines of Python.
Luxonis OAK-D
stereo depth · on-cam NPUFuses neural nets with stereo depth and returns 3D-located detections, the camera as a perception node.
Intel RealSense (D4xx)
RGB-D stereoThe dominant RGB-D depth camera: in most mobile robots and humanoids.
LDROBOT LD19
360° 2D LiDAR · ~$70A cheap spinning laser scanner for SLAM and navigation on a printed mobile base.
ST VL53L5CX
8×8 laser ToFA multizone time-of-flight grid: a poor-man's depth field for obstacles and gestures.
Bosch BNO085
9-DOF · on-chip fusionOutputs stable orientation quaternions: the balance sense every legged or flying robot needs.
DIGIT / DIGIT-360
camera-based tactileMeta's open camera-in-a-fingertip: high-resolution touch, with 3D-printable mounts.
AnySkin
printable magnetic skinA replaceable, self-adhesive tactile skin: the first whose touch policies transfer across copies.
The full sensor landscape and how it connects: the Maker Atlas →
Specs and prices verified July 2026 and kept current. Have a board or sensor that belongs here? Tell us →