Henomaly

Logo
Dashboard
Dashboard
Chat interface for farmer
QNX Pi
Wall mounted monitor
Wall mounted monitor
Wall mounted monitor

Inspiration

Egg prices over the last few years made it obvious to everyone: diseases like avian influenza move through commercial flocks incredibly fast, killing birds in the hundreds of thousands. By the time a farmer notices something is wrong, the disease may already have swept through an entire house. That disrupts farms, cuts the egg supply, and drives up prices for everyone.

So we asked: how can we give farmers an early warning system that:

watches the flock constantly, for long periods,
keeps working when the internet drops or part of the system crashes, and
turns what it sees into something a farmer and a veterinarian can actually act on?

What it does

Henomaly is a camera-based edge AI system running on QNX that monitors the relative health of different groups of chickens. Instead of streaming video to the cloud, it processes everything locally, because barn internet is anything but reliable.

It watches behavior (inactivity, panting, eating, drinking, movement) and looks for visible changes in droppings.
It compares each pen against its own normal baseline, not a fixed rule, because behavior depends heavily on bird age and time of day.
When something is unusual, it creates an alert with the pen, the time, an evidence image, and an explanation of what changed.
The alert reaches the farmer through Photon and iMessage. The farmer can ask questions, request the image, and decide whether to share it with a veterinarian.

Nothing is automatically diagnosed, and nothing is escalated without the farmer's permission.

Conceptually, the baseline check for a signal x (for example, the share of inactive birds in a pen) is a standardized deviation from that pen's normal for the same hour of the day:

$$z = \frac{x - \mu}{\sigma}$$

An alert fires only when z stays above a threshold for several consecutive windows, so a single odd frame never pages anyone.

How we built it

The edge: QNX 8 on a Raspberry Pi 5

The core system runs on a Raspberry Pi 5 with QNX 8.0 and a Camera Module 3.

Nine separate processes, each with one job and its own priority, talking over native QNX message passing. Large camera frames move through shared memory instead of being copied between processes.
The camera is driven through QNX's Sensor Framework in C. Full-resolution frames land in a shared-memory ring that other processes read without copying, protected by a sequence counter. Only small summaries travel as messages.
Real-time priorities: the camera and the farmer's alert link run at the highest priority, and heavy model inference runs at the lowest. Inference can never starve an alert.
On-device AI from QNX's open-source ecosystem: ONNX Runtime 1.24.4 from oss.qnx.com, installed completely offline (106 packages, no internet on the Pi). QNX's Python package for it turned out to be broken, because its compiled module was missing, so we wrote a small C bridge straight to ONNX Runtime's C API and drafted a fix for QNX's package recipe.
Fault tolerance: a supervisor restarts any process that dies. We can deliberately crash one part, watch the rest keep running, and see the failed part come back and rejoin. After a power cut, the whole pipeline starts itself on boot.

Measured on the Pi 5 itself, our detector runs in 168 ms at 320 px, versus 618 ms at 640 px. Compute scales roughly with input area:

$$\left(\frac{320}{640}\right)^2 = 0.25$$

so we expected about a 4x speed-up, and measured 3.7x.

The intelligence: open-source YOLO11, trained on Veri

We started from open-source YOLO11 models and public poultry datasets, and trained every model on Veri's GPUs. Veri is built mainly for language models, so we used its custom-script mode to run full computer-vision training.

Hardware: AWS nodes with 4x NVIDIA A10G (24 GB each), 48 vCPUs and about 180 GB RAM. At peak we ran two nodes at once: 8x A10G.

Behavior and chicken models (Big Broiler dataset, Cardoen et al., 2025):

We turned 33 GB of research video (102 clips, about 900k frames, about 6.7M behavior labels) into about 130,000 labeled bird crops across 7 behavior classes, plus 18.4k detector frames with 92.6k bounding boxes, shipped to Veri as one 9.4 GB volume.
We split by video, not by frame. The 10 test clips were never seen in training, so the scores are honest.
We trained three models in parallel on one node: a chicken detector on 2 GPUs with distributed data-parallel training (NCCL), and two behavior classifiers on one GPU each.

Held-out test results:

Chicken detector (YOLO11n): mAP50 0.927, recall 0.93
Behavior classifier (YOLO11n-cls, Pi-sized): top-1 accuracy 0.686; panting recall 0.80, inactivity 0.82
Behavior classifier (YOLO11s-cls): top-1 accuracy 0.701; panting 0.83, drinking 0.87
Droppings model (YOLO11n, Machuve fecal dataset, CC BY 4.0): mAP50 0.854 on 679 held-out photos

(mAP50 is the mean average precision over classes, counting a detection as correct when it overlaps the true box by at least 50%.)

Challenges we ran into

Making a language-model platform train vision models. Veri's sandboxed containers originally had only 64 MB of shared memory, which crashed PyTorch's data-loading workers and multi-GPU training.

We patched the DataLoader to pass batches through pipes as NumPy arrays, keeping 12 data workers per GPU alive.
We reported the cap with logs, and the Veri team raised it to 16 GB, which unlocked multi-GPU training.
We also reported custom scripts failing on one GPU provider and a crash about 20 minutes into jobs, and Veri shipped fixes during the event.

Expensive failures. A job marked "failed" made even its finished models undownloadable, so we made our training jobs:

time-boxed, sizing training to the remaining budget,
always exit cleanly, so trained models survive,
check multi-GPU communication in 10 seconds before paying for a 30-minute download, and
resubmit automatically through GPU capacity and quota errors.

Data at scale on bad Wi-Fi. Downloading 33 GB of video inside cloud jobs stalled, so we moved video processing to a laptop and uploaded only the compact prepared dataset.

QNX packaging. The ONNX Runtime package had to be installed offline, and its broken Python binding forced us to call the C API directly.

Accomplishments that we're proud of

A full edge AI pipeline on QNX: camera, detection, alerts and a self-healing supervisor, running on a Raspberry Pi 5 with no cloud dependency.
Models trained end-to-end on Veri, including multi-GPU training, on a platform designed for language models.
Honest numbers: every score is on held-out data, split by video, not by frame.
A working farmer loop: alerts with evidence over iMessage, with the farmer in control of what reaches the vet.
Real contributions back: a drafted fix for QNX's ONNX Runtime package, and platform bugs reported to Veri that were fixed during the event.

What we learned

The most important lesson was where our models do not work.

Our droppings model performed well on close-up photos but failed on distant, crowded barn footage. On real held-out pen frames, 0 of its 34 detections were actually droppings: they landed on feathers, dye marks, wall screws and drinker parts. A synthetic benchmark had suggested it worked; only a check on real held-out footage showed it didn't. Even at full 2688-px resolution, individual droppings weren't visible.

So instead of hiding it, we changed the design:

Wide cameras handle flock-level behavior, where our models are validated on exactly that kind of footage.
Droppings analysis needs a closer, controlled camera position. In the demo we simulate that path: after the dropping-finding step, the close-up analysis model receives droppings we'd expect from that camera position, at the simulated anomaly level.

We also learned that honest evaluation is a design tool: splitting by video, scoring on held-out data, and auditing real frames changed our architecture more than any extra training would have.

What's next for Henomaly

Real, veterinarian-confirmed barn data, with better-placed cameras for droppings.
Temporal behavior models for short signs like sneezing and head shaking, which single frames can't capture.
Field testing on a working farm, with baselines learned per flock, age and time of day.

Henomaly can't diagnose bird flu or tell a farmer how to treat an animal. What it can do is keep watching, notice changes earlier, preserve the evidence, and bring the farmer and the veterinarian in before egg prices start climbing again.

GitHub: https://github.com/RishitRai/Henomaly