Real-time vision that runs where the camera is.
Parallax builds perception models, a runtime and an SDK that let cameras, robots and glasses understand a scene in under ten milliseconds. Offline, private, and on hardware that already ships.

Cameras used to record. Now they have to respond.
Most vision products still stream every frame to a server and wait. That is fine for a dashboard. It is useless for a forklift that needs to brake, or a door that needs to open.
Typical cloud round trip over a site link · 180 to 420 ms
Parallax decides on the device, inside the frame.
Detection, depth and tracking run on the chip next to the sensor. The answer arrives before the next frame does, and the video never leaves the building.
Measured on dock-03 · 128 fps · 7.8 ms median
8 ms is where machines start to react.
Slow vision is a safety problem.
A robot moving at 2 m/s travels 36 cm while a cloud model answers. On the device it travels 1.6 cm.
One frame hides many models.
Every frame runs detection, depth, tracking and a policy check. Each step gets a slice of the budget, not a turn in a queue.
Fast enough to disappear.
When perception keeps pace with the camera, the product stops feeling like AI and starts feeling like a reflex.
Real time needs a different pipeline.
A camera produces a continuous stream, not a request. Parallax treats every frame as a deadline and schedules the whole graph around it, so nothing waits for anything else.
So we built every layer for it:
- Models shaped for the sensor, not the benchmark.
- A runtime that runs one frame at a time, every frame.
- Quantization tuned together with each architecture.
The edge is not a smaller data center. It is a different machine.
Cloud
On the device
Speed comes from designing the whole path at once.
On a device there is no batching to hide behind. We co-design the model, the memory layout and the schedule for each chip, from the sensor's first pixel to the decision.
- Zero-copy hand-off from the image processor to the NPU.
- Models sized to fit on-chip memory.
- Schedules compiled per chip, not per framework.
The full perception stack, built from the sensor up.
Sensors
Calibration and capture pipelines for RGB, depth and event cameras.
Depth models
Detection, depth and tracking models designed for memory-bound chips.
Runtime
A scheduler that treats every frame as a deadline.
SDK
Swift, Kotlin, C++ and Python bindings. Ship it in an afternoon.
Machines should see the world as it happens.
Billions of cameras are already installed. The software that lets them understand what they see is the open problem, and it's the one we work on.