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.
| Requirement | Details |
|---|---|
| Linux kernel | 4.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 version | 1.23+ (EKS, GKE, AKS, or self-managed) |
| Linux VM OS | Any 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 access | Sensor 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 privileges | If 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. |
| RBAC | Cluster-admin, or equivalent permission to create a Namespace, ServiceAccount, DaemonSet, Job, ConfigMap, Secret, ClusterRole, ClusterRoleBinding, and PriorityClass. |
| VPE | One 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
- In the Netskope tenant UI, navigate to Settings > Security Cloud Platform > Virtual Private Edge.
- Select the VPE node or VPE group where you want to enable the Workload (eBPF) collector.
- On the Services tab, add the Workload (eBPF) collector service and review the default input and output settings.
- 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.
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).
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 Container | Purpose |
|---|---|
| kernel-preflight | Validates 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-chown | Sets 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.

