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.
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+
Quad Cortex-A76 · Hailo 13–26 TOPS · $80 + $70–110The most familiar Linux brain with a bolt-on vision accelerator and 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 honest 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.
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.
Specs and prices verified July 2026 and kept current. Have a board that belongs here? Tell us →