AI test automation tool for macOS and Windows

Retracio turns your manual web testing into E2E tests that follow your conventions

For QA engineers and developers who own E2E. Record a manual run in the desktop app and get a plain Playwright spec in TypeScript or JavaScript, written into your repository.

import { test, expect } from '@/fixtures';import { CartPage } from '@/pages/cart'; test('applies promo code and shows total', async ({ cartWithItems }) => {  const cart = new CartPage(cartWithItems);   await cart.goto();  await cart.addToCart.click();  await cart.promoCode.fill('SPRING');  await cart.apply.click();   // checks marked during the recorded run  await expect(cart.total).toHaveText(await cart.sumOfLines());  await expect(cart.heading).toBeVisible();});

Why the test automation backlog keeps growing

Manual testing does not scale with the product

Before every release someone walks through the same login, checkout and search scenarios by hand. The scenario count grows with each shipped feature, while the hours in a sprint stay fixed. Scenarios that nobody had time to automate stay manual, and that test automation backlog is where regressions wait until a customer reports them.

Generated tests do not pass code review

Recorded and AI-generated tests arrive with inline CSS paths, hard-coded waits and their own naming, while the repository already has page objects, fixtures and a lint config. A reviewer either rewrites the file to match or merges code the team will not maintain. The generator saved recording time and moved the same work into review.

E2E test maintenance eats the team's time

UI tests break when the UI changes: a renamed button, a moved form or a new loading state fails a locator that pointed at a div path. In a published study of record-and-replay suites, 73% (source) of breakages were caused by locators. A recorded test rots as soon as the screen it captured moves on, and a self-healing run that rewrites the locator without a review leaves nobody sure what the test checks now.

How does AI test generation work here?

Four steps take a scenario you already test by hand and generate E2E tests from that manual testing, ending with a Playwright spec that runs in your pipeline.

Step 1: Run the test by hand

• You open Retracio, start a session and walk through the scenario in the browser: navigate, click, type, and mark what should be true on each screen.
• The app records each action with the element it resolved and the checks you marked, preferring role, label and test-id locators over generated CSS paths.
• Result: a recorded run stored on your machine, with stable locators and explicit expectations.

Step 2: Point the app at the repository

• You select the project checkout and the E2E test folder.
• The app scans the repository for framework, page objects, fixtures, naming and assertion style, then sends the recorded steps, trimmed DOM snapshots and excerpts of that profile to the LLM through your API key; source code never leaves the machine.
• Result: a draft test in the repository's style, beside similar tests, reusing existing page objects and fixtures.

Step 3: Review the generated test

• You read the draft as a diff, adjust a name or an assertion, and run it locally.
• The app runs the test with Playwright against the same application, shows pass or fail per step, and regenerates only the failing step when asked, leaving the rest untouched.
• Result: a passing spec file that reads as if the team wrote it and passes code review without a rewrite.

import { test, expect } from "../fixtures/test";
import { CartPage } from "../pages/CartPage";

test.describe("checkout", () => {
  test("adds an item and updates the cart total", async ({ page, signedIn }) => {
    const cart = new CartPage(page);

    await page.goto("/catalog");
    await page.getByRole("button", { name: "Add to cart" }).first().click();
    await page.getByRole("link", { name: "Cart" }).click();

    await expect(page.getByRole("heading", { name: "Your cart" })).toBeVisible();
    await expect(cart.row("Standing desk")).toBeVisible();

    await page.getByLabel("Quantity").fill("2");
    await expect(page.getByTestId("cart-total")).toHaveText(await cart.sumOfRows());
  });
});

Step 4: Commit and run in CI

• You commit the file to a branch and open a pull request as usual.
• The app stays out of the way: the test is plain Playwright with no Retracio runtime, plugin or dependency. If the repository has no E2E job, it offers a snippet for GitHub Actions or GitLab CI.
• Result: the test runs in the existing pipeline; the manual scenario now runs on every push.

# .github/workflows/e2e.yml
runs-on: ubuntu-latest
steps:
  - run: npx playwright install --with-deps
  - run: npx playwright test

How to review AI generated tests without rewriting them

Generated tests usually fail code review for reasons unrelated to whether they pass: selectors inline, no fixtures, wrong folder. Retracio scans the local checkout before it writes anything and builds a conventions profile from what is already there.

Structure. The scan finds where E2E tests live and how files are named. The generated spec goes next to similar tests under the same name pattern.

Locators. Existing tests show which locator style the team accepts: roles, labels, test ids, or a data-testid prefix. Every element from the manual run is resolved to that style, with CSS or XPath only when nothing else matches.

Fixtures. Custom test fixtures for login, seeded data, or an authenticated page are detected and reused, so the generated test starts from the same setup as the rest of the suite.

Page objects. When the repo already has a page object for a screen the tester walked through, the test imports it. A new one appears only for a screen the repo has never covered, in the same shape as the existing ones.

Style. Assertion style, lint and formatter config, and custom helpers are read from the repo. The output passes the same checks as tests the team wrote by hand, and every check the tester marked during the run becomes an explicit expect on an outcome.

Below is the same checkout scenario written without the conventions profile and with it. Both files are illustrations and carry the example output label.

import { test } from '@playwright/test';

test('test 1', async ({ page }) => {
  await page.goto('http://localhost:3000/login');
  await page.fill('#email', 'user@example.com');
  await page.fill('input[type="password"]', 'secret');
  await page.click('#btn-3');
  await page.waitForTimeout(3000);
  await page.click('//div[@class="cart-row"][1]/button');
  await page.waitForTimeout(2000);
  await page.click('.checkout-footer > button.primary');
  await page.waitForTimeout(3000);
  await page.click('#btn-7');
});

import { test, expect } from '../fixtures';
import { CartPage } from '../pages/CartPage';
import { CheckoutPage } from '../pages/CheckoutPage';

test.describe('checkout', () => {
  test('places an order from the cart', async ({ authedPage }) => {
    const cart = new CartPage(authedPage);
    await cart.goto();
    await cart.removeItem('Blue hoodie');
    await expect(cart.total).toHaveText('$24.00');

    await cart.proceedToCheckout();
    const checkout = new CheckoutPage(authedPage);
    await checkout.placeOrder();

    await expect(authedPage.getByRole('heading', { name: 'Order confirmed' })).toBeVisible();
    await expect(authedPage.getByTestId('app-order-number')).toBeVisible();
  });
});

What happens between the manual run and the merged test

Eight things the desktop app does so that AI generated Playwright tests arrive in review looking like the rest of the suite.

Follow the repository's conventions

Before writing a line, Retracio reads how existing tests are structured, named, and asserted and builds a conventions profile from them. The generated test lands in the same folder pattern, uses the same fixtures and helpers, and passes the same lint and formatter config.

Reuse the page objects already in the repo

When the repository has a page object or helper for the screen the tester walked through, the generated test imports it instead of duplicating selectors inline. New page objects appear only for screens the repo has never covered, shaped like the existing ones.

Pick locators that survive a redesign

Every element the tester touched is resolved to a role, label, or test-id locator, with CSS or XPath used only when nothing better exists. If the repo has its own locator convention, such as a data-testid prefix, the generated test follows it.

Turn marked checks into assertions

During the manual run the tester marks what should be true on each screen, and each mark becomes an assertion in the generated test. The output verifies outcomes on every screen, so a green run means the scenario worked.

Run everything on your machine

The browser, the recording, the repository scan, and the test execution all happen locally inside the desktop app. Recorded steps, trimmed DOM snapshots, and excerpts of the conventions profile go to the LLM through your own API key; source code, cookies, and credentials stay local.

Keep code you own

The output is a plain Playwright spec with no Retracio import, plugin, or runtime, so it runs in your CI exactly like the tests you wrote by hand. Uninstall the app tomorrow and every generated test keeps working.

Regenerate a single failing step

When a step fails on review, only that step is regenerated and the rest of the file stays untouched, including edits the tester already made. The diff on the review screen shows exactly what changed and nothing else.

Bring your own model key

The LLM is called through an API key you provide, so there is no per-test pricing and no vendor-side store of your sessions. Model cost is visible per generated test on the review screen and stays with the provider you already use.

What it works with

Retracio writes Playwright tests in TypeScript or JavaScript today, with Cypress and WebdriverIO planned. The app runs on macOS and Windows. Generated tests run in GitHub Actions and GitLab CI like any other file in your repository.

Record and playback vs AI test generation

Four approaches produce E2E tests today: record-and-playback recorders, cloud AI platforms, copilots inside the IDE, and a desktop app that reads your repository before writing a test. Retracio is the last one. The table compares them by whether a capability is documented, with each cell linking to the vendor's own page.

Full comparisons of Retracio against each alternative, grouped by type, are on the compare page.

What the measurements show

Every number below carries the condition it was measured under, the sample size and the year. Nothing here is a projection.

Your repository is not the reference repository. A codebase with competing fixture styles or without page objects gives the conventions and reuse figures less to work with, and the first batch of tests will show it.

What beta users say after the generated tests reached review

These quotes come from beta users of the desktop app, anonymized at their request. Each one describes what happened in their own repository during the beta.

Where the app runs and what leaves your machine

Retracio is a desktop app with a hybrid execution model: the recording, the repository scan, and the file writes happen on your machine, and test generation calls an LLM provider over the network.

What leaves the machine. Recorded steps, trimmed DOM snapshots of the pages under test, and excerpts of the repository's test conventions (page objects, fixtures, naming) are sent to the LLM provider for generation.

What stays on the machine. Source code, generated tests, browser sessions and cookies, screenshots and recordings, and credentials remain local.

How the repository is handled. The app reads the local checkout only. It never clones or uploads the repository. Generated tests are written as files into the folder you choose, and committing stays with you.

LLM provider. Generation runs on Anthropic Claude through your own API key (BYOK). The key stays yours.

Ownership. The output is plain test files in the folder you chose, inside your repository.

Free while the beta runs

Your work email, your framework, the size of your team. The entry reaches us as an email, and what happens to it is written in the privacy policy.

Frequently asked questions

Start with your next manual test run

Leave your email and we write when a build for macOS or Windows is ready. Record one run, get a plain Playwright spec in your own repository.