2026 · ACTIVE · QUESTION

CausalGuard

Model proposes. System tests. Evidence decides.

Python
FastAPI
SQLAlchemy
PostgreSQL
Prometheus
AMD ROCm / HIP
Docker

CausalGuard is a closed-loop pre-incident reliability and causal verification engine. It detects latent risk before visible symptoms using deterministic statistical change-points, constructs an auditable causal DAG, counterfactually simulates the outcome of acting versus not acting, and then actively tries to falsify its own hypothesis before recommending anything.

The architectural conviction is a distrust of fluent explanation. Traditional observability tells you what is happening. Traditional RCA tells you why it happened, afterwards. A naive LLM agent will tell you something plausible and wrong. CausalGuard is built so that the only claims that survive to an operator are the ones that a test could have killed and did not.

Problem

Cloud infrastructure fails slowly before it fails loudly. Table and index bloat, vacuum starvation from long transactions, stale planner statistics, silent replication lag — these degrade quietly for hours, then cross a threshold and become an outage.

Question

Observability answers "what is happening now". Root-cause analysis answers "why did it happen" after the fact. Can a system answer "what is about to happen" — and then prove its own answer wrong before an operator acts on it?

Approach

Refuse to let the language model be the authority. The model proposes a causal hypothesis; the system tests that hypothesis against telemetry invariants and in a throwaway database clone; only evidence that survives falsification reaches an operator. A naive LLM agent will confidently blame database CPU saturation during lock contention while CPU sits idle at 11% — the Verifier Agent exists to kill exactly that answer.

System

Open any stage to see what it does.

OBSERVE — Pluggable telemetry source — simulated, Prometheus, or a live PostgreSQL — with automatic fallback.

DETECT — Deterministic statistical change-points: CUSUM, EWMA, tuple-bloat ratios, replay lag, xmin-horizon age. Statistics, not vibes.

HYPOTHESIZE — Builds an auditable causal DAG that enforces temporal ordering and topology constraints, so a proposed cause cannot post-date its effect.

PREDICT — Counterfactual simulation of two futures: do nothing, versus a controlled intervention.

VERIFY — The Verifier Agent actively tries to disprove the hypothesis against telemetry invariants. Unsupported claims are struck before an operator sees them.

SANDBOX — Candidate fixes — VACUUM ANALYZE, pg_terminate_backend, REINDEX — run against a throwaway clone of the real database with layered safety guards, and the telemetry delta is measured.

RECOMMEND — Only an intervention that survived falsification and produced a measured improvement in the sandbox is recommended.

Demo

A scripted five-minute demo drives all five failure scenarios end to end. The web UI streams telemetry over a WebSocket with a polling fallback; the API ships OpenAPI docs, health and readiness probes, and Prometheus metrics.

Result

Offline RCAEval benchmark across 735 failure cases and 3 microservice architectures — the project reports 96.2% detection accuracy and 95.4% verification precision.
Reported average proactive lead time of 38.5 minutes, against 6.2 minutes for threshold alarms, on the same benchmark.
On AMD ROCm with FP8 quantization and AITER kernel fusion, the project reports 1.76× token throughput, 45% reduction in time-to-first-token, and 45% VRAM saving, at under 0.3% impact on diagnostic accuracy.
All five failure scenarios — bloat, lock contention, blocked vacuum, stale statistics, replication lag — are wired end to end in release 1.1.

96.2% detection accuracy — Reported by the project's own offline RCAEval benchmark run over 735 failure cases. Not independently replicated.

38.5 min average lead time — Same benchmark; compared against a 6.2-minute threshold-alarm baseline.

Lesson

Version 1.0 mocked the sandbox: pre and post metrics were fabricated fixtures. It demoed beautifully and it proved nothing. Rebuilding the sandbox against a real PostgreSQL clone is what turned a persuasive demo into a system with a claim. The mocked version was the more impressive-looking of the two.

Source

CausalGuard — repository ↗

Connected

Epistemic Guard — Connected through SYSTEMS and AI and RESEARCH.
ContextGuard — Both are AI and SYSTEMS work, and both are built with Python, FastAPI, Docker.
TeleFlow — Both are SYSTEMS and CLOUD work, and both are built with FastAPI, PostgreSQL, Docker.
CodeRelay — Connected through SYSTEMS and AI.