Fanless Jetson-class edge compute: doing the inference at the camera.

Why put the compute at the camera instead of on a PC or in the cloud?

Putting the inference on a board inside the camera removes the two slowest and most fragile links in a vision system: the trip to a separate industrial PC and the trip to the cloud. When the model runs where the image is captured, the decision is made in the same place as the measurement, so there is no frame transfer, no network hop and no remote dependency between seeing the part and emitting a pass or fail.

The timing case is the clearest one. A measured field result of about 30 ms per part leaves almost no budget for shipping a full-resolution frame to another machine and waiting for an answer. On-device inference removes that transfer entirely, which is why the compute location, not just the model, is what makes line-speed decisions realistic. Adente Vision is an edge-AI visual inspection unit built by ADENTE Advanced Engineering Technologies, part of the Aden Group, sold through automation system integrators, and it does the inference on a fanless Jetson-class board in the enclosure rather than on an external server.

The second reason is independence. A unit that decides on its own board keeps working when the plant network is congested or down, and it never sends raw part images off the line. For a plant where the imagery is sensitive process data, that on-device design is what separates a self-contained station from one that depends on infrastructure it does not control.

What does Jetson-class 8-16 GB edge compute actually give you?

Jetson-class edge compute is a compact GPU-accelerated module designed to run neural-network inference at low power, and the 8-16 GB of memory is what lets a real inspection model load and run at the camera rather than on a rack server. The GPU acceleration is the part that matters: image models are parallel work, and a small accelerator does that work in milliseconds where a general-purpose CPU would stall.

The memory headroom is what keeps the model honest. Anomaly and defect models for surface inspection are not tiny, and 8-16 GB gives room for the network plus the image buffers and the classical computer-vision stage that runs alongside it. Adente Vision combines classical computer vision for measurement with AI inference for judgement on the same board, so the compute has to hold both, and the memory budget is sized for that hybrid workload rather than for a single lightweight classifier.

Because the model runs on a dedicated embedded accelerator, its timing is predictable. The catalog latency bound is a conservative 0.5 s per part, and the measured field result is about 30 ms per part; the number you can commit to for a specific cycle sits inside that envelope and needs an application-specific measurement on your parts and lighting.

Why does fanless matter in a factory?

Fanless means the board is cooled by conduction through the enclosure rather than by a fan pulling factory air across it, and that removes the single most common failure point for electronics on a shop floor. A fan is a moving part that wears out, and it is an open path for dust, oil mist and coolant aerosol to reach the board.

Factory air is not clean-room air. Machining coolant, plastic dust, weld fume and packaging fibre circulate around a production cell, and any fan-cooled box ingests them until the heatsink clogs and the temperature climbs. A sealed, fanless design sidesteps that: with no fan and no vents, the same enclosure that keeps contaminants out carries the heat out through its body, which lets the unit hold a 0-45 C range in the standard configuration without an air path into the electronics.

The trade-off a fanless design accepts is a tighter thermal budget, which is precisely why the compute is a low-power embedded module rather than a desktop-class GPU. The engineering choice is deliberate: pick a Jetson-class part whose power envelope can be cooled passively, and you get an inspection computer that survives the environment it is installed in. For the full physical, power and thermal envelope of the unit, see the sibling post on fitting an inspection unit to a real cell.

How much data and time does on-device training need?

On-device inspection does not require a large dataset: the model trains from about 20 good reference images, with training completing in under 48 hours. Because the approach learns what a good part looks like and flags deviation, you supply good parts rather than a catalogue of every possible defect, which is what keeps the data requirement small.

That small-data path makes edge inference practical to deploy and to change. A new part or variant becomes a capture-and-train task measured in a couple of days, not a multi-month data-collection project, and the trained model runs on the same fanless board with no hardware change. The unit runs four modes, Anomaly, Defect, Counting and Quality, and updates load by USB stick so an air-gapped line can be retrained without a network connection.

Edge-compute spec at the camera

The table below summarises what "doing the inference at the camera" means in specification terms. Treat the two latency figures as an envelope, the conservative catalog bound and the measured field result, not as a single guaranteed cycle time for every part.

Does on-device inference keep the data on the line?

On-device inference keeps raw part images on the line because the frame is captured, judged and discarded on the same board, and only the result, a pass or fail, a class, a measurement, leaves the unit over the fieldbus. Nothing about the design requires an image to travel to a server or the cloud to reach a decision.

For a plant where part imagery is sensitive, this is a data-residency property, not just a performance one. The image never becomes a file on a remote system, and model updates arrive by USB, so even an air-gapped cell can be maintained. For the wider comparison of edge against cloud inspection on latency and data sovereignty, see the sibling post on edge vs cloud visual inspection. The full unit is described on the Adente Vision system page, and the method sits under the pillar guide on AI visual inspection.