01
Three approaches, three questions
Cloud-native security tooling has converged on three collection models. They are often marketed as alternatives, but they observe different layers of the system and are better understood as answers to different questions.
- Agentless scanning answers: what is deployed and how is it configured? It reads cloud APIs and disk snapshots from outside the workload.
- Host or sidecar agents answer: what is happening on this node or next to this container? They run as privileged processes or proxies alongside the workload.
- eBPF runtime sensors answer: what did this process actually execute, load, open, and connect to? They observe from inside the kernel without modifying the workload.
02
Agentless scanning: how it works and what it misses
Agentless platforms, often labelled CSPM or the posture half of a CNAPP, connect to the cloud provider with read permissions. They enumerate resources, evaluate configuration against policy, and periodically snapshot block storage volumes to inspect installed packages, secrets on disk, and file permissions without touching the running instance. Kubernetes support usually comes from the API server: workloads, RBAC, network policies, and admission configuration are read as objects.
The strengths are real. There is nothing to deploy inside the workload, coverage across accounts is fast, and the approach cannot degrade application performance because it never runs on the application's node. For inventory, misconfiguration, identity exposure, and image vulnerability lists, it is often sufficient.
The blind spot is execution. A snapshot shows that a vulnerable library exists on disk. It cannot show whether any process loaded it, whether a shell was spawned inside a container ten minutes ago, whether an interpreter parsed untrusted input, or what a workload connected to. Snapshot cadence also means that short-lived containers and in-memory activity are never captured. Agentless scanning describes the system at rest.
03
Host agents and sidecars
Traditional agents run as a daemon on each node, or as a sidecar proxy in each pod. They can watch file integrity, intercept network traffic, and enforce policy inline. Service-mesh sidecars in particular give rich layer-seven network visibility because every request passes through them.
The costs are operational. Sidecars add a container to every pod, consume CPU and memory proportional to pod count, and require injection into deployments, which touches the application delivery path. Userspace agents that hook system calls through ptrace or LD_PRELOAD can impose measurable latency and are fragile across language runtimes. Both models see the workload from the outside, at the network or filesystem boundary, rather than from the kernel's view of what a process did.
04
eBPF runtime sensors
eBPF lets a sensor attach small, verified programs to kernel hooks: tracepoints for syscalls and scheduler events, kprobes for kernel functions, uprobes for functions in userspace binaries, and socket hooks for network flows. One sensor per node observes every container on that node because containers share the host kernel. No sidecar, no code change, and no restart of the workload is needed.
The visibility is what makes runtime reachability possible: library loads, executed functions, process lineage, file access, and network connections are observed as they happen, with the process and container identity attached. The same stream supports detection of behaviour that snapshots never capture, such as an unexpected shell in a production container or a connection to an unfamiliar destination.
The trade-offs are also real. The sensor runs in production, so its event selection and buffering have to be engineered carefully to keep overhead low and predictable. It requires a kernel that supports the needed eBPF features, which excludes some legacy distributions. It observes only what runs, so it must be combined with static inventory to reason about paths that have not yet executed. And because it is evidence-rich, the platform consuming the events has to correlate and summarise them, or teams drown in telemetry.
05
Side-by-side comparison
The table below summarises the visibility each model provides. Read it as a coverage map rather than a scorecard: most organisations need the first column for posture and inventory and the last column for execution evidence and detection.
06
Runtime security without Kubernetes
Runtime security does not inherently require Kubernetes. A host-level sensor can observe supported Linux processes and containers, including Docker workloads, through the host kernel. Kubernetes adds workload metadata and deployment orchestration; it is not what makes kernel-event collection possible.
For standalone containers or Linux hosts, review the sensor's kernel requirements, runtime support, host access, and required privileges. Also decide how to associate events with the container image and owning service. A containerized sensor still needs the host access described by its installation guide, and running on one host does not establish coverage of another.
Primod supports evaluation on Linux environments in Kubernetes or host mode. Review its deployment and coverage guidance for your Docker or Linux-host environment, including the current release's supported runtime, privileges, and detection coverage.
07
Choosing and combining
The decision is rarely either-or. Keep agentless scanning where you need cloud posture and inventory coverage, and add runtime sensing where you need execution evidence and detection. Sidecars are another option when the requirement is inline layer-seven policy enforcement rather than observation.
A practical sequence for teams running containers, Kubernetes, or Linux hosts is to retain static inventory, deploy a runtime sensor on supported hosts, and use observed activity as an input to remediation decisions and incident investigation. Primod's vulnerability prioritization workflow shows how package inventory and runtime evidence contribute to that review.
| Capability | Agentless scanning | Host or sidecar agent | eBPF runtime sensor |
|---|---|---|---|
| Cloud configuration and identity posture | Yes, across all accounts | Partial, node scope | No, needs cloud API correlation |
| Installed package and image inventory | Yes, from snapshots | Yes, from disk | Yes, from observed loads |
| Which libraries a process actually loaded | No | Limited | Yes |
| Which functions or syscalls executed | No | Limited, userspace hooks | Yes |
| Process lineage and shells in containers | No | Yes, with overhead | Yes |
| Live network connections per workload | No | Yes, at proxy or host boundary | Yes, at socket level |
| Short-lived containers | Often missed between snapshots | Yes | Yes |
| Inline layer-7 policy enforcement | No | Yes, sidecar proxies | Partial |
| Deployment footprint | None in workload | One per pod or per node | One per node |
| Workload restarts or code changes | None | Sidecar injection required | None |
Frequently asked questions
- What is the difference between agentless CNAPP and runtime protection?
- An agentless CNAPP connects to cloud APIs and snapshots block storage, so it covers configuration, identity, and installed packages across every account with nothing deployed in the workload. Runtime protection observes execution: an eBPF sensor on each node records library loads, process lineage, file access, and network connections as they happen. Most teams keep the CNAPP for posture and inventory and add runtime protection for execution evidence and detection.
- Can I use runtime security without Kubernetes?
- Yes, host-level sensors can observe supported Linux hosts and containers without Kubernetes. For Docker workloads, check the sensor's current runtime, kernel, and privilege requirements. Primod supports evaluation in host mode; coverage is confirmed for your environment and release.
- Is agentless scanning enough for container vulnerability management?
- It is enough to know which vulnerable packages are present and which configurations are wrong. It is not enough to know which of those vulnerabilities are reachable in production or what a workload did, because snapshots capture the system at rest. Teams that rely on it alone prioritise by CVSS and inventory rather than by execution evidence.
- Does an eBPF sensor replace a CSPM or CNAPP posture tool?
- No. Posture tools cover cloud configuration, identity, and inventory across every account with nothing deployed. An eBPF sensor covers execution on the nodes where it runs. They overlap on image vulnerability inventory and complement each other everywhere else.
- How is an eBPF sensor different from a sidecar?
- A sidecar is an extra container in every pod that sees traffic at the network boundary. An eBPF sensor is one process per node that observes every container on that node from the kernel, including process execution, library loads, and file access, without modifying pods or restarting workloads.
- Does eBPF work on every Kubernetes node?
- It requires a Linux kernel with the eBPF features the sensor uses, which modern managed Kubernetes node images provide. Very old kernels or non-Linux nodes are not supported by eBPF-based sensors.
- Which approach has the lowest performance overhead?
- Agentless scanning has none on the workload because it never runs on the node. eBPF sensors run in-kernel and can be scoped to a small set of events, which keeps overhead low when engineered carefully. Sidecars and userspace hooking agents typically cost the most because they sit in the request path or intercept calls in userspace.
Sources and references
- What is eBPF?
eBPF Foundation
- Kubernetes Security Checklist
Kubernetes documentation
- Pod Security Standards
Kubernetes documentation
- NIST SP 800-190: Application Container Security Guide
NIST
- Sidecar containers
Kubernetes documentation