Endpoint Vulnerability Management

What ‘Runtime’ Means in Vulnerability Management, and What It Doesn’t

In vulnerability management, runtime means observing what software does while it executes on the endpoint to decide whether a vulnerability is exploitable there. Three conditions have to hold: the vulnerable code runs, attacker input can reach it, and no control blocks it. Runtime evidence is the record of whether they hold on each machine.

Josh Skorich
Josh Skorich
CTO & Co-Founder
January 21, 2026
·
Updated November 3, 2026
·
— min read

On this page

What ‘Runtime’ Means in Vulnerability Management, and What It Doesn’t

Most security tools say “runtime” and mean something different by it. Cloud security platforms mean protecting a container or a VM while it runs. Application security vendors mean a sensor inside a web app watching requests. Endpoint detection means catching an attacker who is already executing on the box. In vulnerability management, runtime means one thing: observing what software does while it executes on the endpoint, so you can tell which vulnerabilities are exploitable on that machine.

That definition carries the whole argument, so I want to be exact about it. A CVE tells you a flaw exists in a version of a program. It doesn’t tell you whether that program runs on your hosts, whether the flawed code path executes, whether anything an attacker controls can reach it, or whether a control already blocks the attempt. Runtime evidence is the record of those answers, gathered on the machine where the software runs.

Why does “runtime” mean something different in every tool?

The word caught on because it sounds like the opposite of a static scan, and every category grabbed it. Cloud workload protection watches containers, VMs and serverless functions for malicious activity. Application detection and response tools put a sensor inside one application and inspect the requests and data flowing through it. Endpoint detection and response watches for an adversary mid-attack: the injected thread, the credential dump, the lateral move.

None of those definitions are wrong. None of them answer the vulnerability manager’s question either. That question is narrower and older: of the thousands of CVEs my scanner matched against installed versions, which ones could an attacker use here, today? Vulnerability management needs something watching the software itself, across every program on the host, for the conditions an attacker would use, and it needs that before any attack happens.

I spent most of my career on the offensive side, and that lens is what makes the definition obvious. The first hour on a compromised host is inventory of a different kind: what’s running, as whom, listening on what, launching what. The process list tells you more in ten minutes than the CVE catalog tells you in a day, because the process list is where exploitability lives. Runtime, for vulnerability management, is reading that process list the way a red teamer reads it, continuously, on every endpoint, before the red teamer shows up.

What has to be true for a vulnerability to be exploitable?

Three conditions, and all three have to hold at the same time.

  1. The vulnerable code executes. A library sitting on disk that no process loads is a finding for your inventory. It isn’t a risk. The same goes for a vulnerable feature in a program that runs every day and never takes the code path with the bug in it.
  2. Attacker input can reach it. The code path has to be reachable from something an attacker controls, such as a network socket, a file the user opens, a named pipe, an IPC channel, or a command-line argument another process can set.
  3. Nothing blocks the attempt. A privilege boundary, an exploit mitigation, a policy that stops the child process from launching. Any of these turns a reachable flaw into a dead end.

Reachability is the industry’s name for the first condition: whether the vulnerable code runs at all. Reachable is necessary. It isn’t sufficient. Exploitable means all three conditions hold, and the only place you can check the second and third is on the machine, while the software runs. A dependency manifest tells you what’s installed. A static scan tells you what’s written. Neither can tell you which of the three conditions is met in your environment.

Why the endpoint is the vantage point

Most security data arrives late and from a distance. Network sensors see traffic at the perimeter. Log aggregators see whatever something chose to record. Cloud APIs see configuration state. Each source holds one slice, and the slices don’t line up: by the time a connection shows up in a network sensor, you’ve lost which process opened it, under what identity, after loading which modules.

On the endpoint the slices are still joined. The process that made the connection, the privileges it held, the files it touched, the parent that spawned it: all of it is observable in one place at the moment it happens. Exploitability is a question about those relationships, so the endpoint is where you have to ask it. Every action an attacker needs passes through the operating system on that host, which makes the host the one choke point where all three conditions can be checked together.

What counts as runtime evidence?

Runtime evidence is what the software did, recorded as it ran. On a Windows, macOS or Linux endpoint that comes down to five kinds of observation.

Process execution. Which programs start, with what arguments, spawned by which parent. For instance, a web server launching a shell is a different story from a web server handling requests.

System calls. The interface between a program and the operating system. They show which resources the program uses, as opposed to which ones it’s permitted to use.

Network activity. Which connections form, to where, over what protocol, and whether anything validated the certificate on the other end.

File system operations. What gets read, written, created and deleted. A program with read access to a credential store and a program that reads it are two different risks.

Privilege context. What the process holds and what it uses. Granted and exercised privileges are rarely the same set.

Three of Spektion’s own disclosures this year show what those observations catch that a scan of the file on disk cannot. Punto Switcher ships a signed binary that looks clean to a file scanner; at launch it calls RunDll32.exe by bare name and lets the search order decide which file answers, which lets a local attacker run arbitrary code (CVE-2026-25865). Adobe Genuine Service creates a named pipe writable by Everyone and serves it from a process running as SYSTEM (CVE-2026-71381). MobaXterm carried a local privilege escalation that only shows up when the program executes (CVE-2026-25866). The Spektion Research Team found all three while running the sensor and disclosed them through our CNA partner, and none of them had a CVE until we disclosed. They were sitting on endpoints the whole time, exploitable, with nothing in the catalog to match against.

Definition of runtime in vulnerability management; what runtime reveals about software that is running

Examples of runtime evidence from one environment: green is behavior that matches the baseline for that software, red is behavior that doesn’t.

What runtime is not

The same word sells three other products, so the line is worth drawing by category.

Workload protection watches a container or a cloud VM for malicious activity, and it’s built for the workloads a platform team deploys. Vulnerability management has to cover the laptop in finance running a budget macro, the build server and the jump host, and it has to answer a before-the-attack question on all of them.

Application-layer sensors instrument one application you wrote and inspect its requests. Useful for that app. Silent on the other few thousand programs on the host that you didn’t write.

EDR watches for an adversary who is already executing. Runtime evidence for vulnerability management watches the software for the conditions an adversary would use, so you can remove them first. EDR answers “is someone attacking this host?” Runtime answers “what on this host could be attacked, and how?” Different jobs. Both required.

The software the inventory model never sees

The inventory model assumed software arrived through a pipeline: procured, deployed, versioned, scanned. Three kinds of software now skip the pipeline, and each is invisible to a tool that needs a manifest.

Internally built and AI-written applications. An analyst prompts a coding assistant, pastes the result into a terminal and runs it. The code may never touch a repository. There is no package manager to query and nothing for a scanner to match against. The process still makes system calls.

Ephemeral scripts. The migration script that ran once and cached credentials in a config file. The automation that changed permissions and left them changed. The code is gone by the time a scheduled scan runs; the effects stay.

AI agents and the connections they open. An AI agent with Model Context Protocol access to email, calendar and cloud storage operates at a wider scope than any single integration. Authorization systems show what the agent is permitted to do. Audit logs show what each service chose to record. Only the host sees which process made the connection, with which credential, and what moved.

Runtime evidence needs none of the inputs those tools need: no repository, no manifest, no deployment record. Whatever executes, however it arrived, gets observed. The pipeline most programs rely on was built to see software that announces itself, and a growing share of what runs on your endpoints doesn’t.

What changes in the CVE queue

The payoff is numbers you can defend to the people who do the patching. Across Spektion deployments, 50 to 80% of critical CVEs turn out not to require action. About 70% of critical CVEs sit in software that isn’t executing at all. The same CVE scores 9.76 on one system and 4.00 on another, because one host runs the program with elevated privileges and network exposure and the other isn’t running it.

Then there is the exposure the catalog never listed. In Spektion Research’s data, 71% of applications with exploitable flaws had no CVE assigned. The clock has changed too. Mandiant’s 2026 M-Trends report puts mean time-to-exploit at an estimated negative seven days: exploitation routinely begins before a patch ships. A queue built from the catalog alone starts a week behind.

Inventory and behavior

Inventory asks what you have. Behavior asks what’s happening. Vulnerability management needs both, and it has mostly run on the first. Gartner’s definition of continuous threat exposure management asks programs to “continually evaluate the accessibility, exposure and exploitability” of their assets. Runtime evidence is what makes the third word something you check rather than something you estimate.

When a vendor says runtime, ask which one. If the answer is a container, an app sensor or a threat feed, it’s a fine product answering a different question. For vulnerability management the test is short: does it tell you, per host, whether the vulnerable code executes, whether an attacker can reach it, and whether anything stops them? That is the runtime at the center of The Spektion Platform. How runtime evidence works in practice is its own guide.

Joe Silva and NIQ strategist Kirk Havens work through the same shift on the Security Theater podcast, making the case for why vulnerability management is dead and what replaces it.

See what's exploitable in your environment, whether there's a CVE for it or not.

Many exploitable vulnerabilities never get a CVE. Book a demo to see how Spektion finds what's actually exploitable across your endpoints.

Book a Demo