● AI TEST GENERATION · PLAYWRIGHT YOU OWN

AI writes the tests.Your CI keeps the proof.

Q: What does Verity do?

Verity is an AI test generator and verifier. Give it your app's URL (and optionally an OpenAPI spec or PRD) and it writes readable Playwright tests for UI and API flows, plus visual, AI-agent, performance and security checks. You review and commit them, your CI runs them on every pull request, and Verity turns the results into a release verdict with evidence.

Q: Where do the tests run?

In your own CI — GitHub Actions, GitLab CI or Jenkins — with unlimited runs on every plan, including free. The CI Setup page generates the workflow file for you. Verity Cloud can also run a small number of tests in managed browsers so you can try it before wiring CI.

Q: Do I own the tests Verity writes?

Yes. UI, API and visual tests are plain Playwright TypeScript in your repository, load tests are a script you commit, and AI-agent evals are a YAML file. Nothing is proprietary: if you stop using Verity, the tests keep running.

Q: Does my source code leave my infrastructure?

Not when you run on CI. Tests and scans execute on your own runners, and only results — pass/fail, timings, error messages and findings — are posted back to Verity. To write tests, Verity reads your live app in a browser, plus any spec or PRD you choose to upload.

Q: How does Verity tell a flaky test from a real failure?

Failing tests are rerun automatically. A test that passes on retry is marked flaky and tracked over time; one that fails every time is a real failure. On plans with merge gating, only real failures on the Full regression run can block a merge — the Quick check on pull requests never does.

Q: What happens when my UI changes?

On paid plans, Verity proposes the smallest selector repair grounded in the live page, reruns it, and hands it to you as a reviewable diff. It never edits your code on its own, and genuine product bugs stay failures instead of being healed away.

Q: How much does Verity cost?

Free covers one project with 15 AI-written tests a month — of every type — plus unlimited CI runs, no credit card. Pro is $49 a month (200 tests, self-healing, pull-request checks) and Team is $149. You never pay for runs in your own CI. QAShift also offers managed testing with a dedicated engineer from $499 a month.

Paste a URL. Verity opens your live app, writes readable Playwright tests for UI and API flows — plus visual, AI-agent, load and security checks — and runs them in your own CI on every pull request. Failures come back with evidence, and you keep every line of code.

Watch the 48-second demo

UI · API · VISUALAGENT · PERFORMANCE · SECURITYPLAYWRIGHT YOU OWN

verity / release-1284 LIVE

MORNING RELEASE DECISION

Safe to ship.

CONFIDENCE96^%

231checks passed

02issues isolated

00release blockers

EXECUTION TRACE08:57:14 IST

Live product openedcheckout / production mirror

DONE

Critical paths mapped42 journeys · 318 assertions

DONE

Release executed231 passed · 2 isolated

PROVED

REGRESSION / 02Checkout promo state

Reproduced · video + DOM attachedJIRA-4821

Trusted in production by teams at

Flemingo Duty Free

WordPress

Metomic

BharatSure

Workday

Zoho

Novu

SuperMemory

SEE IT WORK · 48 SECONDS

Watch it catch
a real bug.

01AI writes readable Playwright from a live page.
02One workflow file runs it in your CI.
03The pull request gets a verdict — flaky told apart from broken, with a curl to reproduce.

Every screen is real Verity output.

HOW IT WORKS

From a URL to a merge gate
in four steps.

01
Paste your app's URL
Verity opens it in a real browser and maps the journeys, forms and endpoints worth testing. Add an OpenAPI spec or PRD for deeper coverage.
02
Review readable tests
Playwright specs for UI and API, plus visual, AI-agent, load and security checks. Edit anything — every line is yours.
03
Commit one workflow file
CI Setup writes it for GitHub Actions, GitLab or Jenkins. Tests run on your runners, against your environments, with no run limit.
04
Get a verdict on every PR
A Quick check on pull requests and a Full regression on merge. Flakes are split from real failures, and failures arrive with the error and a proposed fix.

Start free Read the setup guide See an example repo on GitHub

Code ships in hours.
Proof still arrives late.

AI removed the bottleneck from writing code. It did not remove the need to open the product, follow the journey, and prove the outcome.

AGENTCheckout marked complete without a browser runUNVERIFIED

RELEASEOne change broke fourteen passing journeysREGRESSION

STAGINGPayment confirmation returned a blank stateREAL BUG

PR #842The tests passed. The product never opened.FALSE DONE

SELECTORNavigation refactor moved the submit actionDRIFT

⌁

Nobody has a sprint to spare for end-to-end tests.

So the riskiest paths — sign-up, checkout, billing — ship with the least coverage, and the gap widens with every release.

A green unit suite is not a working checkout.

Mocks pass while the real page breaks. Only something that drives the running product can say a customer journey still works.

↘

AI-written changes need an independent check.

When an agent writes the code, Verity is the second pair of eyes: it runs the real flows on every pull request, so regressions surface before a customer finds them.

Coverage in minutes,
not sprints.

Hand-writing an end-to-end suite takes weeks. Verity drafts it from your live app in minutes, and your engineers spend their time reviewing tests instead of typing selectors.

01~2 min

Prompt to first executable test

02<5 min

To run 200 checks across the stack

0340+

Engineering teams shipping with QAShift

041.2M

Checks moving through customer pipelines monthly

From live behavior
to owned evidence.

01 / Observe

It uses the product, not a description of it.

Verity opens the running app, walks the journeys that matter, and grounds every locator and assertion in live product evidence.

02 / Author

Readable Playwright lands in your repository.

UI and API coverage is generated as code your team can inspect, edit, run locally, and keep—even if you leave.

03 / Prove

Every verdict arrives with the evidence.

Runs return the broken step, video, DOM, network trail, logs, and a proposed repair. Passing means the product actually worked.

VERITY / VERIFICATION ENGINESTEP 01

staging.acme.dev/checkoutCONNECTED

CHECKOUT / STEP 03Complete order

role=button · name="Place order"

One system for every
layer that can break.

No stitched-together vendor stack. Every discipline maps into one run history, one risk model, and one verdict your team can understand.

UI functional

Real browser journeys across roles, states and devices

PLAYWRIGHT

API integration

Contracts, schemas, authentication and full request chains

REST · OPENAPI

Visual

Meaningful interface drift across stable product states

SCREENSHOT DIFF

Agent & AI

Grounding, tool use, safety and output guarantees

EVALS

Performance

Load, soak, latency budgets and release regressions

LOAD · CWV

Security

Dynamic and static scanning for common release risks

OWASP

Self-healing without hiding the bug.

When the interface moves, Verity proposes the smallest grounded repair, reruns it, and keeps a human in control. Product failures stay failures.

01 Locator drift is repaired from the live DOM
02 Flakes are separated from real regressions
03 Every change remains reviewable Playwright

checkout.spec.tsREPAIR / REVIEW

SELECTOR CONFIDENCE96%

− page.locator('#submit-order')

+ page.getByRole('button', { name: 'Place order' })

RERUN PASSED · 2.8s

Wired into every merge,
not anyone's memory.

Tests only protect you when they run without someone remembering to start them. Verity lives in your pipeline.

Every merge

The verdict lands on the pull request.

A Quick check runs on every PR and a Full regression on merge. Results post as a check and a comment, right where the review happens.

PR #1284 · checkout-refactor Verity verified 42 journeysRequired check · ready to merge

Every night

Scheduled runs catch silent breakage.

Add a nightly or weekly schedule to the same workflow. Breakage from a dependency, a config change or a third party shows up without a code change.

MTWTFSS02:00 / nightly

Every run kept

Trends, not just today's result.

Flake rates and regression history are tracked per test, so you can see which journeys are getting less reliable before they start failing.

Release 1284 VERIFIED Nightly 06 Sep VERIFIED PR #1278 REPAIRED

Bring Verity into
the stack you already use.

Call the verifier from your agent, terminal, pull request, or delivery pipeline. The same suite and evidence follow the release everywhere.

MCP serverCLICI/CDIDEs

mcp.jsonCONNECTED

{
  "mcpServers": {
    "verity": {
      "command": "npx",
      "args": ["-y", "@qashifthq/verity-mcp"],
      "env": { "VERITY_TOKEN": "your_project_token" }
    }
  }
}

›

Verify checkout against the current branch and return release evidence.

RUNNING

Works where your team works06 CONNECTORS

VS CodeMCP

CursorMCP

GitHubPR GATE

GitLabCI CONFIG

PlaywrightYOUR CODE

Any MCP clientMCP

Your tests. Your choice of where they run.

Keep execution on your infrastructure, or let Verity Cloud handle it. Move between both without rewriting the suite.

∞

YOUR INFRASTRUCTURE

Unlimited on your CI.

Run as many tests as your own runners can handle. Ideal for active development, merge gates and private environments.

Playwright stays in your repository
No per-run Verity limit
Works with existing CI secrets and networks

View CI setup

◌

VERITY INFRASTRUCTURE

Metered on Verity Cloud.

Use managed browsers when you want zero runner maintenance. Included runs get you started; scale when the team is ready.

Managed browsers and evidence storage
Parallel execution without runner setup
Clear usage before you scale

See cloud pricing

Teams that ship often
need evidence they trust.

Customer stories from the QAShift platform.

“
QAShift gives us maintained coverage with an engineer accountable for the result, not a per-test meter that punishes us for testing more.
Karthik SundaramEngineering Manager · Zoho

“
We own every Playwright spec it generates, and it runs in our CI. Self-healing means a UI refactor does not become a day of fixing selectors.
Yonatan CohenStaff Engineer · Novu

“
QAShift separates real failures from noise, so when a check goes red, we trust it and act.
Sophie BennettHead of Engineering · Metomic

“
API coverage catches contract breaks across carriers before our partners ever see them.
Rahul MenonVP Engineering · ShipDelight

𝕏

Builders on X, on the verification gap

𝕏PUBLIC POST
“AI-generated code without automated tests is technical debt at 10x speed.”
Wojak Codes@wojakcodes

𝕏PUBLIC POST
“Testing is the most neglected part of vibe coding projects.”
Meathill@meathill1

FAQ

Questions teams ask before they switch.

Still deciding? Read the docs or talk to an engineer.

What does Verity do?

Verity is an AI test generator and verifier. Give it your app's URL (and optionally an OpenAPI spec or PRD) and it writes readable Playwright tests for UI and API flows, plus visual, AI-agent, performance and security checks. You review and commit them, your CI runs them on every pull request, and Verity turns the results into a release verdict with evidence.

Where do the tests run?

In your own CI — GitHub Actions, GitLab CI or Jenkins — with unlimited runs on every plan, including free. The CI Setup page generates the workflow file for you. Verity Cloud can also run a small number of tests in managed browsers so you can try it before wiring CI.

Do I own the tests Verity writes?

Yes. UI, API and visual tests are plain Playwright TypeScript in your repository, load tests are a script you commit, and AI-agent evals are a YAML file. Nothing is proprietary: if you stop using Verity, the tests keep running.

Does my source code leave my infrastructure?

Not when you run on CI. Tests and scans execute on your own runners, and only results — pass/fail, timings, error messages and findings — are posted back to Verity. To write tests, Verity reads your live app in a browser, plus any spec or PRD you choose to upload.

How does Verity tell a flaky test from a real failure?

Failing tests are rerun automatically. A test that passes on retry is marked flaky and tracked over time; one that fails every time is a real failure. On plans with merge gating, only real failures on the Full regression run can block a merge — the Quick check on pull requests never does.

What happens when my UI changes?