Vigilis

👁️ Vigilis

The QA gate for AI-written code.

It heals safe test drift, refuses real regressions , and signs every decision into an independent, verifiable receipt.

The problem

Tell any coding agent to *"make CI pass"* and the cheapest path to green is deleting the test that caught the bug. AI now writes and fixes tests on its own — so the only question that matters is: can you trust what it did?

Vigilis answers it. Point it at the Playwright, Cypress, or Selenium suite you already have. When a test breaks, it decides:

• Cosmetic drift (a renamed selector) → it heals the locator, re-runs to verify green, opens a PR.
• A real behaviour change (checkout total went from $49 to $0) → it refuses to touch the test, fails the gate, and surfaces the bug instead of burying it.

And every decision is sealed into a signed, offline-verifiable receipt by an independent notary — so a refusal is something you can *prove*, not just claim.

Self-healing is the wedge. Verifiable proof is the point.

Where teams point it: gate AI-written code · self-heal without hiding bugs · auditable test runs · audit-grade evidence for SOX / payment controls · agent-native (MCP). → see the use cases

See it refuse a real bug

The agent ran the spec, saw it fail, checked that the selectors were all correct, concluded the app's login was genuinely broken, and refused to heal — then sealed a receipt anyone can verify offline.

Quickstart

npm i -D vigilis                      # in your Playwright / Cypress / Selenium project

npx playwright install chromium # one-time, for browser automation export ANTHROPIC_API_KEY=sk-ant-... # a pay-as-you-go API key (not a Claude.ai subscription)

npx vigilis init # scaffold vigilis.config.json (auto-detects your framework) npx vigilis generate https://your-app.com --run # explore the app → write + run a real spec npx vigilis heal https://your-app.com --spec tests/login.spec.ts # heal drift → verify green → PR (refuses real bugs)

already have a suite running in CI? attest the run you just did — no API key, no secrets:

npx playwright test --reporter=json > report.json npx vigilis attest-run report.json --commit $GITHUB_SHA --exit-code $? npx vigilis verify .vigilis/attestation/qa-run-*.json # offline: chain intact, or broken at record #N

Runs in your CI on your own key + chromium. About 10¢ per run on the fast model (--model claude-haiku-4-5); Opus by default for quality.

Why it's different

Attestation is verifiable and auditable — it proves *what the agent did*, in order, unaltered. It does not claim the agent's judgement was correct. That honesty is the point: Vigilis improves signal, it doesn't hide failures.

Why a refusal is credible: no layer grades its own work. The actor (any agent) writes the code and tests; Vigilis judges the behaviour and gates the deploy; an independent notary (Treeship) signs the verdict. Vigilis never signs its own homework — which is what makes the proof worth anything to someone who doesn't already trust you.

Optional: alert on a refusal

On a real-bug refusal, Vigilis can post a Slack alert and file a deduplicated Linear ticket — each linking the signed receipt. Off by default; a no-op until you set SLACK_WEBHOOK_URL / LINEAR_API_KEY. See docs/REFUSAL-ACTIONS.md.

Drive it from Claude (MCP)

The same tools ship as an MCP server (vigilis-mcp, in the official MCP registry) — generate / triage / heal straight from Claude Desktop, Claude Code, or Cursor. Add it to your MCP client config:

{

"mcpServers": { "vigilis": { "command": "npx", "args": ["-y", "vigilis-mcp"], "env": { "ANTHROPIC_API_KEY": "sk-ant-..." } } } }

Full setup: docs/MCP.md.

Provenance receipts

Receipts work out of the box with zero secrets — no account, no API key, no network:

• `vigilis attest-run ` seals *any* test run (not just Vigilis's own) into a receipt: it hash-chains the Playwright report's digest, the commit SHA, and the runner's exit code into a tamper-evident bundle under .vigilis/attestation/. Drop it after your existing playwright test step in CI and every run leaves evidence.
• `vigilis heal` seals its whole triage-and-heal session the same way — every tool call and every decision, hash-chained in order.
• `vigilis verify ` re-walks the chain offline and reports *chain intact* or *broken at record #N*. Anyone holding the file can check it; editing or deleting any step breaks every hash after it.

When the Treeship CLI is present, heal receipts are additionally signed by an independent notary — verify with treeship verify last, or share the hosted URL. No hard dependency; --no-receipt to opt out. See docs/TREESHIP.md.

Local bundles are verifiable and auditable (they prove *what the agent did*, unaltered and in order — not that its judgment was correct); Treeship upgrades that to a signed, independently-notarized receipt.

Why I built this

I've spent my career in QA, and AI just rewrote the job: agents now write and fix tests on their own. Huge speed win — but it quietly breaks the one thing testing exists for. When an agent makes a red test green, did it *fix* the bug, or delete the test that caught it? At scale, nobody can check every change by hand.

So Vigilis isn't another self-healer — healing is becoming a commodity. It's the layer that decides honestly which failures to heal and which to refuse, and signs every call so you don't have to take its word for it.

The way I think about it: git is a ledger of your code; Vigilis is a ledger of your agent's decisions — proof you can hand to someone who doesn't already trust you.

— Piyush

How it's built

Vigilis defines its QA tools once and exposes them twice — as an MCP server and as a CLI — over one Claude agent loop:

                     ┌──────────────────────────────┐

│ core │ Anthropic Messages API + tool use │ Agent loop + Tool Registry │ browser · dom · fs · playwright · git └───────┬───────────────┬──────┘ ┌────────────▼──┐ ┌──▼───────────────┐ │ vigilis-mcp │ │ vigilis (CLI) │ │ MCP server │ │ npx vigilis ... │ │ (Claude) │ │ (used in CI) │ └───────────────┘ └──────────────────┘

The loop: Generate (explore a URL → write specs) → Triage (real-bug vs drift vs flake) → Heal (fix drift → verify green → PR, refuse real bugs). *Author* (plain-English intent → test plan) is on the roadmap.

Repo layout

vigilis/

├─ packages/ │ ├─ core/ # agent loop, tool registry, Claude client, prompts, refusal actions │ ├─ mcp/ # MCP server wrapping the registry │ └─ cli/ # the vigilis command (generate | triage | heal | attest-run | verify) ├─ apps/ │ ├─ sample-shop/ # Next.js demo target (login + products + cart, with seeded drift/bug toggles) │ ├─ cloud/ # governance cloud — org audit dashboard over signed receipts │ └─ web/ # landing page → vigilis.dev └─ tests/ # generated specs land here

Develop

pnpm install

cp .env.example .env # add ANTHROPIC_API_KEY pnpm build && pnpm test

Watch the full loop against the bundled demo app — see docs/DEMO.md.

Roadmap

• ✅ Generate · Triage · Heal (Playwright, Cypress & Selenium — all live-verified)
• ✅ GitHub Actions QA gate · signed provenance receipts · MCP server
• ✅ Refusal actions (Slack + Linear) · governance-cloud audit dashboard
• ✅ Zero-secret attestation: attest-run + verify — receipts for any test run, no keys
• 🚧 Author (intent → test plan) · broader agent-attestation surface

Credits

Provenance receipts are powered by [Treeship](https://www.treeship.dev) — the independent attestation primitive — and governed memory by ZMem, both built by Zerker Labs. Thanks to the Zerker Labs team for the trust primitives Vigilis stands on.

License

MIT © Piyush Pathak