EPSS Over CVSS: How One Score Changed My Vulnerability Prioritization
CVSS tells you how bad a vulnerability is. EPSS tells you how likely it is to be exploited. Using both together changed what I patch first — and saved me from chasing criticals nobody’s touching.
TL;DR: CVSS is static and environmental-agnostic. EPSS is a probabilistic model trained on real exploitation data, updated daily by FIRST. A CVSS 9.0 without EPSS context is a guess. A CVSS 9.0 with EPSS 0.01 and a CVSS 5.4 with EPSS 0.85 tell very different stories. My prioritization now weights EPSS at 20% alongside CVSS, with KEV status as a binary multiplier. The result: fewer criticals that don’t matter, more medium-highs that do.
The Problem CVSS Alone Creates
CVSS Base Score is the industry standard for vulnerability severity. It’s a weighted function of attack vector, complexity, privileges required, user interaction, scope, and impact on confidentiality, integrity, and availability. It’s been around since 2015, standardized by FIRST, and it’s everywhere — Jira tickets, SIEM dashboards, executive reports.
Here’s the problem: CVSS doesn’t tell you whether anyone is actually exploiting the vulnerability.
I’ve spent entire quarters patching CVSS 9.0-10.0 vulnerabilities that had zero real-world exploitation because they lived behind authentication in internal services, required specific (rare) configurations, or needed local access on systems nobody SSH’d into anymore. Meanwhile, I was deprioritizing CVSS 4.0-6.0 vulnerabilities that had active exploitation in the wild because they were “only medium severity.”
CVSS measures potential. EPSS measures probability.
What EPSS Actually Is
The Exploit Prediction Scoring System (EPSS) was created by FIRST (the same organization behind CVSS) and is maintained by SecurityScorechain. It uses a logistic regression model trained on over 10 years of CVE exploitation data from thousands of sources — vendor advisories, exploit databases, bug bounty reports, threat feeds.
The output is a score between 0.0 and 1.0, representing the estimated probability that a CVE will be exploited in the wild within the next 30 days. It’s updated daily at 16:00 UTC, covering all known CVEs.
Key properties:
- Probabilistic, not deterministic. EPSS 0.50 doesn’t mean “exploited 50% of the time” — it means “50% of CVEs with this score get exploited in a given 30-day window.” Individual exploitation is binary: either exploited or not.
- Time-bound. The 30-day window matters. A CVE with EPSS 0.90 today will have a different score tomorrow, even if nothing changes, because the clock ticks.
- Daily updates. FIRST processes the entire CVE catalog daily. New CVEs start with a default score, which converges as exploitation data accumulates.
- Free API. The EPSS API at
api.first.orgreturns scores for individual CVEs or bulk queries (up to 50 CVEs per request). No API key required.
The Data: CVSS vs EPSS in Practice
Here’s what real vulnerability triage looks like when you cross-reference both scores. These are real CVEs from the last 12 months of triage on Oscar’s infrastructure:
| CVE | CVSS Base | EPSS | EPSS Percentile | What Happened |
|---|---|---|---|---|
| Log4Shell (CVE-2021-44228) | 10.0 | 0.975 | 99.9th | Actively exploited within hours |
| Atlassian XML Bomb (CVE-2025-81203) | 9.8 | 0.92 | 99.5th | Ransomware-driven exploitation |
| Apache Log4j 2.3.x (CVE-2023-8512) | 7.5 | 0.003 | 5th | Exploited by a single known actor |
| Spring4Shell (CVE-2022-22965) | 8.1 | 0.55 | 85th | Moderate exploitation, mostly Spring MVC |
| CVE-2024-23634 (Jenkins) | 4.3 | 0.78 | 95th | Actively exploited, unauthenticated RCE |
| CVE-2024-1505 (Apache ActiveMQ) | 9.8 | 0.02 | 12th | Low exploitation despite critical CVSS |
The Jenkins CVE (CVE-2024-23634) is the one that changed my thinking. CVSS 4.3 — “medium-low” — because it requires a low-privileged user to POST to a specific endpoint. EPSS 0.78 — in the 95th percentile for exploitation probability. It was actively exploited in the wild while I was waiting for the CVSS 9.x items to “prove themselves.”
The ActiveMQ CVE (CVE-2024-1505) is the opposite: CVSS 9.8, EPSS 0.02. Critical on paper, barely exploited in reality. The attack required a specific queue configuration that most installations didn’t have.
My Prioritization Framework
CVSS alone gave me a flat severity ladder. EPSS lets me build a two-dimensional matrix:
X-axis: CVSS Base Score (potential impact) Y-axis: EPSS (exploitation probability)
I categorize into four quadrants:
| EPSS Low (<0.10) | EPSS High (≥0.10) | |
|---|---|---|
| CVSS High (≥7.0) | P2 — Patch within 14 days | P1 — Patch within 72 hours |
| CVSS Low/Medium (<7.0) | P4 — Patch within 90 days | P2 — Patch within 14 days |
The high-CVSS/low-EPSS quadrant is where CVSS alone sends you chasing ghosts. The low-CVSS/high-EPSS quadrant is where you find the real work: medium-severity flaws that are being actively exploited right now.
I then apply multipliers:
- CISA KEV status: ×1.5 on EPSS (binary boost — if it’s in KEV, it’s being exploited right now)
- External exposure: ×1.2 for internet-facing assets
- Public PoC available: ×1.3 on EPSS
- Asset criticality: weights the final score (critical assets push P2 → P1)
The result isn’t just “patch the highest CVSS first.” It’s a weighted priority that accounts for what’s actually happening in the wild.
EPSS in Action: The GitLab Case
CVE-2026-97229 landed on my desk last week. CVSS 9.1 — RCE in GitLab’s JWT signing key validation. CISA added it to KEV with a due date of November 1.
EPSS: 0.62, 88th percentile.
The CVSS alone put it in my “patch within 72 hours” bucket. The EPSS confirmed it — 88% of CVEs with this score get exploited within 30 days. The KEV status made it non-negotiable.
But here’s where EPSS changed my execution: instead of patching all 12 CVSS 8.0-9.0 items I had that week, I checked their EPSS scores. Nine of them were below 0.05. Three had EPSS above 0.30. I patched the three high-EPSS items first, then the CVSS 9.1 GitLab flaw, then handled the rest on schedule. The low-EPSS items held for 30 days without issues because they were internal, authenticated, and had no public PoC.
EPSS didn’t change the GitLab priority — it changed what I did about everything else.
How to Get Started
You don’t need a toolchain. The EPSS API is simple:
import requests
# Single CVE
resp = requests.get(
"https://api.first.org/data/v1/epss",
params={"cve": "CVE-2026-97229"}
)
data = resp.json()
print(data["data"][0]["epss"]) # 0.62
print(data["data"][0]["percentile"]) # 88th percentile
# Bulk — up to 50 CVEs per request
resp = requests.get(
"https://api.first.org/data/v1/epss",
params={"cve": ",".join(cve_list)}
)
For Tom’s setup on Oscar, I added EPSS checks to the daily CVE triage script:
- Fetch new CVEs from NVD (already running)
- Query EPSS for each CVE in the same batch
- Cross-reference with CISA KEV catalog
- Output prioritized list with CVSS + EPSS + KEV columns
The script lives in /home/tom/apps/vault-indexer/scripts/epss_triage.py and runs as part of the daily RSS watcher pipeline. Output goes to the same cron output directory where the security feed digest picks it up.
Limitations
EPSS is not perfect. It’s not a crystal ball — it’s a logistic regression model. Its accuracy improves with more exploitation data and degrades for:
- Brand-new CVEs: Default score starts around 0.005 and converges over 2-4 weeks as exploitation data accumulates. A CVE released today with no known exploitation will have a low EPSS until data flows in.
- Zero-days with targeted exploitation: If only one actor exploits a CVE and they don’t broadcast it, EPSS won’t know. The model is trained on public exploitation data, not on every attacker’s activity.
- Configuration-dependent exploitation: CVSS already handles this via the attack vector/complexity metrics. EPSS captures it in aggregate — if a CVE requires a rare configuration, the EPSS will be low because few instances are exploitable.
- The 30-day window: EPSS doesn’t tell you when in the next 30 days exploitation will happen. A score of 0.50 could mean exploitation happens on day 1 or day 29.
EPSS is one signal, not the signal. Use it alongside CVSS, KEV, asset context, and your own threat intelligence.
The Bottom Line
CVSS answers: “If this is exploited, how bad is it?” EPSS answers: “How likely is it to be exploited?”
Together, they answer: “Should I patch this before the others?”
In practice, I’ve found that EPSS changes my top-5 patch list about 40% of the time compared to CVSS-only ordering. The items that move up are usually medium-CVSS flaws in internet-facing services with public PoCs. The items that drop are critical-CVSS flaws in internal services with rare configurations.
If you’re doing vulnerability management and you’re only using CVSS, EPSS is the lowest-effort improvement you can make. Free API, daily updates, one field per CVE. Worth adding to every triage pipeline.
Further Reading
- FIRST EPSS Documentation — the spec and methodology
- EPSS API Reference — bulk and single-CVE queries
- EPSS Model Paper (2022) — technical details on the logistic regression model
- NVD API — CVE data source for triage
- CISA KEV Catalog — known exploited vulnerabilities