Skip to content
Calcrivo

Runtime Security Calculator

Score runtime security from node and workload sensor coverage, detection latency, alert precision and the CPU overhead the sensors cost.

Inputs

nodes
nodes
workloads
workloads
rules
alerts
alerts
seconds
%
analysts

Runtime Detection Score

60.3/ 100

Grade

C — Fair

Node Sensor Coverage

88.3%

Workload Policy Coverage

81.7%

Alert Precision

0.90%

Alerts per Real Finding

110.5alerts

Alerts per Analyst per Day

1,050alerts

Nodes With No Sensor

28nodes

Verdict

Deploy the sensor as a DaemonSet with no node selector — an unmonitored node is a blind spot by design

Step by step

  1. Values used

    Nodes in the fleet = 240 nodes; Nodes running a runtime sensor = 212 nodes; Workloads in scope = 1,200 workloads; Workloads with runtime policy applied = 980 workloads; Runtime rules enabled = 180 rules; Runtime alerts per day = 4,200 alerts; Alerts worth investigating per day = 38 alerts; Mean time from event to alert = 45 seconds; CPU overhead of the sensor = 3.20 %; Analysts triaging runtime alerts = 4 analysts

  2. Runtime Security

    Detection score = coverage × 0.5 + latency score × 0.3 + precision score × 0.2 − CPU overhead percentage, where coverage blends node and workload coverage equally.

  3. Alert noise

    Alerts per real finding = alerts per day ÷ investigable alerts per day — the ratio that predicts whether the queue is read at all.

  4. Runtime Detection Score

    = 60.3 / 100

  5. Grade

    = C — Fair

  6. Node Sensor Coverage

    = 88.3

  7. Workload Policy Coverage

    = 81.7

  8. Alert Precision

    = 0.90

  9. Alerts per Real Finding

    = 110.5 alerts

How it works

Runtime security only works where the sensor runs, so coverage is half the score, and it only works if somebody reads the output, which is why precision and per-analyst volume are reported explicitly. Precision is scaled by ten because a 10% precision rate is genuinely respectable for behavioural syscall detection, unlike for a signature-based control. Runtime detection is the last control between a container escape and a compromised node, and it fails in two predictable ways: a node pool that never got the DaemonSet, and four thousand alerts a day that nobody opens.

Formulas

Runtime Security

Detection score = coverage × 0.5 + latency score × 0.3 + precision score × 0.2 − CPU overhead percentage, where coverage blends node and workload coverage equally.

coverage
Mean of node sensor coverage and workload policy coverage
latencyScore
max(0, 100 − 0.8 × mean detection seconds)
precisionScore
min(100, 10 × alert precision)

Alert noise

Alerts per real finding = alerts per day ÷ investigable alerts per day — the ratio that predicts whether the queue is read at all.

noiseRatio
Alerts an analyst reads per genuine finding
alertsPerAnalyst
Daily alerts divided by the analysts triaging them

Frequently Asked Questions

How is Runtime Security calculated?

Detection score = coverage × 0.5 + latency score × 0.3 + precision score × 0.2 − CPU overhead percentage, where coverage blends node and workload coverage equally. Runtime security only works where the sensor runs, so coverage is half the score, and it only works if somebody reads the output, which is why precision and per-analyst volume are reported explicitly. Precision is scaled by ten because a 10% precision rate is genuinely respectable for behavioural syscall detection, unlike for a signature-based control.

Why does Runtime Security matter?

Runtime detection is the last control between a container escape and a compromised node, and it fails in two predictable ways: a node pool that never got the DaemonSet, and four thousand alerts a day that nobody opens.

What values do I need to enter?

This calculator takes 10 inputs: Nodes in the fleet, Nodes running a runtime sensor, Workloads in scope, Workloads with runtime policy applied, Runtime rules enabled, Runtime alerts per day, Alerts worth investigating per day, Mean time from event to alert, CPU overhead of the sensor, Analysts triaging runtime alerts. The pre-filled defaults are a realistic starting point — replace them with figures from your own environment for a result you can act on.

Where should runtime rules focus?

On things that never happen in a healthy container: a shell spawned inside a running pod, writes to /etc or a package manager executing, outbound connections from a process that should only listen, and reads of the service account token by anything other than the SDK. Those four families catch most post-exploitation and are naturally quiet.

Is eBPF overhead acceptable in production?

Usually, in the 1–5% CPU range, and it is tunable — most of the cost is the breadth of the syscall filter and how much context is enriched per event. Measure it on your busiest node type rather than accepting a vendor figure, because syscall-heavy workloads such as build agents are the worst case.

You might also need