Remote hardware clouds

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 clouds (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 clouds, 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 cloud. However, some clouds require additional setup before use.

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

General workflow

This general workflow applies to each of our supported device clouds. Replace <cloud> in the examples below with your chosen cloud. You may omit the cloud subcommand to use the default cloud (embedl).

List available devices: Use the CLI to see all devices available from each cloud:
```
embedl-hub list-devices <cloud>
```
The list-devices command prints the device name, hardware cloud, 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 cloud and runtime (e.g., .tflite for LiteRT, .onnx for ONNXRuntime).

For example, this is how you would compile your model with the default cloud, which uses the LiteRT runtime:
```
embedl-hub compile \
```
```
   --model my_model.onnx
```
This is how you would compile your model for a Samsung Galaxy S25 device and the LiteRT runtime with the qai-hub cloud:
```
embedl-hub compile qai-hub \
```
```
   --model my_model.onnx \
```
```
   --device "Samsung Galaxy S25" \
```
```
   --runtime tflite
```
Run the following command to review the supported command-line options for your chosen device cloud:
```
embedl-hub compile <cloud> --help
```
Benchmark your model on the selected device:

Run the following command to submit your model for benchmarking:
```
embedl-hub benchmark <cloud> \
```
```
   --model my_model.tflite \
```
```
   --device "Samsung Galaxy S25"
```
Run the following command to review the supported command-line options for your chosen device cloud:
```
embedl-hub benchmark <cloud> --help
```
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 clouds.
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 clouds

Currently, Embedl Hub supports remote device access via Qualcomm AI Hub. More clouds are coming soon. You can view all supported devices in Supported devices. Let us know if you’re looking for a specific device or chip by requesting a device:

Embedl Hub (embedl)

The Embedl Hub device cloud is the default device cloud in the embedl-hub library. Using Embedl Hub devices doesn’t require any additional setup.

You may follow the general workflow, and use embedl as the <cloud>, or you may omit the cloud subcommand entirely.

For example, to see all Embedl Hub devices available in embedl-hub, run:

embedl-hub list-devices

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.
Log in to your Qualcomm AI Hub account and click “Settings” in the top right corner.
When you install the embedl-hub library, the qai-hub library is automatically installed. Copy your API token and configure qai-hub in your terminal:
```
qai-hub configure --api_token YOUR_API_TOKEN
```
Your Qualcomm AI Hub API token is not shared with Embedl Hub and stays privately in your local environment.
You are now ready to start running AI on Qualcomm devices with embedl-hub. You may follow the general workflow, and use qai-hub as the <cloud>.

For example, to see all Qualcomm devices available in embedl-hub, run:
```
embedl-hub list-devices qai-hub
```