Test your app
in plain English.
Writing E2E tests is tedious. Maintaining them when the UI shifts is worse. Assrt crawls your app, writes the Playwright tests for you, and re-locates selectors when the DOM moves. Open source. Runs in your own CI.
No API key. No credit card. View source on GitHub
Demo
See it in action
Watch Assrt discover test scenarios, generate Playwright tests, and handle real world edge cases automatically.
Works with your stack
Features
Testing that thinks
like an engineer.
Assrt combines LLM reasoning with Playwright's reliability. It explores your app, writes tests that exercise the real flows, and patches them when the UI shifts.
Auto-Discovery
Point Assrt at a URL and it crawls your app like a real user, reading the accessibility tree, following navigation, mapping forms, and turning auth and CRUD paths into a scenario list you can edit.
Vision plus a11y-tree analysis, so it reasons about UI semantics, not just DOM structure.
Natural Language Tests
Write tests like "Log in, add three items to cart, apply discount code SUMMER, verify total is 15% off." Assrt translates them into deterministic Playwright code you own forever.
TypeScript Playwright files. Not YAML wrappers, not a proprietary format. Code you can read, diff, and ship.
Self-Healing
When the checkout button moves from the header to a sticky footer, your test does not break. Assrt re-locates elements by intent and accessible role, not by brittle CSS selectors.
Heals across selectors, timing, test data, visual drift, and interaction changes, with each patch logged so you can review it.
Visual Regression
Catch the pixel-level regressions that unit tests miss. Assrt snapshots critical viewports and diffs with perceptual hashing, so anti-aliasing and cursor-blink noise stop flagging every render.
Tunable diff thresholds per viewport, not all-or-nothing exact-pixel snapshots.
Zero Lock-in
Every test Assrt generates is a standard Playwright file in your repo. Eject any time. Run with npx playwright test. No proprietary runtime, no cloud dependency, no API key required to run your suite.
Your tests keep working with Assrt uninstalled. That is the point.
Parallel Across Browsers
Run your suite in parallel across Chromium, Firefox, and WebKit. Shard locally across CPU cores or fan out across CI containers, using the same Playwright config you already know.
All three engines, not Chrome-only. No extra runner to install.
How It Works
Four commands.
Complete test coverage.
Point it at your app
Assrt crawls your application like a real user. It reads the accessibility tree, follows navigation patterns, identifies forms, and maps every meaningful user flow. No manual sitemap needed.
$ assrt discover https://your-app.com
Crawling... analyzing 142 pages
Mapping user flows from navigation + forms
Detecting auth patterns, CRUD operations, edge casesReview generated tests
Every generated test is real Playwright TypeScript. Not YAML that needs a proprietary interpreter. Not pseudo-code. Production-grade test files with proper selectors, assertions, and error handling.
// tests/checkout.spec.ts (auto-generated)
import { test, expect } from '@playwright/test';
test('complete checkout with discount code', async ({ page }) => {
await page.goto('/products');
await page.getByRole('button', { name: 'Add to cart' }).first().click();
await page.getByRole('link', { name: 'Cart' }).click();
await page.getByPlaceholder('Discount code').fill('SUMMER');
await page.getByRole('button', { name: 'Apply' }).click();
await expect(page.getByTestId('discount-badge')).toBeVisible();
await expect(page.getByTestId('total')).toContainText('$');
});Describe new tests in English
For specific scenarios, just describe what you want in natural language. Assrt understands your app's structure from the discovery phase and generates tests that use the right selectors and navigation paths.
$ assrt generate "
Log in as admin user.
Navigate to Settings > Team.
Invite a new member with email test@acme.co.
Verify the invitation appears in the pending list.
Revoke the invitation.
Verify it disappears.
"
Generated: tests/team-invitation-lifecycle.spec.ts ✓Run everywhere, heal automatically
Tests run with standard npx playwright test. When a selector breaks because your UI changed, Assrt patches it automatically in the background and opens a PR with the fix. Zero maintenance.
$ npx playwright test
Running 47 tests across 3 browsers...
✓ login.spec.ts (3 tests) .................. 2.1s
✓ checkout.spec.ts (8 tests) ............... 4.3s
✓ settings.spec.ts (5 tests) ............... 3.0s
⟳ profile.spec.ts healed 1 selector ..... 2.8s
✓ search.spec.ts (4 tests) ................. 1.9s
47 passed | 0 failed | 1 self-healedComparison
What you get
vs. what they charge for.
Momentic locks you in with proprietary YAML. QA Wolf charges $90K/year for engineers to write your tests. Playwright gives you power but no AI. Assrt gives you everything.
| Feature | Assrt | Momentic | QA Wolf | Playwright |
|---|---|---|---|---|
| Natural language tests | ||||
| Generates real Playwright code | ||||
| Self-healing selectors | ||||
| Auto-discovery of test scenarios | ||||
| Open source | ||||
| Self-hosted / offline | ||||
| All browsers (Chromium, FF, WebKit) | ||||
| No vendor lock-in | ||||
| Visual regression testing | ||||
| CI/CD integration | ||||
| Free |
Architecture
No black boxes.
You own every layer.
Assrt sits between your app and Playwright. It adds intelligence to test generation and maintenance while keeping the execution path completely standard and open.
Your App
Any web application
Assrt Discovery Engine
Vision + Accessibility Tree + NLP
Test Generator
Natural Language → Playwright TypeScript
Self-Healing Agent
Selector repair + PR automation
Playwright Runtime
Chromium · Firefox · WebKit
Your CI/CD
GitHub Actions · GitLab · Jenkins · Any
Local-first AI
Assrt runs inference locally using quantized models or connects to your preferred LLM provider (OpenAI, Anthropic, Ollama). Your app never touches our servers.
Deterministic output
AI generates the test once. After that, it's static Playwright code (no AI in the loop at runtime). Your tests are as reliable as hand-written ones.
Git-native workflow
Tests live in your repo. Self-healing changes come as PRs. Discovery reports are markdown files. Everything is reviewable, diffable, revertible.
Progressive adoption
Start with discovery to audit your existing coverage. Add AI-generated tests alongside your manual ones. Adopt self-healing when you're ready. No big bang migration.
Pricing
Free to start.
Free to stay.
The open-source version is the real product, not a teaser. Cloud adds convenience for teams. Enterprise adds compliance.
Open Source
Everything you need to test your app with AI. No limits, no tricks.
- Unlimited test generation
- Auto-discovery of user flows
- Self-healing selectors
- Visual regression testing
- All browsers (Chromium, Firefox, WebKit)
- Local LLM support (Ollama)
- CLI + CI/CD integration
- Community support
Cloud
For teams that want managed infrastructure and collaboration features.
- Everything in Open Source
- Hosted test execution (parallel)
- Team dashboard + analytics
- Slack/Teams notifications
- Scheduled test runs
- Flakiness detection + reporting
- SSO / SAML
- Priority support
Enterprise
For organizations with compliance requirements and custom deployment needs.
- Everything in Cloud
- Self-hosted deployment
- Air-gapped LLM support
- SOC 2 Type II compliance
- Custom integrations
- Dedicated success engineer
- SLA guarantees
- Volume discounts
FAQ
The questions
every dev asks first.
What you actually get, what stays on your machine, and what breaks (or does not) when something changes.
Standard Playwright TypeScript. The same import { test, expect } from '@playwright/test' you'd write by hand. No proprietary runtime, no YAML interpreter, no Assrt-specific assertion library. Open one of the generated files and you'll recognize every line.
Nothing. They keep running. Self-healing and discovery are build-time features; at runtime it's vanilla npx playwright test against the .spec.ts files committed in your repo. Uninstall Assrt, delete the config, and your CI keeps green.
Not by default. Assrt runs locally and talks to whatever LLM provider you point it at, OpenAI, Anthropic, or a local Ollama model. Browsers, screenshots, and generated test files stay on your box. There is no Assrt cloud sitting in the middle of test execution.
When a locator fails, Assrt re-examines the page's accessibility tree, finds the element that matches the original intent (role, accessible name, surrounding context), and rewrites the selector. The patch is logged and shipped as a PR, so you can review the diff before it lands on main. Not magic, just intent-based re-locating with a paper trail.
The repo is public (MIT, on GitHub) and you can clone it any time. The email-gated drop is a convenience: one message with the MCP one-liner, the global CLI install, and copy-paste configs for Claude Code, Cursor, Claude Desktop, VS Code, and Windsurf. No spam, no follow-up sequence. If you'd rather skip it, the source link is in the hero.
Yes. Assrt supports seeded auth state (storageState from a one-time login) and credential-based flows. During discovery it follows your login form like any other user, then reuses the session for the rest of the crawl so it can map authenticated routes, dashboards, and CRUD flows.
Start testing in 30 seconds.
Install Assrt, point it at your app, and get a complete test suite. No signup. No API key. No credit card.