A runtime package for UNO Q
Build a runtime package the on-device runner knows how to execute, or ship a sealed binary instead of the model file itself.
- Linux runtime package
- Sealed binary option
- Profile-matched deployments
What this solves
Shipping a model to a Linux edge board usually means hand-writing the glue: preprocessing, tensor layout, output decoding. The package should carry that itself, so the device does not need a bespoke integration.
Who this is for
- Embedded Linux engineers
- Product teams shipping devices
- Systems integrators
Why edge inference fits
Decisions happen locally
Inference runs on the device itself. There is no round trip to a server between a frame and a result.
Keeps working offline
A deployed model runs without a connection. Devices send heartbeats and inference logs when they reconnect.
Data stays where it is captured
Frames are processed on the device. Nothing has to leave the site for a prediction to be made.
The whole pipeline, one stage at a time
Every stage below is a screen in the platform, not a diagram of something you still have to build.
0106
What you get in the platform
Detection post-processing
Confidence threshold, class filter, non-maximum suppression and IoU tracking, tuned in the UI.
Live classification
Send a frame or a device stream through the current model and see the prediction immediately.
Deployment builds
Turn any trained model into a ready-to-run package for the target you pick.
Device fleet
Register devices with an API key, then track heartbeats and inference logs per project.
Over-the-air model updates
Resolve the compatible deployment for a device and push the update without touching the hardware.
Project export
Export the project so your data and models stay portable.
What teams build with it
Detection with no glue code
Preprocessing and output decoding travel inside the package.
Shipping a sealed binary
Use the PXE package when the model file should not travel with it.
Profile-matched deployment
The device resolves which build it is compatible with before it updates.
Streaming live inference
Watch results in the dashboard while the model runs on the board.
Staged rollout
Request an update per device and check its status before the next one.
Every target you can build for
Pick the one that matches the hardware and the model you trained.
Raspberry Pi
Python inference package
Installs with the device client and runs as a service
Camera or sensor inference on a Pi you manage from the dashboard.
UNO Q
Linux runtime package
The on-device runner takes it from there, no glue code to write
Shipping a self-contained model package to a Linux device.
TensorFlow Lite
TensorFlow Lite model with an inference library
Embed it in any runtime that can load TensorFlow Lite
Adding classification or detection to an application you already ship.
C++ Library
Portable C++17 inference library
Compile it into your own firmware or application
Classification models on hardware you build the firmware for.
Arduino Library
Arduino library, ready to import
Import it through the Arduino Library Manager
Classification models on a microcontroller board.
PXE Runtime
Sealed binary package
Pairs with a Linux target such as UNO Q or Raspberry Pi
Shipping a model when the model file itself should not travel with it.
One platform, start to finish
Data, labels, training, evaluation, post-processing, deployment and the fleet live in one place, with nothing to stitch together.
The whole lifecycle
Collect, label, train, evaluate, post-process, deploy and monitor without leaving the platform.
Models sized for edge hardware
NanoVision, Vision Pro and MobileNetV2 are built to run on devices, not on datacentre GPUs.
Six deployment targets
One trained model, packaged for the hardware you already run.
A fleet you can reach
Register devices, read their inference logs, and push new models over the air.
What’s included
- Dataset import from COCO, YOLO, Pascal VOC, Open Images and Edge Impulse JSON
- AI-assisted labeling with human review before anything is applied
- Confusion matrix, per-class metrics and model testing across versions
- Post-processing with NMS and IoU tracking
- Over-the-air model updates to registered devices
- Project export, so your data and models stay portable
Build a package for UNO Q
Create a project, bring your data, and take it through to a deployed model.