Features
Testing that thinks
like an engineer.
Assrt combines LLM reasoning with Playwright's battle-tested reliability. It discovers what your app does, writes tests that capture real user behavior, and maintains them automatically as your UI evolves. Six core capabilities, zero vendor lock-in.
Auto-Discovery
Point Assrt at any URL and watch it map your entire application in minutes. The crawler combines vision models with accessibility tree analysis to understand your UI semantics, not just raw DOM structure. It identifies interactive elements, navigation patterns, form flows, and multi-step processes that a traditional spider would miss entirely.
Once the crawl completes, Assrt builds a directed graph of every reachable user flow. It prioritizes paths by complexity and business impact, covering critical journeys like checkout, onboarding, and account management before secondary flows. In benchmarks against production apps, Assrt consistently discovers 30 to 50 percent more testable paths than manual QA inventories.
The output is a human-readable test plan you can review, edit, and version control. Each discovered flow includes a natural language summary, the exact navigation steps, and the assertions Assrt recommends. You stay in control while the AI handles the tedious exploration work.
- Discovers flows humans overlook
- Prioritizes by business impact
- Outputs editable test plans
- Works on any web application
Natural Language Tests
Write your test intent in plain English and Assrt translates it into deterministic Playwright code. There is no proprietary YAML format, no wrapper DSL, and no runtime interpreter. You get real TypeScript test files that any developer can read, modify, and run without Assrt installed.
The generation engine understands context. When you say "add items to cart," Assrt infers that it needs to navigate to a product listing, interact with add-to-cart buttons, and verify the cart state. It generates proper assertions, handles async operations, and adds sensible timeouts. The resulting code follows Playwright best practices including proper page object patterns and locator strategies.
You can describe complex multi-step scenarios in a single sentence or break them into granular steps. Assrt handles both equally well. It even generates meaningful test names, organizes related tests into describe blocks, and adds comments explaining the business logic behind each assertion.
- No proprietary DSL or YAML
- Generates idiomatic TypeScript
- Follows Playwright best practices
- Understands business context
Self-Healing
UI changes break traditional test suites constantly. A designer moves a button, a developer renames a CSS class, and suddenly half your tests fail for reasons that have nothing to do with actual bugs. Assrt eliminates this entire category of maintenance burden by understanding element intent rather than relying on brittle selectors.
When a test step fails, Assrt activates six distinct healing strategies. It checks for timing issues, inspects runtime errors, validates test data freshness, re-evaluates visual assertions, adapts to interaction pattern changes, and resolves broken selectors. Each strategy runs independently and the framework picks the most confident fix. The healed selector is written back to your test file so the fix persists.
Self-healing happens transparently during test execution. Your CI pipeline keeps passing while Assrt quietly adapts to UI drift. You get a detailed healing report after each run showing exactly what changed and why, so you can review the adaptations and ensure they match your intent. No silent failures, no false confidence.
- Six independent healing strategies
- Fixes persist in your test files
- Transparent CI integration
- Detailed healing reports
Visual Regression
Unit tests and integration tests verify behavior, but they cannot catch the subtle visual regressions that frustrate users: misaligned elements, overlapping text, broken responsive layouts, or colors that shifted after a dependency update. Assrt fills this gap with intelligent visual comparison that goes far beyond naive pixel diffing.
The visual regression engine uses perceptual hashing to compare screenshots at a semantic level. It understands that anti-aliasing differences, cursor blink states, and animation mid-frames are not real regressions. It groups related changes together so a single font-size tweak that affects 40 pages shows up as one actionable item, not 40 separate failures.
You configure which viewports and pages to snapshot, or let Assrt auto-select based on your discovered test plan. Baselines update automatically when you approve changes, and the diff viewer highlights exactly which regions changed. This integrates directly with your CI workflow, blocking merges only when visual regressions exceed your configured threshold.
- Perceptual hashing ignores noise
- Groups related visual changes
- Configurable sensitivity thresholds
- CI-native with approval workflow
Zero Lock-in
Every test that Assrt generates is a standard Playwright test file written in TypeScript. There is no proprietary runtime, no cloud dependency, and no required API keys. If you decide to stop using Assrt tomorrow, your tests keep working exactly as they did before. Run them with npx playwright test and nothing changes.
This is a deliberate design decision, not a limitation. Vendor lock-in is the single biggest risk in adopting AI testing tools. Competitors wrap Playwright in proprietary layers that require their cloud service to execute. Assrt takes the opposite approach: it generates the same code a senior test engineer would write by hand, then gets out of the way.
Your tests live in your repository, run in your CI pipeline, and follow your team's conventions. Assrt respects existing Playwright configurations, custom fixtures, and page object models. It extends your testing workflow rather than replacing it. When you outgrow any individual Assrt feature, you can replace just that part while keeping everything else.
- Standard Playwright test output
- No cloud dependency or API keys
- Respects existing project config
- Eject anytime with zero friction
Parallel Everything
Assrt runs your entire test suite in parallel across Chromium, Firefox, and WebKit simultaneously. A full 500-test suite completes in under four minutes on a MacBook Pro. In CI environments, Assrt automatically shards across available containers, scaling linearly with the compute you allocate.
Cross-browser testing is not optional for production applications, but most teams skip it because of the time cost. Assrt eliminates that tradeoff. Every test runs against all three browser engines by default, catching the rendering quirks and API inconsistencies that only surface in specific browsers. Firefox handles form validation differently, WebKit has unique scroll behavior, and Chromium ships features ahead of the standard.
The parallel executor is intelligent about resource allocation. It detects available CPU cores, monitors memory pressure, and adjusts concurrency dynamically. Long-running tests get their own workers while fast tests batch together. Flaky test detection runs suspect tests multiple times in isolation to distinguish genuine failures from timing issues.
- Chromium, Firefox, and WebKit in parallel
- Dynamic concurrency based on resources
- Automatic sharding in CI
- Built-in flaky test detection
Ready to see it in action?
Read the docs, install Assrt in under a minute, and generate your first test suite. No signup required.