Autonomous SRE · MAPE-K

Incidents that
fix themselves.

GhostOps detects a failure, diagnoses its root cause, writes the patch, proves it in a sandbox — and hands you a pull request. Monitoring that finally closes the loop.

Trigger a live incidentView the code
17
catalogued failure types
4
fixed end-to-end
6
automated safety gates
0
unreviewed production merges
B1 memory leak → bounded cache → sandbox ✓C4 CI failure → operator fixed → PR openedA1 null reference → guard added → 3/3 testsOPA policy gate: path-traversal blockedHuman gate: GhostOps never merges its own PRsB1 memory leak → bounded cache → sandbox ✓C4 CI failure → operator fixed → PR openedA1 null reference → guard added → 3/3 testsOPA policy gate: path-traversal blockedHuman gate: GhostOps never merges its own PRs
// Live pipeline

Watch an incident get fixed.

Pick a scenario and trigger it. The backend runs the real pipeline — OPA policy check and Docker sandbox included — and streams every stage here as it happens.

loading scene…

1 · Diagnosis

pending

Waiting for this stage…

2 · Patch

pending

Waiting for this stage…

3 · Validation — OPA policy + Docker sandbox

pending

Waiting for this stage…

4 · Pull request

pending

Waiting for this stage…

Only low-risk fixes are auto-merged, and only into staging; the kill switch stops all of it.

// Architecture

Monitor. Analyze. Plan. Execute. Learn.

Built on the MAPE-K autonomic-computing loop, with three independent gates between an AI-written patch and your main branch.

  1. M01

    Monitor

    Prometheus scrapes the cluster; Alertmanager fires a webhook the moment a rule breaches.

    Prometheus · Alertmanager

  2. A02

    Analyze

    The backend enriches the alert with pod logs and metric history; the Diagnostic Reasoner cites the evidence.

    FastAPI · Claude

  3. P03

    Plan

    The Patch Generator writes the smallest diff that fixes only the diagnosed cause — never the tests.

    CrewAI · unified diff

  4. E04

    Execute

    OPA checks the patch's target, then pytest runs it in a throwaway, network-less container.

    OPA/Gatekeeper · Docker

  5. K05

    Knowledge

    Every run, pass or fail, is stored and fed back to ground future diagnoses.

    SQLite · Grafana · Jaeger

1
Policy gate

Patches may only touch allow-listed paths; manifests need limits and can't be privileged.

2
Blast-radius gate

Rejects patches that are too big, weaken tests, add dependencies, touch secrets, or add eval, shell or network calls.

3
Sandbox gate

The real test suite passes in an isolated container, plus a new regression test that fails before the fix and passes after.

4
Replay & canary

The incident's real traffic is replayed against the fix, then a canary pod proves it on the cluster.

5
Risk-based autonomy

Low risk auto-merges to staging, medium opens a PR, high pages a human. Every step is signed and audited.

6
Human & kill switch

Production stays under human control: one switch pauses every automatic action.

// Impact

Every run, on the record.

Read straight from the GhostOps knowledge base.

Incidents handled
0
every run is logged, pass or fail
Validation pass rate
0.0%
OPA policy + sandboxed tests
Pull requests
0
opened for human review
Blocked by gates
0
bad patches that never reached anyone
Daily outcomespassedfailed

No incidents yet — trigger one above.

Human review of GhostOps' PRs
—accepted (merged ÷ merged + rejected)
0 merged0 awaiting review0 rejected0 duplicatesnever synced

Every new diagnosis is given past incidents together with what the reviewer did with their fix. Label a PR duplicate on GitHub to keep it out of the rate.

// Production

Fixed means healthy in production.

Deployed fixes are watched on the same signal that fired the alert, attacked with chaos before they count, and every real incident is priced.

MTTR — alert → verified healthy
—
median over 0 verified fix(es) · p90 —
no verified fixes yet
Incident cost meter
$0
cost of 0 real incident(s)
$0
saved vs manual repair
Watched in production

Deployed fixes are watched here: the same Prometheus signal, for a window, before they count as resolved.

// Trust

Every decision, on a tamper-evident record.

What GhostOps decided and why, chained by hashes; how alerts were grouped; and the fixes it learned from people.

Every decision GhostOps makes is recorded here, each entry hashing the one before it.

// Coverage

Seventeen ways production breaks.

The full use-case catalogue — application logs, system metrics and deployment behaviour — with what GhostOps detects and fixes today.

Start the backend to load the use-case catalogue.

// Detector lab

Throw telemetry at it.

Sixteen deterministic detectors run before any LLM is involved. Try a preset or paste your own logs.

Pick a scenario. These detectors are deterministic Python — no LLM, no API key.
// Knowledge base

Recent incidents.

Click one to see the exact patch GhostOps produced.

The knowledge base is empty — every run you trigger lands here.