Guide
Guide · ComparisonUpdated October 7, 2026

Agentless CNAPP vs Runtime Protection Explained

An agentless CNAPP reads cloud APIs and disk snapshots, so it shows what is deployed and how it is configured, but only at rest. Runtime protection uses an eBPF sensor on each node to record what processes actually execute, load, open, and connect to.

Short answer

Agentless scanning inventories installed packages and configuration through disk snapshots and cloud APIs, while runtime security observes execution through a sensor on the host; runtime sensors can cover supported Linux hosts and containers with or without Kubernetes.

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.

app.primod.io / runtime / alerts / checkout-service
Runtime alert HighIllustrative scenario · Product UI preview

Web process launched a shell

Workload
checkout-service · Deployment
Namespace
production
Process chain
web worker → /bin/sh
Observed activity
Shell launch followed by a token read and an outbound connection attempt
Interpretation
Consistent with suspicious command execution and credential access
Response
Observe — no action blocked

Where it ran

Podcheckout-service-7d9f6c-x2k4p
Nodenode-pool-b-03
Containercheckout
Image digestsha256:9f2c…a1e0

Request context

Method · route: POST /api/upload

Trace · span: supplied by instrumentation

Detection details

Rule: rce-shell-web-ancestor · rev 3

Technique mapping: as provided by the rule

Evidence quality

Complete · Process ancestry complete for this alert

Limited · Some events may be missing: capture reported lost events on this node during the window

What a runtime sensor can show that a snapshot cannot: the process chain and what followed. Illustrative scenario · Product UI preview.

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.

Visibility comparison of agentless scanning, host or sidecar agents, and eBPF runtime sensors
CapabilityAgentless scanningHost or sidecar agenteBPF runtime sensor
Cloud configuration and identity postureYes, across all accountsPartial, node scopeNo, needs cloud API correlation
Installed package and image inventoryYes, from snapshotsYes, from diskYes, from observed loads
Which libraries a process actually loadedNoLimitedYes
Which functions or syscalls executedNoLimited, userspace hooksYes
Process lineage and shells in containersNoYes, with overheadYes
Live network connections per workloadNoYes, at proxy or host boundaryYes, at socket level
Short-lived containersOften missed between snapshotsYesYes
Inline layer-7 policy enforcementNoYes, sidecar proxiesPartial
Deployment footprintNone in workloadOne per pod or per nodeOne per node
Workload restarts or code changesNoneSidecar injection requiredNone

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

  1. What is eBPF?

    eBPF Foundation

  2. Kubernetes Security Checklist

    Kubernetes documentation

  3. Pod Security Standards

    Kubernetes documentation

  4. NIST SP 800-190: Application Container Security Guide

    NIST

  5. Sidecar containers

    Kubernetes documentation

Keep reading

Related articles

All articles