Autonomous browser testing

Ship it. We'll prove it works.

A real browser tests your app on every push and deploy, AI tells you whether a failure is a real bug, and only passing runs use credits.

or let your coding agent check its own work

npx welltested setup

Works with Claude Code, Cursor and Codex. Your agent runs your tests before it says done. How it works

Chromium, Firefox, WebKit
AI triage on every failure
A proof page for every run

One loop, three stages.

Try a test from a URL and one sentence. Keep the ones you want in a suite. Let every push, deploy or schedule rerun them. When one fails, the run shows why and what changed since the last green run. Home rolls up the receipts into suite cards, so you can see what is green right now.

01 / DESCRIBE
Say what should work.
Paste a URL and one sentence, or hold the mic and say it. The AI planner reads your live page and proposes steps that target elements it actually found. Nothing runs until you approve the plan. If a step aims at the wrong thing later, click the right element on its screenshot and rerun from there.
02 / PROOF
Get the receipt.
A real browser runs the approved plan and records what happened:
- Real browser runChromium, or Firefox, WebKit and iPhone/Android mobile-web profiles on the larger plans, runs the steps you approved. Self-healed and vision-clicked steps are labelled.
- Step trace with screenshotsA screenshot per step, plus a video when a run fails. Missing frames are named, never hidden.
- Console and network logsBrowser console errors and the requests, statuses and timings from each step, so "POST /api/checkout 500" shows up next to the failed step.
- AI triage and a fix promptJev reads the step trace and Clef reviews the screenshots: a real bug in your app, or a test or environment issue. Copy a fix prompt for your coding agent. The AI never changes the pass/fail result.
- What changed since the last passA step-by-step diff against the last green run: status, screenshot, console errors and failed requests, with a likely source file when your app ships source maps.
- Shareable proof pageA token-gated link you can send to anyone with the verdict, screenshots and step trace in one place.
03 / KEEP
Let it run itself.
Keep a test and it joins a suite. Home shows every suite as a card: green or red, last run, what triggers it. Rerun a suite with one click, or let it run on its own.
- Every push and every deployA GitHub Action on push, or a deploy hook URL your host or pipeline calls after each deploy. On every plan.
- On a scheduleDaily on Builder, hourly on Team and Scale.
- Results where you lookAn email when a suite goes red or recovers, on every plan. PR comments on Team and Scale.

For coding agents

Your agent checks its own work before it says done.

Claude Code, Cursor, Codex, Windsurf, Copilot and Kiro can run your Well Tested tests themselves. One command sets it up; after that, "done" comes with a real browser run behind it.

01 / SET UP
One command.
npx welltested setup finds the coding agents on your machine and adds the Well Tested MCP server and a "verify before done" skill. It shows you the change and asks before it writes anything.
02 / VERIFY
Checked before done.
Before your agent says the work is finished, it runs your kept tests with welltested run or the MCP tool. A real browser runs them and every result links to a proof page.
Building on localhost? welltested tunnel --port 3000 lets the cloud run reach your dev server, or welltested run --local runs the browser on your own machine (sign in with welltested login --runner first).
03 / FIX
Failures come back fixable.
A red run comes back to your agent with Jev and Clef's call (a real bug in your app, or a test or environment issue), the console and network logs, and a fix prompt it can act on. Then it runs the tests again.
- Credits1 credit = 1 passing test run, on one browser, up to 1 minute. Only passing runs use credits. A run that catches a bug in your app, or fails because of us or your environment, is free.

Set up your coding agent →

Autonomous testing

An agent runs the test. Two models judge it.

The agent plans and runs browser tests from a sentence. When a run goes red, Jev, a decision model from TypeSafe, reads what happened step by step, and Clef, Cloudflare's vision model, looks at the screenshots. Together they answer the question you actually have: is my app broken, or is the test? A real bug comes with the console and network logs and a fix prompt to paste into your coding agent. A renamed button is repaired mid-run and labelled, so it doesn't turn your suite red.

Run a free check →What's new

RUNCheckout reaches the receipt page

FAILStep 4 · expected “Payment received”

JEVFailure analysis → the app misbehaved

CLEFScreenshots → receipt never shown

LOGSPOST /api/checkout → 500 at step 4

AI TRIAGELooks like a real bug in your app · High

FIXCopy fix prompt for your coding agent

Illustration of the triage panel, not a customer result. Pass/fail is never changed by the AI.

AI plannerLive
Plans from one sentence
Paste a URL and say what should work. The agent reads your live page and proposes steps that target elements it actually found. Nothing runs until you approve the plan.
Jev + ClefLive
Bug or not? AI triage
When a run fails, Jev reads the step trace and Clef checks the screenshots against your goal. You get a call: a real bug in your app, or a test or environment problem, with the signals it's based on. Your pass/fail result never changes.
Repair modelLive
Self-healing steps
When a button is renamed or moves, the run repairs that step on the spot from a fresh look at the page and keeps going. The step is labelled "Passed after repair" and you can keep the repair with one click. Assertions and destructive steps are never repaired.
Vision modelLive
Vision fallback
When a step still can't find its target, for example on a canvas or an icon-only button, a vision model finds it in the screenshot and the step is labelled "Clicked by vision". Hidden, disabled or contradicting elements are refused.
Vision modelLive
Screenshot review
Screenshots from the run are reviewed against your goal and summarized next to the step trace, as an opinion separate from the pass/fail result.
PlaywrightLive
Real browsers
Chromium on every plan. Firefox, WebKit and iPhone and Android mobile-web profiles on Team and Scale. Native iOS and Android apps are on the roadmap, not live.
Auth profileLive
Pages behind a login
Save a username and password, or custom login steps for flows like SSO redirects, on an environment and check them with Save & test login. Planning reads the signed-in page, and the run signs in once and runs your steps in that session. The password is encrypted at rest and never appears in screenshots, logs or proof pages.
Speech to textLive
Voice to test
Hold the mic and describe the journey, up to 60 seconds in English or Turkish. The transcript becomes an editable goal; nothing runs until you approve it.
AI judgeBeta
AI feature testing
Point it at your chatbot or AI endpoint. Twelve approved scenarios check that it does its job, stays on task, resists prompt injection, doesn't leak data, keeps a safe tone and gets known facts right. Only origins you verify can be tested.

Proof on every push and deploy.

Kept tests rerun themselves. Add the GitHub Action, a deploy hook URL, or a step in GitLab CI or Bitbucket Pipelines, and every run comes back with the same proof page, AI triage and share link as a run you started by hand. Duplicate triggers for the same commit are merged into one run.

Every GitHub push
Every deploy (hook URL)
Daily, weekly or hourly schedules
Email when a suite goes red or recovers
PR comments on Team and Scale

See CI setup →

GitHub Actions

GitLab CI

Bitbucket

Example pipeline step

- name: Run Well Tested evidence
  env:
    WELLTESTED_CI_TOKEN: ${{ secrets.WELLTESTED_CI_TOKEN }}
    GITHUB_COMMENT_PR: ${{ github.event.pull_request.number && 'true' || '' }}
    GITHUB_EVENT_PULL_REQUEST_NUMBER: ${{ github.event.pull_request.number }}
    GH_TOKEN: ${{ github.token }}
  run: |
    RESPONSE=$(curl -fsS -X POST https://welltested.io/api/ci/run \
      -H "Authorization: Bearer ${{ secrets.WELLTESTED_CI_TOKEN }}" \
      -H "Content-Type: application/json" \
      -d '{"scenarios":["scn_your_scenario_id"],"browsers":["chromium"]}')
    echo "$RESPONSE"
    BATCH_ID=$(echo "$RESPONSE" | jq -r '.batch.id')
    STATUS_URL=$(echo "$RESPONSE" | jq -r '.statusUrl')
    set -euo pipefail
DEADLINE=$(( $(date +%s) + 1800 ))
while [ $(date +%s) -lt $DEADLINE ]; do
  BODY=$(curl -fsS -H "Authorization: Bearer $WELLTESTED_CI_TOKEN" "$STATUS_URL")
  STATUS=$(echo "$BODY" | jq -r '.batch.status')
  echo "$BODY" | jq -r '.runs[]? | "\(.status)\t\(.testTargetLabel)\t\(.resultUrl // "pending")"'
  case "$STATUS" in
    COMPLETED)
      if [ "${GITHUB_COMMENT_PR:-}" = "true" ] && [ -n "${GITHUB_EVENT_PULL_REQUEST_NUMBER:-}" ]; then
  COMMENT=$(echo "$BODY" | jq -r '[.runs[]? | "- \(.testTargetLabel): \(.resultUrl // "pending")"] | join("\n")')
  MARKER="<!-- well-tested-evidence -->"
  COMMENT_BODY="$MARKER\n### Well Tested evidence\n\n$COMMENT"
  EXISTING_COMMENT_ID=$(gh api --paginate \
    "repos/$GITHUB_REPOSITORY/issues/$GITHUB_EVENT_PULL_REQUEST_NUMBER/comments?per_page=100" \
    --jq '.[] | select(.body | contains("<!-- well-tested-evidence -->")) | .id' \
    | head -n 1)
  if [ -n "$EXISTING_COMMENT_ID" ]; then
    gh api --method PATCH \
      "repos/$GITHUB_REPOSITORY/issues/comments/$EXISTING_COMMENT_ID" \
      -f body="$COMMENT_BODY"
  else
    gh api "repos/$GITHUB_REPOSITORY/issues/$GITHUB_EVENT_PULL_REQUEST_NUMBER/comments" \
      -f body="$COMMENT_BODY"
  fi
fi
      echo "Well Tested batch passed"
      exit 0
      ;;
    PARTIAL|FAILED|CANCELED)
      echo "Well Tested batch finished with status=$STATUS"
      exit 1
      ;;
  esac
  sleep 15
done
echo "Timed out waiting for Well Tested batch $BATCH_ID"
exit 1

Engines, in plain language.

You never write these yourself; the planner does. This is what runs behind the proof page. Want to leave? Export any kept test as a standalone Playwright file that runs without us.

Playwright
Browser + mobile webLive
Real browser automation runs Chromium, Firefox, and WebKit against your URL with explicit checks and captured evidence.

Also works from your phone

The same proof loop, from the back of an Uber.

Open /app on your phone: the responsive web app works there too. Pick a kept test, choose Chromium, the iPhone profile or the Android profile, then watch the run finish and share the proof link. You can also describe a new test by voice. The browser runs on our servers; your phone is the remote.

Start with a bounded check →Run from your phone on every plan · phone browser profiles on Team and Scale

Product demo15s loop

01Pick a kept test or suite

Rerun it as is, no re-approval needed.

02Choose targets

Chromium, iOS Safari profile, or Android Chrome profile.

03Run and share proof

Execution happens on the server; the phone tracks status and proof links.

How teams run vibe testing in practice.

Pay only for passing runs.

1 credit = 1 passing test run, on one browser, up to 1 minute. Only passing runs use credits. A run that catches a bug in your app, or fails because of us or your environment, is free. AI triage, self-healing and diff included, never metered. Break Test: Quick 3 credits, Standard 10, flat. This is the one exception to “only passing runs use credits”, because finding a break is what you're paying for. You get the credits back if our system fails. Need more? Add 500 credits for $59 on any plan. Pack credits never expire and are used only after your monthly credits.

Compare plans →Annual billing saves 20%

Free check	No signup	One bounded check on your URL, no card	Test a URL free →
Builder	$29/mo	300 credits a month · Chromium (desktop)	Choose Builder →
Team	$99/mo	1,000 credits a month · Chromium, Firefox, WebKit + iPhone and Android profiles	Choose Team →
Scale	$299/mo	3,000 credits a month · Chromium, Firefox, WebKit + iPhone and Android profiles	Choose Scale →

Ship it. We'll prove it works.

Say what should work.

Get the receipt.

Let it run itself.

One command.

Checked before done.

Failures come back fixable.

An agent runs the test. Two models judge it.

Plans from one sentence

Bug or not? AI triage

Self-healing steps

Vision fallback

Screenshot review

Real browsers

Pages behind a login

Voice to test

AI feature testing

Proof on every push and deploy.

Playwright

The same proof loop, from the back of an Uber.

How teams run vibe testing in practice.

Pay only for passing runs.