Netskope LogoNetskope Logo
  • Security Services
  • AI Services
  • Networking Services
  • Analytics Services
  • Integrations
  • getting-started.svgGetting Started
    • Support
    • Community
    • Netskope.com
    © 2026 All Rights Reserved. Netskope Inc.
    Home
    AI Command Center
    Getting Started with AI Command Center
    Configuring Workload Sensors

    Configuring Workload Sensors

    AI Command Center discovers AI agents and non-human identities running on Linux servers and Kubernetes nodes using the Workload Sensor. The Workload Sensor uses eBPF technology to collect activity data on monitored hosts and forward it to Netskope through the Virtual Private Edge (VPE) for analysis in the AI Command Center.

    What You’ll See in AI Command Center

    Once the Workload sensor is deployed and forwarding data, AI Command Center surfaces that data in the Agents and Non-Human Identities pages.

    Agents – Autonomous and semi-autonomous AI processes detected on monitored hosts, built on agent frameworks such as LangChain, LangGraph, AutoGen, and CrewAI. Agents appear in:

    • The Agents panel on the AICC Asset Overview page.
    • The Agents section under Assets on the AI Inventory page.

    Non-Human Identities – Machine identities such as Kubernetes service accounts, CI/CD pipeline identities, API keys, and workload OIDC identities that interact with AI applications, agents, MCP servers, and models. Non-human identities appear in:

    • The Non-Human Identities section under Identities on the AI Inventory page.

    How It Works

    The Workload sensor runs as a lightweight DaemonSet on Kubernetes clusters, or as a systemd service on Linux VMs. It observes process activity, network connections, and identity tokens at the kernel level to detect agent frameworks and non-human identities without requiring traffic to route through the Netskope proxy.

    During installation, you configure the sensor to point to your (on prem) Netskope Virtual Private Edge (VPE). The sensor connects to the VPE over tls and begins streaming AI usage events to the Netskope platform. No direct internet egress is required from cluster nodes, all communication routes through the VPE.

    Prerequisites

    Before installing the Workload (eBPF) sensor, ensure your environment meets the following requirements.

    RequirementDetails
    Linux kernel4.18 or later, with CONFIG_BPF and CONFIG_BPF_SYSCALL enabled. 5.8+ recommended for optimal performance5.15+ for best resultsCPU architecture x86_64 or arm64
    Kubernetes version1.23+ (EKS, GKE, AKS, or self-managed)
    Linux VM OSAny systemd-based Linux distribution that meets the kernel requirement, for example RHEL 8.2+, Ubuntu 20.04+, Amazon Linux 2 (kernel 5.10), or Amazon Linux 2023. Root access is required to install.
    Network accessSensor nodes must reach the VPE on TCP 37070 (event stream) and 37071 (enrollment and installer downloads). Kubernetes nodes must be able to pull the sensor image from Artifactory or your registry mirror.
    Namespace privilegesIf your cluster enforces Pod Security Admission, the sensor namespace needs the `pod-security.kubernetes.io/enforce: privileged` label. The VPE-generated manifest applies it for you.For Helm installs, add the label to the namespace yourself.
    RBACCluster-admin, or equivalent permission to create a Namespace, ServiceAccount, DaemonSet, Job, ConfigMap, Secret, ClusterRole, ClusterRoleBinding, and PriorityClass.
    VPEOne or more Netskope Virtual Private Edge (VPE) nodes must be deployed and operational. See Virtual Private Edge.

    Procedure

    Step 1: Configure the Collector Service on VPE

    1. In the Netskope tenant UI, navigate to Settings > Security Cloud Platform > Virtual Private Edge.
    2. Select the VPE node or VPE group where you want to enable the Workload (eBPF) collector.
    3. On the Services tab, add the Workload (eBPF) collector service and review the default input and output settings.
    4. Click Save.

    After you save, the VPE is ready to accept connections from sensor agents.

    Step 2: Generate the Sensor Install Command

    Use the Netskope REST API v2 to generate a ready-to-run install command for your target cluster or VM. The command is pre-filled with your VPE endpoint, your tenant’s cluster credential, and the sensor version approved for your tenant.

    Every request needs a REST API v2 token in the Authorization: Bearer header.

    1. Find your collector ID. The install API is keyed by the collector ID of your VPE, not by its hostname:

    curl -s -H "Authorization: Bearer $API_TOKEN" \
      "https://<tenant>.goskope.com/api/v2/shadowai/collectors" \
      | jq -r '.data[] | "\(.collectorId)\t\(.enrollmentEndpoint)\t\(.ok)"'

    The enrollmentEndpoint shown is the address the VPE reports for itself. It is often a private or internal address that your sensors cannot reach, so you supply the reachable address in the next step.

    2. Request the install command. Choose the format that matches your deployment tooling:

    # Helm (recommended for Kubernetes)
    curl -s -H "Authorization: Bearer $API_TOKEN" \
      "https://<tenant>.goskope.com/api/v2/shadowai/collectors/<collector-id>/install?format=helm&endpoint=https://<vpe-host>:37071"
    
    # kubectl
    curl -s -H "Authorization: Bearer $API_TOKEN" \
      "https://<tenant>.goskope.com/api/v2/shadowai/collectors/<collector-id>/install?format=kubectl&endpoint=https://<vpe-host>:37071"
    
    # Bash (for Linux VMs)
    curl -s -H "Authorization: Bearer $API_TOKEN" \
      "https://<tenant>.goskope.com/api/v2/shadowai/collectors/<collector-id>/install?format=bash&endpoint=https://<vpe-host>:37071"

    Replace :

    • <tenant> with your Netskope tenant hostname
    • <collector-id> with the collectorId from the previous step
    • <vpe-host> with the address your sensors use to reach the VPE.
    • The endpoint parameter is required and must include the scheme and port 37071. If your VPE sits behind a load balancer, use the load balancer address.
    If you have not assigned a DNS name (FQDN) to your VPE, pass the VPE’s IP address in the endpoint on every /install request, for example endpoint=https://10.20.30.40:37071.

    The API returns a JSON response. Copy the data.command field; it is the command to run. The following is an example Helm command:

    helm install shadow-ai-sensor \
      oci://registry-1.docker.io/netskopeprivateaccess/shadow-ai-monitor-chart \
      --namespace shadow-ai-monitoring --create-namespace \
      --set collector.endpoint=vpe-prod.corp.example.com:37070 \
      --set enrollment.endpoint=https://vpe-prod.corp.example.com:37071 \
      --set credential.token=nsk_cluster_v1_eyJhbGciOi... \
      --set image.tag=143.0.2406 \
      --set image.repository=docker.io/netskopeprivateaccess/shadow-ai-monitor

    Before running the Helm command, add two flags:

    • –set createNamespace=false. This is required with Helm 3, which otherwise fails with namespaces “shadow-ai-monitoring” already exists, because the chart tries to create the namespace a second time. It is harmless with Helm 4.
    • –version <data.version>. This installs the chart from the same release as the image; without it, Helm installs the newest published chart.

    When the endpoint is an IP address, the VPE presents a self-signed certificate, so the returned command includes –set enrollment.tlsSkipVerify=true (Helm) or curl -k (kubectl and Bash).

    The nsk_cluster_v1_… value embedded in the command is your tenant’s cluster credential. It does not expire and is not limited to a number of nodes, so autoscaled nodes can always enroll. Treat it as a secret: it authorizes sensor enrollment to your tenant. You can issue additional credentials with POST /api/v2/shadowai/credentials/rotations.

    Step 3: Run the Install Command

    Before running the command, verify your shell is pointed at the correct target cluster or host.

    Kubernetes:

    # Confirm you are targeting the intended cluster
    kubectl config current-context
    
    # Switch context if needed
    kubectl config use-context <your-cluster-context>

    Run the command generated in Step 2. For Helm deployments, Helm v3.8 or later is required. The chart on Docker Hub is public, so no registry credentials are needed.

    If your cluster enforces Pod Security Admission at the baseline or restricted level, prepare the namespace before a Helm install. The Helm install does not label the namespace for you; the kubectl manifest does.

    kubectl create namespace shadow-ai-monitoring
    kubectl label namespace shadow-ai-monitoring pod-security.kubernetes.io/enforce=privileged

    The command creates the shadow-ai-monitoring namespace if needed, deploys the sensor DaemonSet, and starts enrollment automatically.

    Linux VM: Run the generated command on the target host. It downloads the install script from your VPE and runs it with sudo. The script checks kernel compatibility, downloads the sensor binary from your VPE, creates a systemd service, and starts enrollment.

    Step 4: Verify the Deployment

    Each sensor pod runs up to two init containers before the sensor starts. Both must complete successfully.

    Init ContainerPurpose
    kernel-preflightValidates the kernel version (4.18 or later) and BPF support. Missing optional features, such as BTF, are logged as warnings and do not stop the pod.
    identity-chownSets ownership on the node directory that stores the sensor identity

    If the VPE is unreachable, the sensor container logs the enrollment error and keeps retrying.

    Kubernetes:

    Check pod status and confirm enrollment:

    # Check pod status
    kubectl get pods -n shadow-ai-monitoring -l app.kubernetes.io/name=shadow-ai-monitor
    
    # Verify enrollment succeeded ("identity ready" appears when a restarted pod reuses its enrollment)
    kubectl logs -n shadow-ai-monitoring -l app.kubernetes.io/name=shadow-ai-monitor -c monitor --tail=-1 \
      | grep -E "enrollment successful|identity ready"

    Each sensor pod should show Running with 1/1 ready. Helm installs also run one shadow-ai-monitor-seccomp-installer pod per node; the label selector above excludes it.

    Run the log check soon after the pods start. The enrollment line is written once at startup, and the pod log rotates within hours, so for long-running pods use the API check below instead.

    Linux VM:

    sudo systemctl status shadow-ai-monitor
    sudo journalctl -u shadow-ai-monitor | grep -E "enrollment successful|identity ready"

    Confirm that your sensors are registered with your tenant:

    curl -s -H "Authorization: Bearer $API_TOKEN" \
      "https://<tenant>.goskope.com/api/v2/shadowai/sensors?state=active&limit=500" \
      | jq -r '.data.items[] | "\(.hostname)\t\(.state)\t\(.currentVersion)"'

    Each cluster node or VM should appear as active within a few minutes of successful enrollment.

    Step 5: Confirm Data in AI Command Center

    After the sensors are connected and streaming, go to the AI Command Center. Agents and non-human identities appear as the sensors observe AI activity on the monitored hosts. A host with no AI activity produces no entries.

    Upgrade

    Helm:

    helm upgrade shadow-ai-sensor \
      oci://registry-1.docker.io/netskopeprivateaccess/shadow-ai-monitor-chart \
      --version <new-version> \
      --namespace shadow-ai-monitoring \
      --reuse-values \
      --set image.tag=<new-version>

    Use the data.version value from the Step 2 API call as <new-version>. Always pass –set image.tag; with –reuse-values, an upgrade without it keeps running the old image. Before any pod is replaced, a pre-upgrade check validates the stored credential against the VPE; if it fails, the upgrade stops and the running sensors are left unchanged. Pods are then replaced one node at a time.

    kubectl: Generate a new format=kubectl command (Step 2) and run it. It updates the DaemonSet in place.

    Linux VM: Run the format=bash command from Step 2 again on each host. The sensor keeps its existing enrollment.

    Uninstall

    Kubenetes (Helm):

    helm uninstall shadow-ai-sensor -n shadow-ai-monitoring
    kubectl delete namespace shadow-ai-monitoring --ignore-not-found   # helm uninstall leaves the namespace

    Kubernetes (kubectl):

    kubectl delete namespace shadow-ai-monitoring
    kubectl delete clusterrole shadow-ai-monitor
    kubectl delete clusterrolebinding shadow-ai-monitor
    kubectl delete priorityclass shadow-ai-monitor-priority

    On Kubernetes, each node keeps its sensor identity in /var/lib/shadow-ai-monitor/identity, so a reinstall on the same nodes reuses the existing enrollment.

    Linux VM: Run the uninstall script from your VPE on the host:

    curl -fsSL https://<vpe-host>:37071/uninstall.sh | sudo bash

    The script stops and removes the service, binaries, configuration, logs, and identity. Use curl -fsSLk if your VPE endpoint is an IP address. Do not remove the files manually: the identity files are marked immutable and rm -rf cannot delete them.

    Limitations

    • The Workload sensor supports Linux servers and Kubernetes nodes on x86_64 and arm64. You can use Netskope Client for Windows hosts.
    • The sensor detects agents and non-human identities but does not block or modify their activity.
    • Hosts running kernels older than 4.18 are not supported. On RHEL 8, release 8.2 or later is required. Kernel 5.8+ is recommended for optimal performance.
    • Kubernetes sensors are not upgraded automatically. Upgrade them with Helm or kubectl as described above.
    In this Topic
    • Configuring Workload Sensors