Remote hardware providers

This guide explains how to access remote edge AI devices through Embedl Hub, enabling you to compile and benchmark your models on real devices such as phones, dev boards, and SoCs directly from your local Python environment or terminal.

You will learn:

How remote device access works in Embedl Hub
The general workflow for compiling and benchmarking models remotely
How to use specific remote device providers (e.g., Qualcomm AI Hub)

How remote device access works

Embedl Hub enables you to evaluate your models on real edge AI devices without needing physical access to the devices. Embedl Hub integrates with remote device providers, allowing you to:

Compile your model for the target device
Deploy and run benchmarks on real devices
Retrieve performance metrics and logs

This workflow is device-agnostic and works for any supported provider. However, some providers require additional setup before use.

You can find provider-specific setup instructions in their respective sections.

General workflow

List available devices: Use the CLI to see all devices available from each provider:
```
embedl-hub list-devices
```
The list-devices command prints the device name, hardware provider, OS version, and chipset. Use the name of the device exactly as it’s written whenever embedl-hub asks for a device name.
Compile your model: Compile your model to a device-ready binary. The target format depends on the selected runtime (e.g., .tflite for LiteRT, .onnx for ONNXRuntime).

For example, this is how you would compile your model for a Samsung Galaxy S25 device and the LiteRT runtime:
```
embedl-hub compile \
```
```
   --model my_model.onnx \
```
```
   --device "Samsung Galaxy S25" \
```
```
   --runtime tflite
```
Most models will only run on the device they were compiled for. For best performance, always compile your model specifically for your target device.
Benchmark your model on the selected device:

Run the following command to submit your model for benchmarking:
```
embedl-hub benchmark \
```
```
   --model my_model.tflite \
```
```
   --device "Samsung Galaxy S25"
```
The benchmarking job reports key metrics such as on-device inference latency, peak memory usage, and the processor or compute unit used for each layer. Additional details may be available for specific hardware providers.
Analyze and compare your results on the web: All your benchmarking jobs and results are available on your personal
projects page on the web. Here you can:
- View a history of all your submitted benchmarks
- See which devices each model was tested on
- Compare performance metrics (such as latency, memory usage, and accuracy) across different devices
- Identify which device delivers the best results for your model
- Download detailed logs and reports for further analysis
Use these insights to optimize your models and make informed decisions about deployment targets.

Supported remote device providers

Currently, Embedl Hub supports remote device access via Qualcomm AI Hub. More providers are coming soon. Let us know if you’re looking for a specific device or chip by requesting a device:

Qualcomm AI Hub (qai_hub)

Qualcomm AI Hub provides access to all Snapdragon-powered phones such as the latest Samsung Galaxy S25 running the Snapdragon 8 Elite chip, as well as some dev boards and automotive grade SoCs in the SA8XXX family. It also gives access to Google Pixel phones, like the latest Google Pixel 9 Pro, powered by the Google Tensor G4 chip.

Follow these steps to let the embedl-hub library interface with devices from Qualcomm:

Create an account on Qualcomm AI Hub.
Install the qai_hub Python library:
```
pip install qai_hub
```
Log in to your Qualcomm AI Hub account and click “Settings” in the top right corner.
Copy your API token and configure qai_hub in your terminal:
```
qai-hub configure --api_token YOUR_API_TOKEN
```
See all Qualcomm devices available in embedl_hub in Supported devices or by running the following command:
```
embedl_hub list-devices
```
You are now ready to start running AI on Qualcomm devices with embedl_hub.

Your Qualcomm AI Hub API token is not shared with Embedl Hub and stays privately in your local environment.