E2E tests
that run themselves.
Connect your GitHub repo. Cairn maps every user flow, generates Playwright tests, runs them on a schedule, files GitHub issues when something breaks, and lets Claude write the fix and open a PR.
You don't own your release cadence. Your test suite does.
Tests rot faster than code ships
Every UI change breaks a selector. Engineers stop trusting the suite, the suite stops catching bugs, and users hit them first.
Writing Playwright costs you afternoons
Each flow takes an hour to write and another to stop it flaking. So the next release ships with no new tests — no one has time.
AI ships faster than you can test it
Agentic coding merges changes in minutes — but the tests don't follow. Untested paths reach prod, and the first to hit the bug is a real user.
Debugging a failure is its own sprint
A failed run means reproducing it locally, reading the trace, writing the fix, then updating the test — days gone for every bug.
We kept forgetting to test.
We're a small team, and like everyone now, more of our code is written with AI. More changes, merged faster — and somehow, less testing. We'd promise to check the critical flows after a big change, then forget. And running the suite by hand every few hours is exhausting, so nobody does it consistently. The bug ships, and a real user finds it first.
So we built the thing we wished existed: connect a repo, and Cairn maps the flows, writes the Playwright tests, keeps them in sync on every push, and runs them on a schedule and on every merge — so the testing happens whether we remember or not. When something breaks, it tells us why and opens the fix.
We're open-sourcing it because every team shipping with AI has this exact gap.
— The Cairn team
From repo to merged fix.
Map and generate once. Then, on every push, Cairn resyncs the suite, runs it, catches the regression, and ships the fix. Green builds — without writing the tests or the fixes.
Connect
Install Cairn on a repo. It reads your routes, components, and code evidence automatically — no test code to write.
Map
Cairn reads every page and surfaces the real user flows — sign-in, checkout, settings.
Generate
Each flow becomes a full spec — selectors, assertions, and session auth, in TypeScript.
Sync
Every push to main or staging, Cairn diffs the change, updates affected tests, and writes specs for newly detected flows.
Run
Runs on a cadence and on every merge in real Chromium — video and a trace captured each time.
Fix
Failures become issues. Claude triages and opens a merge-ready PR when the cause is clear.
The whole loop, playing live.
Every tab is the real product — the file explorer, the Cairn assistant, flows that rewrite themselves on each push, suite runs, the Claude fix loop, security recon, and API drift. Hover to pause.
It watches your APIs, not just your screens.
A UI breaks because something underneath it changed. Cairn fingerprints the contract of every API your flows touch and watches it for drift — so a failure comes with the backend reason, not just a red X.
Capture
On every run, Cairn records each request and response your flows make — internal APIs and third parties alike.
Fingerprint
Each response is distilled to a structural contract — fields, types, status. Values are stripped, so normal variance never reads as a change.
Watch for drift
Every run is compared to the last-green baseline. A breaking change is flagged — and tied to the UI failure it caused.
status changed type and declineReason was dropped — a breaking change. Cairn ties it to the checkout flow that failed on it.
See the issue this becameIt tells you what broke — and why.
A failure isn't a red X. Cairn reads the network layer, finds the call that failed, sees the contract that changed, and files the report an engineer would write after a day of debugging. Click any line to see how it knew.
Checkout — “card declined” never clears on a valid card
On /checkout, a valid card still shows “Card declined” and the Pay button stays disabled — the purchase can't complete.
UI showed an error state, and exactly one non-2xx call sits in the network log. Cairn leads the diagnosis with the call, not the Playwright assertion.
Claude writes the PR.
You just hit merge.
When a Playwright test fails, Cairn captures the trace and console output, feeds it to Claude, and opens a minimal fix PR straight to your repo.
$ captured: dom snapshot, trace, console logs, network har
$ analyzing selector resolution against React tree...
$ generating patch via Claude Opus...
Built for the way you actually ship.
GitHub-native
Install as a GitHub App. Cairn reads your code, files issues when tests fail, and opens fix PRs — no CI config required.
Framework-aware mapping
Reads your pages, layouts, and API routes — Next.js, Remix, SvelteKit, Astro — to derive real user flows from actual code, not guesses.
Real browser execution
Chromium via Playwright. Every run captures video and a trace, so you can replay the exact sequence when something fails.
Branch-aware sync
On every push to main or staging, Cairn detects the affected flows, updates their tests, and writes new specs for new pages — tests never drift from the code.
API contract tracking
Cairn fingerprints every API response your flows touch and watches for breaking drift — so it names the failing call behind a UI break, not just the red X.
Security recon
A deterministic pass probes each deploy for exposed files, source maps, leaked storage, and access-control gaps — findings filed by severity.
Scheduled + post-merge runs
Run suites on cadence — every 20 minutes to weekly — and automatically after every merge. Catch regressions the moment they land.
Claude Fix loop
Failures become classified issues (bug, test-bug, timeout, infra). For real bugs, Claude triages the root cause, writes the patch, and opens a PR.
Weekly recap
A Monday digest of what Cairn observed — pass-rate trend, regressions caught, auto-fix rate, new exposures, API drift — emailed to your team.
Self-host it, or let us run it.
Cairn is open source under AGPL-3.0 — read it, audit it, fork it, and run it on your own infrastructure. Or skip the setup and use the managed cloud. Either way, the product is the same.
Managed cloud
Connect a repo and go — we run everything.
- Maps your user flows from the repo, automatically
- Generates Playwright tests, kept in sync on every merge
- Runs the suite on every merge and on a schedule
- Re-runs just the flows a merge touched
- Records video + a full Playwright trace for every run
- Files root-caused GitHub issues — flaky noise filtered out
- Drafts auto-fix pull requests with Claude
- Tracks API contract drift and names the changed field
- Scans for leaked secrets and exposed surface
- Hosted runners with Chromium, Firefox & WebKit
- Artifact storage for videos and traces
- Scheduling, automatic retries, and concurrency
- One-click GitHub App + the full dashboard
- Automatic updates, monitoring, and support
Self-hosted
Run it on your own infra.
- The same full feature set as the managed cloud
- Your data never leaves your environment
- Bring your own model and provider keys
- Free vela-cairn package to track your backend's API contracts
- Run it on your own infrastructure
- Open source (AGPL-3.0) — read, audit, fork, run
Your code stays yours. Cairn never trains models on your private code.
Stop writing tests.
Start shipping confidence.
> Installing Cairn on your repo...
> Mapping flows, generating tests, watching your APIs...
> Running on every push — failures become fix PRs.
> Awaiting your authorization.