Edge AI · On-device inference

Edge AI and TinyML development that runs on the microcontroller, not the cloud

Models quantized to fit flash and RAM you actually have, running inference on the device inside a battery power budget. One lead engineer owns the result; an AI team speeds up the work. 20+ years across firmware, boards, and machine vision.

What Edge AI development means here

Edge AI runs a trained model directly on an embedded device — a microcontroller, SoC, or camera module — so inference happens locally, with no round trip to a server. TinyML is the sub-case that fits models onto ultra-low-power microcontrollers, often under a milliwatt. The result: real-time response, no dependence on a network link, and data that never leaves the device.

The hard part is not training the model — it is making it run on hardware with kilobytes of RAM and a battery that has to last months. That is an embedded engineering problem before it is a data-science one, and it is where most cloud-first ML teams stall.

Who needs on-device inference

Battery products that cannot afford a constant cloud connection — sensors, wearables, field instruments running for months on a coin cell or 18650.
Machine vision on the line, where a camera replaces manual inspection and the verdict has to be instant and local.
Privacy-bound applications where raw data — audio, images, health signals — must never leave the device.
Existing products that already have a microcontroller and need a detection or classification feature added without a hardware redesign.
Teams with a working model in Python that will not fit on their target part and need it quantized, pruned, and deployed.

How the work runs

Feasibility on the real target

Before any model work, the candidate part is benchmarked for flash, RAM, and inference time. If the network will not fit or will be too slow, that is known in week one — not after months of training.

Data and model

Data collection and labelling, model built and trained in TensorFlow / Edge Impulse, then evaluated against the constraints of the target device rather than a workstation GPU.

Compression to fit

Quantization (INT8, and INT4 where the part supports it), pruning, and knowledge distillation to shrink the model until it runs inside the available flash, RAM, and power budget.

On-device deployment

The model is compiled with the hardware toolchain — TFLite Micro, CMSIS-NN, ESP-DL, or the vendor NPU stack — and integrated into the firmware with deterministic timing and clean fault handling.

Field validation

Measured on real hardware under real operating conditions: inference latency, power draw, and accuracy in the environment the device actually ships into.

Hardware and toolchains

Inference is deployed on the part that fits the power and cost budget, not on whatever is fashionable:

STM32 (incl. STM32N6 NPU) ESP32-S3 Nordic nRF52 / nRF53 ARM Cortex-M TFLite Micro CMSIS-NN Edge Impulse ESP-DL OpenCV INT8 / INT4 quantization pruning knowledge distillation

Why MPV-LAB for this

Embedded-first, not cloud-first. The bottleneck in Edge AI is the microcontroller, not the model. This is a firmware and board practice that also does ML — the right order for on-device work.
Machine vision already in production. Camera-based recognition has replaced manual inspection on a working plant floor, not only on a bench.
One accountable engineer. A lead engineer owns the result end to end, with an AI team speeding up the routine work — predictable cost, faster than an in-house department.
Power budget is designed in. Sleep current, wake rate, and inference duty cycle are engineered from the start, so the battery target is met, not discovered late.
You keep everything. Model, firmware source, and toolchain configuration are handed over — no locked binaries, no lock-in.

Common questions

Can my existing Python model run on a microcontroller?

Often yes, after compression. The model is quantized and pruned, then benchmarked on the actual target for flash, RAM, and inference time. If it genuinely will not fit, you get a straight answer early and a recommendation for a more capable part or a lighter architecture.

What accuracy loss comes with quantization?

INT8 quantization typically costs a small, measurable drop that is recovered with quantization-aware training. The trade-off is quantified on your data before deployment, so accuracy against power and speed is a decision you make with numbers, not a surprise.

How small a device can run inference?

TinyML targets microcontrollers under roughly a milliwatt — Cortex-M class parts with hundreds of kilobytes of RAM. Whether your model fits depends on its architecture; feasibility is checked on the real part first.

Do you handle the whole device, or only the model?

Both are available. The model can be delivered for your existing firmware, or the full device — board, firmware, enclosure, and the on-device model — can be developed end to end under one contract.

Who owns the model and the code?

You do, once the milestone is paid. You receive the trained model, the firmware source, and the toolchain configuration. Any other engineer can pick the package up and continue.