> For the complete documentation index, see [llms.txt](https://nx.docs.scailable.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://nx.docs.scailable.net/ai-manager-v6.1.4/ai-accelerators-support/intel-support.md).

# Intel Support

Run models on Intel CPUs, GPUs and NPUs with the OpenVINO runtime of the AI Manager: requirements, drivers, setup, tuning and troubleshooting.

| AI Accelerator | Support Level | CPU Architecture | Operating System       | API/driver version |
| -------------- | ------------- | ---------------- | ---------------------- | ------------------ |
| Intel CPU      | Full support  | x86\_64          | Ubuntu 22+ and Windows | OpenVINO           |
| Intel GPU      | Full support  | x86\_64          | Ubuntu 22+ and Windows | OpenVINO           |
| Intel NPU      | Experimental  | x86\_64          | Ubuntu 22+ only        | OpenVINO           |

The AI Manager has one Intel runtime, built on Intel OpenVINO 2026.1, that runs models on the Intel CPU, an integrated or discrete Intel GPU, or the NPU of Intel Core Ultra processors.

* **Default device:** the CPU. You pick the GPU or NPU with a small settings file, see [Choose the Device](#choose-the-device).
* **Model format:** OpenVINO, with FP32 precision. You don't have to convert anything: the AI Manager Cloud converts every ONNX model you upload automatically, see [Convert a Model](#convert-a-model).

**First step:** check the [requirements](#hardware-requirements), install the drivers for the GPU or NPU, then [select the runtime](#select-the-intel-runtime).

## Hardware Requirements

| Device | Supported hardware                                                                 | Tested by us                                 |
| ------ | ---------------------------------------------------------------------------------- | -------------------------------------------- |
| CPU    | Intel Core 6th to 14th generation and Core Ultra, Xeon, Atom. **AVX2 is required** | Core i7-12700K                               |
| GPU    | Intel Arc, Iris Xe, UHD / HD Graphics, Data Center GPU Flex and Max                | UHD Graphics 770 (integrated)                |
| NPU    | Intel Core Ultra NPU                                                               | Verified on Ubuntu; not supported on Windows |

The complete list of compatible hardware is in the [Intel system requirements](https://docs.openvino.ai/2026/about-openvino/release-notes-openvino/system-requirements.html) tables.

Without AVX2 on x86\_64, no AI Manager runtime can start, and the plugin shows a warning in the Integrations tab.

## Software Requirements

The CPU needs no driver. Only the GPU and the NPU do.

### Ubuntu

The Intel runtime needs Ubuntu 22.04 or higher (or Debian 12 or higher, with glibc 2.34).

1. Install the OpenCL loader. **This is required for all Intel devices, including the CPU**: without it the plugin does not offer the Intel runtime at all.

   ```bash
   sudo apt install ocl-icd-libopencl1
   ```
2. For the **GPU**, install the OpenCL driver:

   ```bash
   sudo apt install intel-opencl-icd
   ```

   This is the setup we verified (Ubuntu 22.04, integrated GPU). For newer GPUs, install the current release of the [Intel compute runtime](https://github.com/intel/compute-runtime/releases). For a discrete Arc GPU, Linux kernel 6.2 or higher is recommended.
3. For the **NPU**, install the driver from the [Intel NPU driver](https://github.com/intel/linux-npu-driver/releases) releases. It needs Linux kernel 6.6 or higher.
4. Add the user that runs the Mediaserver (`<server-user>`) to the `video` and `render` groups, and restart the Mediaserver:

   ```bash
   sudo usermod -aG video <server-user>
   sudo usermod -aG render <server-user>
   ```

If Ubuntu or Debian overwrites the driver packages, prevent APT from upgrading them by placing them on hold, for instance on Ubuntu 22.04:

```bash
sudo apt-mark hold intel-opencl-icd libigdgmm12
```

Newer Ubuntu releases split the GPU driver into more packages (`intel-ocloc`, `libze-intel-gpu1`); hold the ones `dpkg -l | grep -i intel` lists.

### Windows

To use the Intel GPU, install the current Intel Graphics Driver as shown on this [page](https://www.intel.com/content/www/us/en/support/articles/000005629/graphics/processor-graphics.html). The CPU needs nothing. The NPU is not supported on Windows.

## Select the Intel Runtime

After installing the drivers and restarting the Mediaserver, the Intel runtime appears in the AI Manager plugin's runtime selection panel. Open any camera's settings, go to the **Integrations** tab, click **AI Manager**, and select the Intel runtime.

<figure><img src="https://2982163321-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FKGfC0TFSmuMDjbpLErO3%2Fuploads%2Fgit-blob-b5416e5eadff34cd8b21005bd0574929ee6c0b8f%2Fclient-ai-manager-runtime-selection-multiple-devices.png?alt=media" alt="AI Manager Integrations tab showing three runtime entries: Generic CPU, Hailo and Intel, after multiple AI-capable devices were detected"><figcaption><p>The Intel runtime appears in the list once the requirements are met and the server has been restarted</p></figcaption></figure>

## Convert a Model

When you [upload a model](https://nx.docs.scailable.net/ai-manager-v6.1.4/ai-manager-cloud-ui/upload-your-model.md), the AI Manager Cloud converts the ONNX file to the OpenVINO format (IR) on its own, and stores it as an artifact of type `application/zip; device=intel; precision=fp32`. There is no hardware option to enable for Intel. The conversion keeps the operators and the outputs of your model, so the same post-processing applies as on the CPU.

## Configure the Runtime

By default the runtime uses the CPU. To change that, or to tune the runtime, create the file `runtime_args.json` in the runtime folder:

{% tabs %}
{% tab title="Linux" %}

```
<server-install-dir>/mediaserver/var/nx_ai_manager/inference_engine/runtime_args.json
```

{% endtab %}

{% tab title="Windows" %}

```
C:\Windows\System32\config\systemprofile\AppData\Local\<company-name>\<server-app-name>\nx_ai_manager\inference_engine\runtime_args.json
```

{% endtab %}
{% endtabs %}

### Choose the Device

For example, to run on the GPU or on the NPU:

{% tabs %}
{% tab title="GPU" %}

```json
{
  "device_type": "GPU"
}
```

{% endtab %}

{% tab title="NPU" %}

```json
{
  "device_type": "NPU"
}
```

{% endtab %}
{% endtabs %}

{% hint style="warning" %}
On Linux, reselecting a runtime in the AI Manager plugin, or clearing its cache, deletes `runtime_args.json`. Select the Intel runtime first, then create the file, and only then restart the Mediaserver. A file written before the runtime was selected is removed again.
{% endhint %}

After making the changes, restart the Mediaserver, see [Restarting the Server](https://nx.docs.scailable.net/ai-manager-v6.1.4/support-and-troubleshooting/troubleshooting/controlling-the-server-and-the-plugin.md#restarting-the-server).

### Device Values

| `device_type`         | Effect                                                                   |
| --------------------- | ------------------------------------------------------------------------ |
| `CPU` (default)       | Run on the Intel CPU                                                     |
| `GPU`                 | Run on the GPU. With several GPUs, the runtime uses all of them together |
| `GPU.0`, `GPU.1`, ... | Run on one specific GPU                                                  |
| `NPU`                 | Run on the NPU (Linux only)                                              |
| `AUTO`                | Start on the CPU and move to an accelerator as soon as it is ready       |

{% hint style="warning" %}
`GPU` means **any OpenCL GPU**. On a machine without the Intel driver but with another vendor's OpenCL GPU, the runtime uses that GPU. Use `GPU.0` or `GPU.1` to pick the right one.
{% endhint %}

### Other Settings

All settings go in the same file. **Every value must be a JSON string**, for example `"num_requests": "2"`; other types are skipped with a warning in the log. Unknown keys are ignored, and an invalid value falls back to its default.

| Key               | Values (default in bold)                             | Meaning                                                                                                                                                                                                  |
| ----------------- | ---------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `perf_hint`       | **`latency`**, `throughput`, `cumulative_throughput` | OpenVINO performance mode. Use `cumulative_throughput` when `device_type` uses several GPUs. Any other value means `latency`                                                                             |
| `num_requests`    | integer, **`0`** = automatic                         | Number of inferences a model can run in parallel. Automatic lets OpenVINO decide (we saw 1 with `latency` and 4 to 5 with `throughput`)                                                                  |
| `num_streams`     | integer, **`0`** = automatic                         | OpenVINO streams. Only used with `throughput`; 4 is recommended for a discrete GPU                                                                                                                       |
| `auto_batch_size` | integer, **`0`** = off                               | Groups concurrent requests into batches on the GPU or NPU. Ignored on the CPU                                                                                                                            |
| `npu_turbo`       | `1`, **`0`**                                         | Enables the NPU turbo mode (Linux only)                                                                                                                                                                  |
| `cache_dir`       | path, **`.`**, `""` = off                            | Folder of the compiled-model cache (`<hash>.blob` files). The cache avoids recompiling the models at every start. By default it is created in the Mediaserver's working directory, next to `runtime.log` |
| `max_queue_size`  | integer, **`100`**, `0` = unlimited                  | Frames waiting for inference per model, and finished results waiting to be collected                                                                                                                     |
| `log_level`       | `0` (trace) to `6` (off), **`2`**                    | Minimum level written to `runtime.log`                                                                                                                                                                   |
| `log_file`        | path, **`runtime.log`**                              | Log file. It is rotated at 5 MB, and the last three are kept as `runtime.1.log` to `runtime.3.log`                                                                                                       |

## Monitor

Check that the model really runs on the device you chose. The runtime does not show an error when it cannot use a GPU or an NPU: it falls back to the CPU (see [Troubleshooting](#troubleshooting)). Monitor the device while a camera is running inference.

Monitor the usage of the Intel CPU, GPU and NPU on Ubuntu using the appropriate command:

| Hardware | Command              | How to install                                                   |
| -------- | -------------------- | ---------------------------------------------------------------- |
| CPU      | `top`                | Comes preinstalled in the OS                                     |
| GPU      | `sudo intel_gpu_top` | `sudo apt install intel-gpu-tools`                               |
| NPU      | `intel-npu-top`      | [intel-npu-top on PyPI](https://pypi.org/project/intel-npu-top/) |

The runtime log is written here:

```
<server-install-dir>/mediaserver/bin/runtime.log
```

## Troubleshooting

| Symptom                                                                         | Cause and fix                                                                                                                                                                                                                                                                                                       |
| ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| The Intel runtime is not offered in the Integrations tab                        | On Linux, `libOpenCL.so` is missing: install `ocl-icd-libopencl1`. With a message about AVX2, no runtime is offered at all: the x86\_64 CPU has no AVX2                                                                                                                                                             |
| `device_type` is `GPU` or `NPU`, but the device stays idle                      | The runtime used the CPU. The log says `Compile on GPU failed ... falling back to CPU`, or `Unrecognized device ID` when the device is missing. Check the driver, that the user is in the `render` group, and that `/dev/dri` is accessible                                                                         |
| The wrong GPU is used                                                           | `GPU` selects any OpenCL GPU, including other vendors' (see the warning under [Device Values](#device-values)). Use `GPU.0` or `GPU.1`                                                                                                                                                                              |
| A model works on the CPU and the GPU, but not on the NPU                        | Not all models can be compiled for every device. When that fails, the model silently falls back to the CPU. The only trace is the warning in `runtime.log`. Contact the [support team](https://nx.docs.scailable.net/ai-manager-v6.1.4/support-and-troubleshooting/how-to-get-support.md) to check for a workaround |
| The GPU shows a compile error such as `No layout format available for gathernd` | The GPU plugin lacks an operator or data type of the model. The runtime falls back to the CPU                                                                                                                                                                                                                       |
| `.blob` files appear next to the log                                            | This is the compiled-model cache (`cache_dir`). Set a folder, or `""` to turn it off                                                                                                                                                                                                                                |
| `10 warnings generated.` in the console                                         | OpenCL compiler messages while compiling for the GPU. Harmless                                                                                                                                                                                                                                                      |
| `Input queue at capacity` (or `Output queue at capacity`) in the log            | Frames arrive faster than the device processes them. Reduce the number of cameras on this runtime, use a faster device, or raise `max_queue_size`                                                                                                                                                                   |
| Detections on the GPU contain extra rows of zeros                               | The GPU pads outputs with a variable size to their maximum. Rows with a score of 0 can be ignored                                                                                                                                                                                                                   |
