Zyvor · incident compiler

Turn an outage into a reproducible test.

KAVIRA compiles captured production evidence into an isolated reproducer, one-factor experiments, and a repair package. The proposer lists explanations. Execution decides.

Try the live demo Run it yourself

Evidencecaptured, not replayed
Hypothesesproposed, never authoritative
Experimentchange one factor
Repair packagepatch + regression test

KAVIRA console: sign in, compile an example, then read the evidence, the experiment arms, and the repair package — Recorded against a real `kavira serve`. Click through the same console yourself.

Execution is the verdictA hypothesis is never a finding.

Exact replay is not claimedConditions are reconstructed, not replayed.

Local-firstOne static binary. No cloud, no agents.

Zero dependenciesGo standard library only.

One factor at a time

If the symptom does not reproduce, KAVIRA stops and says so. A repair package exists only when the repair held.

Six steps: read evidence, propose, run the original, stop if it does not reproduce, change one factor, write the package. Verdicts: repair_held, not_reproduced, repair_failed, unsupported.

Four verdicts, and what each one writes

The runner sets the verdict, not the proposer. Pick one:

The repair held

The original condition reproduced the symptom. With one factor changed, the repair arm held within the bound.

Writes a patch, regression_test.json, measurements, and reproduction steps.

$ kavira compile -f examples/oom.json -o repairs
wrote repairs/inc-oom-001
$ kavira test -f repairs/inc-oom-001/regression_test.json
regression held

The symptom did not reproduce

The captured condition ran and the symptom did not appear, so there is nothing to repair yet. KAVIRA stops instead of guessing.

Writes nothing. No repair package is invented.

$ kavira compile -f incident.json -o repairs
verdict not_reproduced: no package written

It reproduced, but the repair did not hold

The symptom reproduced, then the repair arm failed the bound. A repair that execution did not confirm is not offered.

Writes nothing. The experiments show which arm failed and how.

$ kavira compile -f incident.json -o repairs
verdict repair_failed: no package written

Outside the three v0 classes

Container OOM, network timeout, and configuration regression are supported. Anything else is reported as unsupported rather than approximated.

Writes nothing, and says why.

$ kavira compile -f incident.json -o repairs
verdict unsupported: no package written

Three incident classes in v0

Incident	Experiment	Repair check
Container OOM	Bounded workload under the captured memory limit	Failures, memory, latency bound
Network timeout	Selected delay, loss, or policy on a local listener	Recovery and connectivity
Configuration regression	Previous and current configs, same workload	Behavior diff and a regression test

A console that shows its work

Evidence, every experiment arm, and the repair package, with copy and download. Light, dark, and 390px. Open the live demo: it is the real console, running on precompiled results.

Repairs page with patch, regression test, and reproduce steps, light

Repairs page with patch, regression test, and reproduce steps, dark

Quickstart

git clone https://github.com/zyvorai/kavira.git && cd kavira
make check
./bin/kavira compile -f examples/oom.json -o repairs
./bin/kavira test -f repairs/inc-oom-001/regression_test.json
./bin/kavira serve        # http://127.0.0.1:8080

The console listens on http://127.0.0.1:8080. The demo login (admin / Admin@321) exists only until you set KAVIRA_ADMIN_PASSWORD. Set it, and KAVIRA_SESSION_KEY, and serve HTTPS (-tls-cert/-tls-key, or -tls-self-signed DIR for a lab) before exposing it.

docker build -t kavira .
docker run --rm -p 8080:8080 \
  -e KAVIRA_ADMIN_PASSWORD='choose-a-long-one' \
  -e KAVIRA_SESSION_KEY="$(openssl rand -hex 32)" kavira

What it does not claim

KAVIRA reconstructs conditions, measures one factor, and lets execution decide. It does not replay production, sample loss at random, approve production changes, or invent a repair.