---
source_url: "https://assrt.ai/?utm_source=openai"
title: Assrt — Natural Language Testing for Web Apps
mirrored_at: 2026-08-08T01:08:30.391Z
host: assrt.ai
cited_in_42a: true
mirror_canonical: "https://index.42a.ai/assrt.ai/index__q__utm_source_openai"
---

> **Original source:** https://assrt.ai/?utm_source=openai

v0.1.0 — Now in public beta

## Playwright tests that  
write themselves.

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.

We email you the one-line setup for Claude Code, Cursor, VS Code, Windsurf, and the global CLI, wired to your stack in under a minute.

Or skip the email and run the CLI right now:

No API key. No credit card. [View source on GitHub](https://github.com/assrt-ai/assrt-sdk)

MIT licensedSelf-hosted, runs locallyGenerates real Playwright code

Live run Assrt drives your real app, catches the broken checkout (a missing Stripe token), and hands back the failing Playwright test plus a screenshot and recording. You wrote none of it.

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.

01

### 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.

02

### Review 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.

03

### 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.

04

### 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.

Comparison

## 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

Price

$0

??? /mo

~$7.5K /mo

$0

The output

## What lands in your repo.

Not YAML. Not a proprietary spec. A normal Playwright file with role-based selectors that survive a refactor, committed to your branch so a teammate can read it, diff it, and ship it without ever opening Assrt.

-   →Role-based selectors replace CSS classes that break the moment a designer renames them.
-   →Playwright auto-waiting replaces hand-tuned `waitForTimeout` values that always lie.
-   →Runs with `npx playwright test` — uninstall Assrt and the suite still works.

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

assrt

Test Generator

Natural Language → Playwright TypeScript

assrt

Self-Healing Agent

Selector repair + PR automation

assrt

Playwright Runtime

Chromium · Firefox · WebKit

Your CI/CD

GitHub Actions · GitLab · Jenkins · Any

Assrt layer (removable)

Standard tooling

#### 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.

Most Popular

### Open Source

$0forever

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

$49/seat/mo

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

Custom

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

[Talk to Us](https://assrt.ai/contact)

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.