Arduino Ventuno Q: $299 for Two Brains — One Runs LLMs, the Other Moves Servos

The Arduino Ventuno Q is a board with two brains, and it's the first time we've seen Arduino put that idea on something this serious. One brain — a Qualcomm Dragonwing IQ8 SoC with a 40 dense TOPS Hexagon NPU and 16GB of RAM — does perception: cameras in, local LLM/VLM inference out. The other brain is an STM32H5F5 Cortex-M33 microcontroller doing deterministic I/O at sub-millisecond timing. They talk to each other over an RPC bridge, so perception, decision, and action all happen on one $299 board.

What it is and why it's interesting//

This is the second Arduino×Qualcomm collaboration after the UNO Q (October 2025), first shown at Embedded World 2026, with pre-orders opening August 25. The pitch that actually makes sense: most "edge AI" boards are great at looking and terrible at acting, because Linux is a preemptive OS — fine for running YoloX on a camera feed, miserable for holding a servo steady or timing a safety-critical PWM edge. Most real-time controllers are the opposite. The Ventuno Q fuses both halves into one chassis with one dev environment (Arduino App Lab) spanning them, aimed squarely at robotics and industrial I/O gateways rather than pure inference boxes.

The specifics//

• Price / where to get it: $299 pre-order, live now at the Arduino store. It's an introductory price — CNX notes it's expected to rise after pre-orders close (Circuit Digest reports the intro pricing runs about two months), and a 65W USB-C supply is included with the order. Delivery in roughly four weeks; also listed through Mouser, DigiKey, Farnell/RS, and Robu.in.
• The AI brain: Qualcomm Dragonwing IQ8 (IQ-8275) — octa-core Kryo Gen 6 CPU, Adreno A623 GPU, Hexagon NPU at 40 dense TOPS (vendor phrasing; we'll stay consistent with it), Spectra ISP. Runs Ubuntu preinstalled (Debian coming soon); Docker and apt are already on the board.
• The action brain: STMicroelectronics STM32H5F5, Cortex-M33 @ 250 MHz, 4MB flash / 1.5MB RAM, running Arduino core on Zephyr RTOS.
• Memory/storage: 16GB LPDDR5 (shared by NPU/CPU/GPU), 64GB eMMC, plus an M.2 slot for NVMe over PCIe Gen4.
• I/O where it counts: triple MIPI-CSI camera inputs (360°/stereo setups), CAN-FD — one PHY on a screw terminal plus more on the JOMEGA header and UNO shield headers — deterministic GPIO/PWM, 2.5GbE, tri-band Wi-Fi 6 + BT 5.3, HDMI out plus DP alt mode over USB-C, and it speaks both UNO shields and Raspberry Pi HATs natively, along with Qwiic/Modulino.
• Form factor/power: 160×100mm, active cooler (there's a fan, covered in the gotchas below), powered from USB-C at 5V/3A, a 12-24V DC barrel jack, or a 7-24V screw terminal.
• Openness: not open hardware — no public schematics at launch and the silicon is Qualcomm/ST proprietary. What is open: Ubuntu/Linux upstream, Zephyr + Arduino core on the MCU side, ROS 2 support, and a full standard Linux dev workflow (VS Code, your own IDE, native tools) if you skip App Lab entirely.
• Software stack: preloaded models optimized for the NPU via Qualcomm AI Hub — Qwen 3 4B and Gemma 4 (E2B/E4B) LLMs, a Qwen 2.5 7B + Qwen 3 4B VLM pair, Whisper ASR, Melo/Piper TTS, YoloX object detection, MediaPipe gesture recognition — plus GGUF import from Hugging Face through a llama.cpp brick and an Edge Impulse path for training/quantizing your own models.

How it actually works//

The interesting engineering is the split itself. The IQ8 side runs standard Linux: cameras feed the Spectra ISP into the NPU, where vision models run at 40 dense TOPS while the CPU handles orchestration — including local LLM/VLM inference for "understand what's happening" workloads, all offline if you want privacy or no uplink. The STM32H5F5 side is where timing-critical stuff lives: GPIO, PWM, and CAN-FD with sub-millisecond response, because a 250 MHz Cortex-M33 on Zephyr doesn't care about Linux scheduler jitter when it's closing a motor-control loop.

The glue is the RPC bridge between the two chips — remote procedure calls across the SoC/MCU boundary. In practice that means your Arduino sketch on the MCU can call into a model or service running on the Linux side without hand-rolling IPC: camera frame → NPU inference → LLM/VLM decision → motion command executed deterministically on the M33, all within one application written in one environment. That's "perception, decision, action" as an architecture rather than a slogan — and it's exactly the shape of a robot, a doorbell that understands who's at the door, or an industrial I/O gateway that watches a line and reacts faster than a cloud round-trip ever could.

Who should buy one (and who shouldn't)//

Buy it if: you're building something that both sees and moves — a robotics rig, a perception node with actuators, an offline kiosk, an industrial edge box — and you'd rather have one board than a Pi + inference SBC + motor controller stack glued together with USB. ROS 2 support makes it a legitimate prototyping platform for exactly that.

• If you just want local LLMs: this is overkill and probably not the cheapest path per token — an inference-focused box or GPU will get more throughput per dollar, and nobody's published the LPDDR5 bandwidth figure that actually determines tokens/sec here.
• If you need open hardware (public schematics, reproducible silicon) now: it's not there yet at launch.
• If you don't write firmware: the $299 buys you a half-idle MCU brain. The value is in using both sides.

And two small gotchas: it has an active cooler (fan noise in a quiet rack, plus one more moving part), and it's a pre-order — you're buying a board that ships in ~4 weeks at a price that will likely go up when the intro window closes.