> ## Documentation Index
> Fetch the complete documentation index at: https://docs.siderolabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Hailo AI Accelerators

> Enable Hailo edge AI accelerator cards on your Talos nodes and verify they are available to your workloads.

export const VersionWarningBanner = () => {
  const latestVersion = "v1.13";
  const [latestUrl, setLatestUrl] = useState(null);
  const [currentVersion, setCurrentVersion] = useState(null);
  const [isBeta, setIsBeta] = useState(false);
  const parseVersion = v => v.replace("v", "").split(".").map(Number);
  const isGreaterVersion = (a, b) => {
    const [aMajor, aMinor] = parseVersion(a);
    const [bMajor, bMinor] = parseVersion(b);
    if (aMajor > bMajor) return true;
    if (aMajor === bMajor && aMinor > bMinor) return true;
    return false;
  };
  useEffect(() => {
    if (typeof window === "undefined") return;
    const {pathname, hash, search} = window.location;
    const match = pathname.match(/\/talos\/(v\d+\.\d+)\//);
    if (!match) return;
    const detectedVersion = match[1];
    if (detectedVersion === latestVersion) return;
    setCurrentVersion(detectedVersion);
    if (isGreaterVersion(detectedVersion, latestVersion)) {
      setIsBeta(true);
    }
    const newPath = pathname.replace(`/talos/${detectedVersion}/`, `/talos/${latestVersion}/`);
    setLatestUrl(`${newPath}${search}${hash}`);
  }, []);
  if (!latestUrl || !currentVersion) return null;
  return <div className="not-prose sticky top-6 z-50 my-6">
      <div className="border border-yellow-500/30 bg-yellow-500/10 px-4 py-3 rounded-xl">
        <div className="text-sm">
          {isBeta ? <>
              ⚠️ You are viewing a <strong>beta version</strong> of Talos ({currentVersion}).
              This version may be unstable.
              <a href={latestUrl} className="ml-2 underline text-yellow-400 hover:text-yellow-300 font-medium">
                View latest stable version {latestVersion} →
              </a>
            </> : <>
              ⚠️ You are viewing an older version of Talos ({currentVersion}).
              <a href={latestUrl} className="ml-2 underline text-yellow-400 hover:text-yellow-300 font-medium">
                View the latest version {latestVersion} →
              </a>
            </>}
        </div>
      </div>
    </div>;
};

<VersionWarningBanner />

This guide shows how to enable Hailo AI accelerator support on your Talos nodes, confirm the card is detected by the operating system, and verify that the device is reachable from a workload running in your cluster.

<Note>Hailo cards are edge accelerators designed for video processing and computer-vision inference, not large AI/LLM workloads. They have limited on-board memory, so they are best suited to lightweight, real-time inference at the edge.</Note>

## Before you begin

You'll need:

* A Talos Linux cluster running v1.11 or later.
* At least one node with a Hailo accelerator.
* `talosctl` and `kubectl` configured and authenticated against your cluster.
* The `siderolabs/hailort` Talos system extension:

The simplest way to include the extension is at image creation time: select it on the **System Extensions** page when generating your installation media in Omni or the [Talos Image Factory](https://factory.talos.dev/). If your node is already running without it, follow [Enable Hailo support](#enable-hailo-support) below. Otherwise, skip to [Verify the card is detected](#verify-the-card-is-detected).

## Enable Hailo support

System extensions are baked into the Talos boot image rather than installed at runtime. If your node booted from an image that does not include `siderolabs/hailort`, add the extension by switching the node to an image that does. The node performs a standard upgrade cycle to boot into the new image.

<Tabs>
  <Tab title="Standalone Talos">
    Generate a new schematic that includes the `siderolabs/hailort` extension using the [Talos Image Factory](https://factory.talos.dev/), then upgrade the node to the matching installer image:

    ```bash theme={null}
    talosctl upgrade \
      --image factory.talos.dev/metal-installer/<schematic-id>:<talos-version>
    ```

    For the full schematic workflow, see [Boot Assets](../../platform-specific-installations/boot-assets)
  </Tab>

  <Tab title="Omni">
    Add the extension to a machine in an Omni cluster:

    1. Select the cluster containing the target machine.
    2. Select the machine, then open the **Extensions** tab.
    3. Click **Update Extensions**, add `siderolabs/hailort`, and click **Update**.

    Omni generates the new image and upgrades the machine to it. For more details, see [Install Talos Linux Extensions](../../../../omni/infrastructure-and-extensions/install-talos-linux-extensions)
  </Tab>
</Tabs>

Once the node boots the image containing the extension, the kernel loads the HailoRT driver and exposes the card to the operating system as a device node at `/dev/hailo0`.

## Verify Hailo support

After the node boots with the extension, confirm the driver is loaded and the device is available to your workloads.

### Step 1: Confirm the extension is installed

Check that the `hailort` extension is loaded on the node. Replace the `<node-ip>` placeholder with the IP address of your node:

```bash theme={null}
talosctl get extensions --nodes <node-ip>
```

You should see the `hailort` extension listed, along with its version:

```text theme={null}
NODE        NAMESPACE   TYPE              ID            VERSION   NAME          VERSION
<node-ip>   runtime     ExtensionStatus   0             1         hailort       4.23.0
```

Make a note of the HailoRT version reported here. If you later run the HailoRT CLI from a container, the library version inside the container must match this version.

### Step 2: Create a namespace for the verification pod

The verification pod needs access to the host's `/dev` directory, which requires privileged execution. Talos enforces [Pod Security Admission](../../../../kubernetes-guides/security/pod-security) at the `baseline` level by default, so rather than relaxing security on an existing namespace, create a dedicated namespace for the verification and allow privileged workloads:

```bash theme={null}
kubectl create namespace hailo-check
kubectl label namespace hailo-check pod-security.kubernetes.io/enforce=privileged
```

You can delete this namespace when the verification is complete.

### Step 3: Run a verification pod

Create the verification pod. The pod mounts the host's `/dev` directory and checks that the Hailo device node is present:

```yaml theme={null}
kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: hailo-check
  namespace: hailo-check
spec:
  restartPolicy: Never
  containers:
    - name: check
      image: busybox
      command:
        - sh
        - -c
        - "ls -l /dev/hailo0 && echo 'Hailo device is visible in the pod'"
      securityContext:
        privileged: true
      volumeMounts:
        - name: dev
          mountPath: /dev
  volumes:
    - name: dev
      hostPath:
        path: /dev
EOF
```

### Step 4: Confirm the result

Read the pod logs:

```bash theme={null}
kubectl logs -n hailo-check hailo-check
```

If the device is available to the workload, the logs show the device node followed by the confirmation message:

```text theme={null}
crw-rw-rw-    1 root     root      509,   0 Jan  1  1970 /dev/hailo0
Hailo device is visible in the pod
```

### Step 5: Clean up

Remove the verification pod and its namespace:

```bash theme={null}
kubectl delete namespace hailo-check
```

## Going further: verify with the HailoRT CLI

The verification above confirms the device node is present and reachable from a workload. To confirm the card itself responds — for example, to read its firmware details — you can run the HailoRT CLI (`hailortcli scan`) from a container. See the [HailoRT documentation](https://hailo.ai/developer-zone/documentation/hailort-v4-24-0/) for the available commands.

## Troubleshooting

Issues can show up at two layers: the device may not be detected by the operating system, or it may be detected but not visible inside a pod. The following sections outline how to diagnose each.

### Device not detected

If the Hailo device does not appear:

1. Confirm the system extension is installed:

   ```bash theme={null}
   talosctl get extensions --nodes <node-ip>
   ```

2. Review the kernel logs for driver messages:

   ```bash theme={null}
   talosctl logs -k --nodes <node-ip>
   ```

### Device not visible inside the pod

If the pod cannot see `/dev/hailo0`:

* Confirm the namespace is labelled to allow privileged workloads.

* Confirm the pod runs with `privileged: true` and mounts the host's `/dev` directory.

* Confirm the device is detected on the node using the steps in [Verify the card is detected](#verify-the-card-is-detected).