Skip to content
Field Notes

What InnerWarden Pro costs a Linux host, measured

7 min read

Every technical buyer asks the same question before putting a security agent on a server: what does it cost me? Until this week we did not have an answer we could defend. We had measured the free CLI's hook, the local API and plenty of detection quality, but never what the paid host stack costs the machine it protects. Our rule is that we only claim what we have measured, so we measured it.

The setup

One Azure Standard_D4as_v7 (4 vCPU, AMD), Ubuntu 24.04, kernel 7.0. A fresh VM in its own network, created for this test and deleted the same day. InnerWarden Pro 0.17.18, installed with the same one-line installer a customer uses.

The workload runs inside a systemd service that stands in for an AI agent, connected to InnerWarden the way our docs describe, so the guards that only watch the agent see every program it starts. Each phase ran five rounds of three micro benchmarks and three real builds:

  • exec: start /bin/true and wait for it, 3,000 times.
  • open: open, read and close a small file, 200,000 times.
  • connect: open a TCP connection to a local listener, 20,000 times.
  • build: compile redis 7.2.5 with make -j4, which starts thousands of compiler processes on all four cores.

We report medians. We also read the kernel time of every InnerWarden BPF program and the CPU time of every InnerWarden process during each phase, because a saving in one place can come back as a cost in another.

PhaseWhat ran
BaselineThe same VM with no InnerWarden
Pro, defaultsInstalled, nothing armed: what you get right after the installer
Guards in observeAfter innerwarden-ctl arm and the reboot it asks for: the Execution Gate and the Secret Read Guard watching the agent, its DNS lookups routed through InnerWarden's own resolver
Gate enforcingAs above, with the Execution Gate refusing anything the agent was not allowed to run

Before measuring the last phase we checked the gate was really on: a fresh copy of /bin/true started from inside the agent got Operation not permitted, and the original ran. After the last phase we stopped InnerWarden, unloaded it completely and ran the baseline again, because the VM itself got about 11% slower on exec after its reboot. The armed phases are compared with that second baseline.

The results

BaselinePro, defaultsGuards in observeGate enforcing
exec, median286 to 319 us354 us (+24%)404 us (+27%)399 us (+25%)
open + read + close, median2.6 us3.6 us (+1.0 us)4.5 us (+1.9 us)4.5 us (+1.9 us)
local TCP connect, median23 to 27 us52 us (2.3x)74 us (2.8x)66 us (2.5x)
redis build, wall time16.4 s17.0 s (+3.7%)17.3 s (+5.8%)17.5 s (+6.7%)
redis build, CPU time59.3 to 59.5 s60.2 s (+1.4%)60.4 s (+1.4%)60.5 s (+1.7%)

Idle, with the gate enforcing and nothing running, InnerWarden used 2.7% of one core.

What it means

On real work the cost is single digits. A build that starts thousands of processes and keeps all four cores busy took 3.7% longer with Pro at its defaults and 6.7% longer with every guard armed. The build's own CPU time grew by under 2%. Most of the difference in wall time is InnerWarden's own processes sharing the four cores with the compiler.

Enforcing costs nothing extra. The observe and enforce phases are the same within noise. The decision to refuse a program is cheap; watching is what costs, and you pay for watching in observe mode too.

Idle is quiet. Under 3% of one core on a host doing nothing.

Where it costs, honestly

Starting a program pays about 70 to 85 microseconds more. About a quarter of that is kernel-side; the rest is the sensor's own work on each new process. For a server that starts a few programs a second this is invisible. For a build or a CI job that starts thousands, it is the 4% to 7% above.

Opening a file pays 1 to 2 microseconds more. Real, small, and only noticeable in a loop that does nothing else.

Local TCP connects are our outlier. In a storm of 20,000 connections to the same machine in about a second, each connect took 2.3 to 2.8 times as long. The BPF programs explain about 1.5 microseconds of the 30 to 47 added. The rest is our sensor process: during the storm it re-reads the kernel's view of open sockets, and that view grows with every connection waiting to close. A normal service never does this, but it is a real cost of our design and we have opened an item to reduce it.

One deployment note

With the gate enforcing, the agent may only run programs from paths that only root can write. When we asked InnerWarden to trust our benchmark binaries in a folder our test user owned, it refused: the kernel allows by path, so a writable folder would let anyone swap the program behind an allowed name. That also means an agent that runs a script straight from its own workspace (redis runs one during its build) is refused under enforce until the script is run through an allowed interpreter or moved somewhere only root can write. That is the point of the gate, and it is worth knowing before you enforce on a coding agent. The observe, rehearse, enforce workflow shows you every such program before anything is refused.

Limits

One VM size, one kernel, one cloud. Cloud machines drift by a few percent between runs, which is why we ran the baseline twice. The micro benchmarks are worst cases by design. We measured the Execution Gate in enforce; the Secret Read Guard and the DNS resolver were in observe, so their enforce costs are not in this table.

If you run InnerWarden and see different numbers on your hardware, tell us. We would rather publish a worse number that is true than a better one that is not.