Inspiration
92,205 vulnerabilities (CVEs) have been published in 2026 so far, more than double all of 2024, and fewer than 1 in 250 is ever confirmed exploited. Most teams still fix the highest severity score (CVSS) first. But severity says how bad an attack could be, not whether anyone will attack. We wanted to predict which vulnerabilities attackers will actually use, and show engineers what to fix first and why.
What it does
Hunch ranks vulnerabilities by how likely they are to land on CISA's Known Exploited Vulnerabilities list (KEV), and turns that ranking into a to-do list for one company's software.
- Your software: upload a software bill of materials (SBOM, CycloneDX JSON or XML). We match every component to its known vulnerabilities, including the ones NIST hasn't reviewed yet, and show each component's risk: CVE count, severity mix, KEV entries, the version that fixes it, and the top 3 CVEs. You can compare two components side by side, ask why something is ranked where it is, and download the results as CSV.
- Fix first queue: every matched vulnerability, ranked. KEV entries come first, then our model's score. Each row shows:
- a warning sign: public exploit code appeared that month, another bug in the same product was just added to KEV, or the EPSS score jumped
- why it ranks here: the top 3 reasons from the model (SHAP), a plain-English explanation (written by IBM Granite for the top rows), and where CVSS alone would have ranked it next to where we rank it
- a status (to do, in progress, done) and a one-click Push to Linear that creates the ticket
- filters for critical items, items not yet in Linear and items with warning signs, plus search and sort by CVSS
- Insights: what predicts an attack across the whole benchmark:
- Summary: how much our top 500 catches, KEV rate by severity band and by weakness type
- Model overview: the catch-rate curve against the three standard rankings, which you can hover to read off any queue size, and a map of Granite description embeddings where exploited CVEs cluster
- Vendors: which vendors carry most of the exploitation
- Light and dark mode throughout.
How we built it
- Time-machine backtest. We rebuilt the benchmark for 2024 and 2025: each vulnerability is scored using only what was known at the end of its publish month, and labelled by whether it reached KEV by November 4 of that year (27 positives in 2024, 48 in 2025). We train on 2024 and test on 2025, check the reverse direction for robustness, and score hits in the top K, where K keeps the benchmark's pick rate (500 of 72,670, so K = 243 for 2025). Every model result is a 5-seed mean. Nothing was tuned on 2026.
- 35 point-in-time features in six groups:
- signals: EPSS percentile within the month, plus public exploit code from Exploit-DB, Metasploit, Nuclei and GitHub
- assigner history: how often the organization that published the CVE has had CVEs reach KEV
- severity and weakness type: CVSS metrics, only when supplied by the vendor rather than NIST, and the CWE
- keywords: 11 description flags such as "unauthenticated" or "remote code execution"
- Granite similarity to past KEV entries
- exposure time
- Model. A LightGBM model with monotone constraints (a higher EPSS or an exploit flag can only raise the score), rank-blended 25/75 with a simple "safety ranker" (EPSS percentile + exploit code). We chose it with a selection rule we fixed before comparing: a new variant replaces the submission only if it wins clearly in both test directions. That rule also kept us from swapping in variants that only looked better by noise.
- IBM Granite:
granite-embedding-small-english-r2embeds every description. Similarity to KEV entries added up to the snapshot month is a model feature, and is worth 3.6 extra hits in the top 500.granite-4-h-smallon watsonx.ai writes the plain-English explanations. It can also double-check SBOM matches made from descriptions only. We benchmarked this check on 40 known true and false pairs.
- Matching the unreviewed 51,046. NIST hasn't reviewed most 2026 CVEs, so they have no product list. We match SBOM components against the description instead (product name early in the text, vendor present, add-on and plugin bugs skipped). These matches are labelled "version unverified".
- Live freshness: optional re-ranking with today's EPSS from the FIRST API, and every score shows the month it describes.
- The TigerData Golden Baseline (Engine Block). Instead of scattering loose files across laptops, our entire platform is anchored by a managed Tiger Data cloud instance that serves as our immutable single source of truth. It acts as our architectural spine, strictly enforcing point-in-time boundaries directly at the data level so our model only learns from signals observable before weaponization[cite: 26]. This boundary prevents temporal leakage, protects real-world precision, and powers sub-second threat similarity searches. For our team, hosting this baseline in the cloud simplified everything: anyone can run fast SQL queries, execute tamper-proof backtests on demand without data contamination, and feed live triage queues directly to the dashboard.
- Stack: DuckDB, Polars and pandas for data; LightGBM, scikit-learn and SHAP for modeling; Granite through sentence-transformers and watsonx.ai; TigerData (TimescaleDB + pgvector) for the operational engine block and vector store; a FastAPI backend; React, Vite, Tailwind and ApexCharts for the frontend; the Linear API for tickets.
Data we used (and didn't)
All 8 provided files, plus live EPSS from FIRST in the app (not in the submission). We left out every column the brief flags as leaky:
nvd_status,n_affected_cpesandn_references- everything from
references.csv - NIST-supplied CVSS scores
last_modified
We also used the EPSS percentile instead of the raw score, because EPSS changed models in March 2025 and raw scores shift between years.
Challenges we ran into
- The data knows the future. The NIST files are today's versions, and NIST reviews exploited vulnerabilities first: 100% of exploited CVEs in our backtest are "Analyzed" today, against 42–50% of the rest. We blocked those columns and trained a cheater model with them to measure the leak. It nearly doubles the score (19.6 hits vs 10.2), a gain that can't hold for 2026. Our submission script refuses scores from any model that saw them.
- Very few positives. 27 and 48 exploited CVEs per year, so one random seed can swing results by about ±3 hits. We report 5-seed means with min and max.
- Our first model didn't win. LightGBM alone beat the baselines deeper in the list but not at the benchmark's pick rate. Monotone constraints and the blend fixed that, and we kept the losing results in our model card.
- Gaps: the KEV list ends in December 2025, there's no signal data for June 2026, and most 2026 CVEs have no product list.
Accomplishments that we're proud of
- Backtest on 2025, at the benchmark's pick rate: our ranking catches 15.4 exploited CVEs, against 13 for exploit code + EPSS, the best standard ranking, and 8 for CVSS-first and for EPSS-first. That's about 32% of 2025's exploited CVEs from 0.7% of the list. It also wins in the time-reversed check (8.6 vs 6).
- Our top 500 for 2026 is submitted; judges score it against KEV additions through November 4.
- A measured leakage audit, documented in a model card with every result, including the ones that didn't work.
- A working path from SBOM upload to ranked queue to Linear ticket, with a reason for every rank.
What we learned
- Building an honest time boundary: A model is only as credible as its training rules. By enforcing strict historical cutoffs directly inside our cloud database, our team could run experiments and queries freely, knowing the data foundation made it impossible for future exploit events to contaminate our results.
- Severity is a poor predictor of attacks: Fresh threat signals (exploit code, EPSS percentile) matter most: removing them costs 8 of 18 hits in the top 500.
- Assigner reputation matters: Who publishes the vulnerability matters a lot too: removing assigner history costs 4.6 hits.
- Granite's text similarity bridges data gaps: Semantic embeddings surface critical signals from vulnerability descriptions that structured tabular fields miss entirely.
- Stopping future leakage is paramount: Not letting the model see the future was the hardest part, and the single biggest factor in making sure predictions hold up in production.
What's next for Hunch
- Real early-warning alerts when a component's risk jumps; today the warning signs show in the queue only.
- Re-score every vulnerability live each month as new signal data arrives.
- Plug into IBM Concert Protect and add IBM X-Force threat intelligence.
- Let Granite answer free-form "why is this ranked here?" questions; today "Ask why" answers a set of suggested questions from the facts on screen.
Built With
- duckdb
- fastapi
- figma
- huggingface
- ibmgranite
- lightgbm
- pgvector
- polars
- postgresql
- python
- react
- shap
- tailwind
- tigerdata
- timescaledb
- vite

