Try Cairn on your own app — locally, no clone.
One command runs the whole Cairn stack on your machine, pointed at your own repo and localhost — no clone, no login, no cloud. Map flows, generate Playwright tests, and run them right in your dev loop.
Your E2E feedback lives after the push, not in your loop.
Cairn's cloud runs on your pull requests and on a schedule — exactly where regression coverage belongs. But while you're actively building, that feedback is a push away: you commit, open a PR, and wait to learn whether you just broke the checkout flow.
The tightest place to catch a broken user journey is while you're still editing the code— the same loop where you already run your dev server. That's what local dev mode is for.
No clone — just run it in your own app.
You don't clone Cairn, you run it. From the folder of the app you want to test, one command spins up the whole stack against your localhost — no GitHub, no login, no cloud.
From the repo you want to test, with your dev server running:
export GOOGLE_GENERATIVE_AI_API_KEY=AIza...
npx cairn-dev dev --target http://localhost:3000Cairn provisions a local database, seeds the repo, and opens a dashboard at localhost/local. Contributors working inside a Cairn checkout can use pnpm cairn dev instead. Ctrl+C tears the whole stack down.
The full loop, on your machine.
Point it at your repo
Run one command from the repo you're building. Cairn reads your source straight from disk — no GitHub App, no login, no config file to maintain.
Map + generate
Cairn maps your user flows from the local source and generates self-contained Playwright tests for them, streaming into a dashboard on your machine.
Run against localhost
Tests execute against your --target dev server in a real browser, with video and trace — the exact runner the cloud product uses.
Watch as you edit
Save a file and Cairn instantly flags the flows your change affects, so you know what to re-check while you're still in the code — a free, no-LLM signal.
A live E2E watcher for your dev loop.
The same engine as the cloud, pointed at a local repo and your localhost — so you catch broken journeys before you push.
The same engine, local
Mapping, test generation, the Playwright runner, and the dashboard — the exact cloud engine, run on your machine against a local repo.
A watcher for your loop
Save a file and Cairn flags the flows your edit affects — instantly, and without an LLM call, right while you code.
Runs against your localhost
Generated tests run against your dev server with video and trace, so you see the exact browser step that broke — no push required.
Local mode never touches GitHub, so the GitHub-only features degrade gracefully — issues are recorded in the local dashboard instead of filed, and auto-fix PRs are off. Everything else is the product you already know, running where you write the code.
Frequently asked questions
No. Local mode reads your repo from disk and bypasses login and the GitHub App entirely — it never talks to GitHub or the cloud. It's the same engine, pointed at a local repo and your localhost dev server.
Node, Docker running (or your own DATABASE_URL), and a Gemini API key for mapping and test generation. Point it at your running dev server with --target, and Cairn provisions the database, seeds the repo, and opens a local dashboard.
It's the same engine — flow mapping, test generation, the Playwright runner, and the dashboard — run on your machine against a local repo and localhost, instead of on GitHub PRs and a schedule. GitHub-only features (filing issues, auto-fix PRs) are gracefully turned off.
Yes — npx cairn-dev runs the whole stack from published Docker images, no clone required. Contributors working inside a checkout can use pnpm cairn dev.
Explore more of Cairn
Put your tests on autopilot.
Connect a repo and watch Cairn map your flows, write the tests, and run them on every PR — in minutes.