Your Pi Is Not a GPU. Get Over It.
You’ve got a Frigate instance watching six cameras, and your CPU is wheezing like it ran a marathon in flip-flops. Someone in the home lab Discord says “just throw a Coral on it.” Someone else says “Hailo-8 or nothing, cope.” Now you’re reading benchmarks from 2021 and wondering if any of this applies to your Pi 5 setup.
Here’s the thing: both accelerators are real solutions to a real problem. But they’re aimed at slightly different versions of that problem, and picking the wrong one will either leave you money on the table or stuck compiling a kernel module for three hours on a Tuesday night.
Let’s actually sort this out.
What Even Is an Edge AI Accelerator?
Quick framing before we dive in: these aren’t GPUs. They don’t run general compute. They’re dedicated silicon for neural network inference — specifically the matrix multiply operations that dominate models like object detectors, classifiers, and small transformers.
The pitch is: offload inference from your CPU (or your overworked Raspberry Pi), get low-latency results per frame, keep power draw in check. A ~$60 Coral USB doing 4 TOPS burns about 2W. A $70 Hailo-8 M.2 doing 26 TOPS burns about 2.5W at load. Neither is going to spike your electric bill.
The tradeoff is the model pipeline. These things don’t just “run your model” — they need it compiled/quantized into their own format. That’s where the pain lives.
Google Coral: The Old Reliable That Google Kind of Abandoned
The Coral Edge TPU has been around since 2019. If you’ve been in the home lab scene for more than two years, you’ve probably seen it mentioned in every Frigate tutorial.
The hardware:
- Coral USB Accelerator — USB 3.0, 4 TOPS INT8, plug it into anything with a USB port
- Coral M.2 Accelerator (A+E key or B+M key) — same chip, same 4 TOPS, sits in an M.2 slot
- Coral Dev Board — SoC with integrated TPU, not really relevant for most home lab use
What it does well: plug-and-play with TFLite models. If your model is already in quantized TFLite format, you compile it once with the Edge TPU compiler, copy it to the board, and it runs. The Frigate integration has been around forever and is battle-tested.
What it does terribly: anything that isn’t quantized TFLite. That’s it. That’s the whole list. You want to run an ONNX model? Nope. PyTorch export? Convert it yourself. Some layers aren’t supported on-chip and fall back to CPU silently — which is how you end up wondering why your “hardware accelerated” pipeline is still melting your Pi.
The elephant in the room: Google has been ghosting Coral. The last meaningful SDK update was mid-2023. The hardware is still sold (Mouser, DigiKey, some Pi shops), but there’s been zero new chipgen announcement, no roadmap, and the GitHub issues are a graveyard of “any update on this?” comments from 2024. In 2026, you’re buying a chip that’s functionally EOL. It still works, but you’re not getting support, new model compatibility, or driver updates beyond what the community patches.
If you’re plugging a Coral USB into a Pi 5 via a Pineboards HatDrive adapter (which gives you PCIe-connected M.2 off the Pi 5’s PCIe lane), that actually works — the M.2 Coral gets real PCIe bandwidth. But you’re still constrained to 4 TOPS and a TFLite-only world.
Hailo-8: The Serious Upgrade
Hailo is an Israeli AI chip company that’s been doing edge inference silicon since around 2018. The Hailo-8 hit the market more broadly around 2022, and by 2026 it’s genuinely well-supported in the home lab and embedded Linux world.
The hardware lineup:
- Hailo-8 — M.2 2230 or 2242 (B+M key), 26 TOPS INT8, PCIe Gen3 x1 interface
- Hailo-8L — same M.2 form factor, 13 TOPS, lower power draw, this is what ships in the Raspberry Pi AI Kit (the official HAT+ for Pi 5)
- Hailo-10 — newer gen, aimed at LLM-scale edge inference, still somewhat preview-ish in 2026 in terms of full SDK coverage
The Raspberry Pi AI Kit with Hailo-8L is the easiest entry point: official support in the Pi 5 kernel (no external driver dance), Hailo’s runtime is pre-packaged for Raspberry Pi OS, and you get 13 TOPS for around $70 for the kit. The full Hailo-8 module for M.2 desktops and x86 edge boxes runs about $80-100 and gives you 26 TOPS.
Model format: Hailo uses its own format called HEF (Hailo Executable Format). Your pipeline is: train model → export to ONNX → run through Hailo’s Model Zoo compiler toolchain → get a .hef file → deploy. It’s an extra step, but ONNX is the common denominator for basically everything now (PyTorch, TensorFlow, ONNX Runtime all export ONNX), so your model options are dramatically wider than Coral’s TFLite-only world.
Hailo maintains an actual model zoo with pre-compiled HEF files for common architectures: YOLOv5, YOLOv8, SSD variants, EfficientDet, and more. For Frigate specifically, you can grab a pre-built HEF and skip the compilation step entirely.
SDK maturity in 2026: Hailo’s HailoRT SDK has proper Python bindings, a REST API mode, GStreamer plugin support, and active maintenance. The kernel module (hailort.ko) is DKMS-packaged which means kernel upgrades don’t break it silently. This is the stuff that makes the difference at 11 PM when you’re debugging why your detection pipeline stopped working after a system update.
Numbers That Actually Matter
Let’s get concrete. Running a real object detection workload:
| Workload | Coral USB (4 TOPS) | Hailo-8 (26 TOPS) |
|---|---|---|
| SSD MobileNet v2 (Frigate default) | ~50ms/frame | — |
| YOLOv8n (HEF) | — | ~7ms/frame |
| EfficientDet-D0 | ~40ms/frame | ~10ms/frame |
| CPU fallback (Pi 5) | ~200ms/frame | ~200ms/frame |
The Coral at ~50ms/frame gets you roughly 20 FPS sustained on one stream, which is fine for most Frigate deployments. But with 4-6 cameras all feeding detections, you’re queuing. The Hailo-8 at ~7ms/frame on YOLOv8n is effectively real-time on a single stream and can comfortably handle multiple concurrent detection pipelines.
For Whisper STT inference (not a natural fit for either chip honestly, but people try it): neither accelerator handles this particularly well out of the box in 2026. Coral can’t run it at all. Hailo-10 has preliminary Whisper support via its LLM-focused architecture, but it’s still early. Realistically, STT on the edge still wants a CPU with AVX or a proper GPU. Don’t let anyone tell you otherwise.
For token classification tasks (sentiment, NER, small BERT-style models): Hailo-8 can handle these with a compiled HEF. Coral can only run them if you can quantize them to TFLite and they fit within the supported ops — which many transformer-ish models don’t.
Wiring It Into Frigate
This is the part everyone actually wants to know. Let’s do both.
Coral USB + Frigate
The Docker Compose setup for Coral USB is dead simple:
services: frigate: image: ghcr.io/blakeblackshear/frigate:stable container_name: frigate privileged: false restart: unless-stopped devices: - /dev/bus/usb:/dev/bus/usb volumes: - /etc/localtime:/etc/localtime:ro - ./config:/config - ./storage:/media/frigate - type: tmpfs target: /tmp/cache tmpfs: size: 1000000000 ports: - "5000:5000" - "8554:8554" - "8555:8555/tcp" - "8555:8555/udp"And the Frigate config for the Coral detector:
detectors: coral: type: edgetpu device: usb
model: path: /edgetpu_model.tflite input_tensor: nhwc input_pixel_format: rgb width: 320 height: 320If you’re using an M.2 Coral instead of USB, change device: usb to device: pci — Frigate figures out the rest.
Hailo-8 + Frigate
For Hailo, you need the /dev/hailo0 device exposed to the container. Frigate’s Hailo integration landed properly in the 0.14+ releases:
services: frigate: image: ghcr.io/blakeblackshear/frigate:stable container_name: frigate privileged: false restart: unless-stopped devices: - /dev/hailo0:/dev/hailo0 volumes: - /etc/localtime:/etc/localtime:ro - ./config:/config - ./storage:/media/frigate - type: tmpfs target: /tmp/cache tmpfs: size: 1000000000 ports: - "5000:5000" - "8554:8554" - "8555:8555/tcp" - "8555:8555/udp"And the Frigate config for Hailo:
detectors: hailo: type: hailo8l device: PCIe
model: path: /config/yolov8n.hef input_tensor: nchw input_pixel_format: rgb width: 640 height: 640 labelmap_path: /labelmap/coco-80.txtDrop your .hef file into the Frigate config directory. Hailo’s model zoo (hailo.ai/developer-zone/model-zoo/) has pre-compiled HEFs for the common COCO-trained detectors. YOLOv8n is the sweet spot: small model, fast inference, good accuracy on the COCO classes Frigate cares about.
One gotcha on the host side: you need the HailoRT driver installed before the container can see /dev/hailo0. On Raspberry Pi OS with the AI Kit, this is handled for you. On Debian/Ubuntu x86, it’s:
# Install HailoRT runtime (get the deb from hailo.ai developer zone)sudo dpkg -i hailort_4.x.x_amd64.debsudo systemctl enable --now hailo_driverls /dev/hailo* # should see /dev/hailo0DKMS will rebuild the module on kernel upgrades automatically. It’s not perfect but it’s miles better than maintaining an out-of-tree patch yourself.
Price and Getting Your Hands on One
Coral USB: ~$60 USD if you can find it in stock. Mouser and DigiKey have stock as of mid-2026 but it fluctuates. The M.2 variants run $25-40 for the module itself.
Hailo-8L (Raspberry Pi AI Kit): ~$70 USD from Raspberry Pi authorized resellers. This is the easiest purchase — it’s a first-party Pi 5 accessory, available wherever Pi gear is sold.
Hailo-8 M.2 module: ~$80-100 USD. Available from Hailo’s website and some distributors. Supply has improved significantly in 2025-2026 compared to the early scarcity.
Hailo-10: Preview pricing as of mid-2026, targeting ~$150-200 for the module. SDK coverage is still expanding. Unless you specifically need the LLM-class capabilities, wait a bit.
The Platform Angle
If you’re running Raspberry Pi 5: the Hailo-8L AI Kit is the obvious choice. It’s first-party, kernel-supported, officially documented, and Frigate has explicit Pi 5 + Hailo integration docs. Coral USB works fine too — just plug it in — but 4 TOPS vs 13 TOPS is a meaningful gap and you’re betting on an EOL ecosystem.
If you’re running x86 (mini PC, NUC-style box, Beelink, etc.): Hailo-8 in M.2 is the call. 26 TOPS, PCIe Gen3, drives Frigate without breaking a sweat, and you can run additional inference workloads alongside it.
If you’re running an older Pi or ARM SBC that isn’t Pi 5: Coral USB is still the pragmatic choice. It’s USB-attached so it works anywhere. Just be realistic about the limitations.
Should You Bother?
Yes, if: you’re running Frigate with more than two cameras and your CPU is above 60% on detection alone. The latency reduction is real — going from 200ms CPU inference to 7ms on Hailo-8 means the difference between catching a package thief and getting a blurry frame of their back.
Hailo-8 / 8L if: you want something that’ll still have software support in two years, you want model flexibility beyond TFLite, or you’re on a Pi 5 and want the clean first-party experience. The ONNX compilation step sounds annoying but you only do it once per model, and the pre-built HEFs in the model zoo mean you probably won’t need to compile anything.
Coral if: you’re on a tight budget, already have one lying around, or you need something that works today with zero additional setup and you’re okay with TFLite. Just go in with eyes open about the EOL trajectory. You’re not going to get new features, and if Google quietly pulls the plugin libraries one day, you’re on your own.
Neither if: your workload is primarily LLM inference. Hailo-10 is inching toward that territory but it’s not ready for home lab primetime yet. For LLM inference on the edge in 2026, you’re still better served by a discrete GPU, an Apple Silicon Mac Mini, or a purpose-built box with an NVIDIA Jetson Orin.
Honestly, the Hailo-8L AI Kit for Pi 5 is one of the cleanest edge AI purchases you can make right now. It’s not glamorous, it doesn’t run ChatGPT, and it won’t impress anyone at a cocktail party. But your Frigate instance will detect cars, people, and cats with sub-10ms latency while drawing less power than a USB phone charger. Your 2 AM self — the one who set up the camera alerts — will appreciate it.
