We tried to predict Kubernetes failures before they happen. Here is every result, including the losses.

Selim Benfradj · November 17, 2026

TL;DR - Ruptura is an open source engine (Apache 2.0) that forecasts Kubernetes and OpenShift failures and gives an estimated time of failure. - We compared it with what most teams already run: Prometheus predict_linear alert rules. - Every test was written down before its data existed. Losses are published like wins. - Headline: on a replica that leaks while its siblings stay healthy, Ruptura warned 8 minutes after the leak started and 57 minutes before the crash, against 30 minutes for predict_linear, with 0 false alarms. - Memory failures over 12 hours: Ruptura warned on 65 of 73 leak cycles with a median lead of 15.4 minutes, against 38 of 73 and 7.0 minutes for the quiet predict_linear setting, with 0 false alarms on its trend forecasts, and on 14 of 14 periodic spikes no trend rule saw. - Where it lost: a bad release that leaks fast (the rule warned earlier), two of six detection faults named under the wrong failure mode, and more findings than the rules on healthy workloads (real CPU throttling, but more of it).

Why this test

Every observability vendor says "predictive". Few show the numbers, and almost none show them against the free baseline a team already has. So we set ourselves one rule: Ruptura must beat a well-tuned predict_linear rule on the same cluster, the same faults, the same window, or we say it does not.

The setup

Scripts, rules and raw outputs: https://github.com/benfradjselim/ruptura/tree/main/benchmark (scripts published on 14 November, before the main benchmark day, byte-identical to the frozen versions).

Results

1. Memory failures, 12 hours (part A)

Contestant Trend leaks warned Median fresh lead Periodic spike False episodes
predict_linear 30m/30m 38 of 73 7.0 min 0 of 14 0
predict_linear 10m/30m 73 of 73 21.5 min 0 of 14 67 (61 on a healthy batch job)
Ruptura, trend forecasts only 65 of 73 15.4 min 0 of 14 0
Ruptura with its failure memory 73 of 73 18.3 min 14 of 14 2

Verdict against the criteria written in advance: C1 pass (as many cycles and at least 5 min more lead than the quiet rule), C2 pass (at most half the false episodes of the fast rule, at most 2 more than the quiet one), C3 pass (at least 60 % of periodic spikes).

For an SRE: the quiet rule is calm but late, the fast rule is early but cries wolf 67 times in 12 hours on a healthy job. Ruptura sits where you want to be: earlier than the quiet rule, as calm, and it is the only one that sees a failure that comes back on a schedule. The fast rule still leads on plain trends; we say so.

2. A replica that diverges from its siblings (part F1, run 2026-11-13)

Three replicas, one starts leaking, three rounds.

Ruptura predict_linear (both settings)
Warned after leak start 7.6 to 8.1 min 34.5 to 35.5 min
Median lead before the OOM kill 57.2 min 29.8 min
Named the leaking pod 3 of 3 per-pod rule
False alarms 0 fired on 3 calm pods

Why: Ruptura compares each pod with its own replicas, so a pod that grows while its siblings stay flat stands out long before it nears its limit. A trend on one series cannot see that. The same test run on Nov 4 gave the same picture (57.8 against 30.4 min).

3. A bad release (part F2)

A new version that leaks, rolled out beside a healthy version and a heavier but stable one, three rounds (run 2026-11-14). Ruptura lost this one on 2 of its 3 criteria.

Ruptura predict_linear (both settings)
Warned after the bad rollout 11.2 to 12.2 min (criterion: within 15 min, met) 1 to 2 min
Median lead before the OOM kill 55.2 min 64.8 min
False warnings about 14 min of false warnings (heavy rollouts, rollbacks) fired on 32 to 38 healthy pods

What it means: a trend rule reacts to every new version's warm-up, so on a bad release it is first, and it is also wrong on almost every healthy rollout. Ruptura waits for evidence and catches the bad release within 12 minutes, but it was later than the rule here, and it still raised false warnings on the heavy version's warm-up and during rollbacks. Both are on our list.

4. Detection, 6 faults x 3 rounds (part B)

Fault Ruptura median Rule median Expected mode 3 of 3
crash loop 35 s 1093 s yes
image not found 34 s 968 s yes
missing mount 18 s 968 s yes
replicas unavailable 1223 s 968 s no (listed as startup_stuck; loss stated before the run)
CPU throttling 742 s 1015 s yes
OOM kill 192 s 667 s no (flagged 8 min earlier, but as crash_loop or replicas_unavailable)
stuck rollout 16 to 123 s after Kubernetes marks it yes, 4 of 4 criteria

5. Quiet, cost and setup (parts C, D, E)

Where Ruptura lost, and what we are doing about it

Known limits we stated before the runs: - The lab's faults are regular, which flatters the failure memory. Real clusters are noisier. - The OOM rule has no for delay, so on OOM kill the best Ruptura can do is a tie. - 99 of 125 pods on this lab have no memory limit. Forecasting against a limit cannot cover them yet; node memory pressure is next on the roadmap.

Try it on your cluster

If you run it and it misses a failure, open an issue with what happened. That is the most useful thing you can send us. We are also looking for a few teams who want to run it on real clusters with us: become an early adopter.

We will present this live at Red Hat Summit Paris on 24 November.

Try Ruptura
Open source, for Kubernetes and OpenShift. getruptura.dev · ★ GitHub