Ai·

The 18 Best Agentic QA Tools in 2026

Eighteen agentic QA tools, sorted on one question: does the tool replay a script, or does it decide what to test from the change in front of it? Updated November 2026.

Daniel Mauno Pettersson

CEO / Co-founder

Eighteen agentic QA tools, sorted on one question: does the tool replay a script, or does it decide what to test from the change in front of it? Updated November 2026.

TL;DR: The best agentic QA tools in 2026 are QA.tech for dynamic testing on every pull request, testRigor for plain-English tests without selectors, and Momentic, mabl and KaneAI for AI-assisted suites. Shiplight and Playwright Test Agents suit teams that want agent-written test code in their repo. QA Wolf suits teams buying agent-written scripts run in a vendor cloud. Of the eighteen, only QA.tech does dynamic testing: the agent works out what to test at runtime from the change, then verifies the outcome by goal. The rest either replay steps fixed before the run, with varying amounts of AI on top, or re-plan from scratch on every run without a stable verdict.

Pretty much every testing vendor calls itself agentic now. Putting the word on a pricing page is free. This guide starts with a test for the term that survives the marketing and sorts 18 tools into five categories. It then compares them on what decides the purchase: who does the testing work, what breaks when your UI changes, and whether verification keeps up with how fast you ship.

How this guide was put together

QA.tech makes one of these tools, and this guide ranks it first. To keep the rest useful, every competitor entry is based on that vendor's own product and pricing pages as they read in November 2026, and every entry says where the tool does not fit. If a vendor's page and this guide disagree, the vendor's page wins. Tell us and we will fix it.

Quick comparison: static scripts or dynamic testing?

ToolTest modelCategoryWho does the testing workWhat happens when the UI changesRuns on every pull request?Platforms
QA.techDynamic – agent decides what to test from the change, verifies by goalAutonomous AI agentThe agent – plans, tests, verifiesAgent re-reads the screen and completes the journey; no selectors to repairYes – reads the PR and connected issue, scopes the run to what changed; CI/CD, MCPWeb, mobile web, native mobile, API, voice
testRigorScripted in plain English, replayed each run; elements matched visuallyAutonomous AI agentHumans (or generation from production sessions) write plain-English steps; testRigor executes them as writtenVisual and contextual element finding; very little interventionCI/CD, MCP; runs the steps you wroteWeb, mobile, desktop, API
MomenticScripted + AI repairAI-assistedHumans author; intent-based locators executeIntent locators re-resolve the elementCI/CD, MCP; AI picks existing tests from the code diffWeb, mobile (emulators and simulators)
mablScripted + AI repairAI-assistedHumans author in a low-code editorAuto-healing on IDs, classes, positions; structural refactors need a personCI/CD; runs your suite after each commit or PRWeb, mobile, API
KatalonScripted + AI repairAI-assistedHumans author in no-code, low-code or full code; AI agents assistAI-assisted healingCI/CD; runs the suite you definedWeb, mobile, desktop, API
KaneAI (TestMu AI)Scripted from plain English, exportable to codeAI-assistedHumans describe tests; KaneAI plans and writes the stepsAuto Healing AgentKane CLI in CI; PR validation in betaWeb, mobile, API
TestimRecorded and low-code + AI generationAI-assistedHumans record and edit; natural-language generation on topAI locators re-resolve elementsCI/CD; runs the suite you definedWeb, mobile, Salesforce
BrowserStack AI agentsScripted or low-code, agent-assistedAI-assistedHumans or agents author from PRDs and user stories; runs on BrowserStack's gridSelf-Healing AgentCI/CD; PR merge gate in a paid reporting add-onWeb, real iOS and Android devices, API
Autify NexusRecorded in plain English, Playwright underneathAI-assistedHumans record; Genesis AI drafts tests from Jira and Figma requirements"Fix with AI" repairs locatorsCI/CD; runs the suite you definedWeb
FunctionizeScripted, AI-built from a descriptionAI-assistedHumans describe; Studio builds the testStudio keeps tests passingNot stated; MCP for coding agentsWeb
Virtuoso QAScripted + AI repairAI-assistedHumans author in NLP low-codeSelf-healing executionCI/CD; runs the suite you definedWeb
ShiplightScripted YAML, agent-authoredCoding-agent toolingYour coding agent writes YAML tests into your repoHeals arrive as PR diffs for your team to reviewThrough your coding agentWeb
Playwright Test AgentsScripted, agent-authoredOpen-sourceYour coding agent writes Playwright codeHealer agent proposes a fix; selectors stay yoursVia MCP-capable coding agentsWeb
Playwright MCPPrimitive – agent drives a browserOpen-sourceYour coding agentn/a – no test artefactAny MCP clientWeb
BrowserUse / StagehandDynamic per run, no fixed verdictOpen-sourceAn LLM agent pursuing natural-language goals / your engineers mixing code and AI actionsRe-plans each run / code parts are yoursLibrary your agents callWeb
QA WolfScripted, agent-written Playwright and AppiumAgents + managed serviceQA Wolf's agents write and maintain scripts in QA Wolf's cloudAgents update the scriptAgents pick existing tests per PRWeb, native mobile, desktop
Tricentis ToscaScripted, model-basedEnterprise codelessQA org, model-based authoringChange a module, it propagates to every test using itLimitedWeb, mobile, desktop, SAP/mainframe
ACCELQScripted, codelessEnterprise codelessQA org, codeless authoring; Autopilot assists discoverySelf-healingLimitedWeb, mobile, API, desktop, mainframe

What Makes a QA Tool Actually Agentic?

Three different things are being sold under the "AI testing" banner. The useful way to tell them apart is to ask whether the test is static or dynamic.

The first is traditional test automation – Selenium, Cypress, Playwright – replaying a recorded sequence. Static by design: the steps were fixed when someone wrote them, and the suite runs the same steps in the same order regardless of what changed. No AI, and honest about it.

The second is the same scripts with an AI layer on top. The model writes them faster, and when a selector breaks it re-guesses it ("self-healing"). Most tools wearing the agentic label live here. The test is still static; what got smarter is the repair.

The third is dynamic testing. The agent holds a goal, reads the actual screen, decides what to do, acts, and checks whether the outcome is what a user would expect. Point it at a pull request and it reads what changed, works out which journeys that change can break, runs those, and adds a few nobody had written down. It also remembers: it builds up knowledge of your product across runs, the way a tester builds intuition over years.

You can test for this in any demo. Ask what happens when the test runs into something no script ever recorded. A repair layer re-guesses a selector. An agent re-reasons the journey. If the vendor's answer is fundamentally about locators, you're looking at a patch, not a tester. (For a deeper breakdown of the two architectures, see agentic testing vs traditional test automation.)

Concretely, an agentic QA tool should demonstrate:

  • Goal-based test definition – tests describe what should happen ("sign up as a new user and verify you land in the dashboard"), not which elements to click
  • Autonomous test generation – the agent builds new coverage on its own, by exploring the product and reasoning about what could break, instead of waiting for someone to record clicks
  • Outcome verification – it validates that the goal was achieved, not merely that the click-path survived
  • Adaptation without healing – when the UI changes, the agent completes the journey because it understands intent; there is no brittle artefact to "heal"
  • A full execution loop – runs tests, interprets failures, and reports what was expected versus what happened, not just that a selector went missing
  • Change-scoped verification – it runs where development happens, on every pull request, and decides what to test from the change itself rather than replaying the whole suite as a separate phase at the end

Why this matters now: AI has sped up every part of the SDLC except verification. Teams using coding agents ship more code, reviewed by fewer humans, faster than any scripted regression suite can keep up with. And teams running scripted automation are still paying the script maintenance tax – 20 to 30 percent of QA time spent repairing tests that broke for reasons that have nothing to do with product quality. Nobody budgets for it, it never gets a ticket, and the visible result is that coverage stops growing. You can have 10,000 tests and still ship a bad product; if they don't test what your users actually care about, all green means very little.

Analysts track the category now as well. Gartner's Magic Quadrant for Agentic Software Quality Assurance Platforms (October 2026) covers platforms "with specialized agents that continuously assure quality across the SDLC", and most of the vendors it evaluates sell enterprise testing suites to QA organisations. Testing scoped to each pull request sits closer to the developer workflow, which is why the comparison above leads with it.

The Five Categories of Agentic QA Tools

Autonomous AI Agents (no selectors) – Tests are described in plain English and executed against the screen the way a user sees it; nothing to heal because there is no locator to break. Within this group only QA.tech is dynamic – it also decides what to test at runtime from the change in front of it. (QA.tech, testRigor)

AI-Assisted Platforms (static scripts + AI repair) – Humans author tests by recording, in a low-code editor or in plain English; AI speeds up authoring and re-resolves broken locators. Scripts remain the underlying model. (Momentic, mabl, Katalon, KaneAI, Testim, BrowserStack AI agents, Autify Nexus, Functionize, Virtuoso QA)

Coding-Agent and Open-Source Tooling – Your coding agent writes and repairs test code that lives in your repo, or you assemble agent-driven testing from free building blocks. (Shiplight, Playwright Test Agents, Playwright MCP, BrowserUse, Stagehand)

Agents + Managed Service (static scripts in a vendor cloud) – A vendor's agents write and maintain a Playwright and Appium suite that runs in the vendor's cloud, with a service tier on top. (QA Wolf)

Enterprise Codeless Suites (static, model-based) – Platforms built for large QA organisations testing packaged enterprise applications, now with agentic features layered on. (Tricentis Tosca, ACCELQ)

Figure out which operating model you're actually shopping for before you open a single feature list. Putting an autonomous platform, a managed service and an enterprise suite side by side on a checklist is how teams end up with the wrong tool. They answer different questions.

Category 1: Autonomous AI Agents

1. QA.tech

QA.tech's agentic testing platform uses agents that interact with your application visually, the way a human tester would, rather than through the DOM or code structure. You describe what you want tested in plain English, and the agent figures out how to get it done. When the UI changes, there's no broken script to "heal" – the agent looks at the screen, understands what the test is trying to achieve, and completes the journey. Something that comes naturally to a human, like still finding the login button after it got renamed to "Sign in," was never supposed to be a maintenance event.

On onboarding, agents build a knowledge graph of your application – mapping screens, navigation patterns and user flows. That knowledge compounds across runs, making test generation smarter and more contextual as your product evolves. Agents don't just validate known paths; they probe edge cases, empty states and failure scenarios that scripted tests routinely miss – exploratory testing as a standing capability, not an occasional manual exercise.

The part that matters most in 2026: QA.tech closes the loop with AI-speed development. When a pull request opens, the agent reads the intended change, picks up requirements from the connected issue, works out which journeys that change can break, and runs those – verification as a peer in the pipeline, not a nightly suite after it. That is what we mean by dynamic testing: the run is scoped to the change, and the agent adds the cases nobody scripted. Tools that read the code itself rather than test the running app are a separate category, covered in our roundup of AI PR code review tools. One AI-native customer shipping thousands of PRs a month runs exactly this workflow; another cut regression cycles from two or three days down to about two hours. And since the agent acts as a regular user – it doesn't look at your code, doesn't look at the DOM – the verification is independent. It doesn't matter if the code is legacy that's been around for ages or something a coding agent wrote five minutes ago.

QA.tech also runs API testing – the agent calls your endpoints and writes its own validation code in an isolated sandbox, no browser in the loop – and voice testing, where the agent speaks into your app's mic input and verifies the outcome like any other test.

AI Autonomy LevelAutonomous AI
Testing PhilosophyGoal-oriented – describe what should happen, not how
Interaction ModelVisual and semantic – no DOM or selector dependency
When the UI changesThe agent re-reads the screen and completes the journey – there is no selector to repair
Test Creation Time~5 minutes per test, in plain English
Test TypesE2E, Regression, Exploratory, Visual, API, Voice, PR testing, CI/CD
PlatformsWeb, mobile web, native mobile, API, voice

How to try it: start with a free trial that covers web and PR testing on one application, with 10 credits. The self-serve Starter plan is $89 a month for up to 5 users and 2 applications, with 50 credits included; only agent runs use credits. Plans are on the pricing page.

Pick it if you ship with AI coding agents and want an independent agent verifying every pull request by goal, your UI changes weekly, or non-engineers need to contribute tests in plain English.

Skip it if your estate is SAP, mainframe or desktop.

2. testRigor

testRigor shares the no-selectors stance: tests are written from the user's perspective, and elements are found the way a user sees them. The difference from QA.tech is what happens at run time. testRigor executes the plain-English steps as written, every run, while a dynamic agent works out the steps from the goal and the change. It is the most resilient scripted model on this list, and it is still a scripted model. Element identification is visual and contextual rather than selector-based, so tests survive UI refactoring that would break traditional frameworks. It stands out at generating tests from observed production behaviour: it captures what real users actually do and builds coverage around those flows. Tests can also be generated from Claude Code through testRigor's MCP server.

AI Autonomy LevelAutonomous AI
Testing PhilosophyUser-perspective testing – elements identified as seen on screen
When the UI changesVisual element finding absorbs cosmetic changes; when a flow changes, the written steps need updating
Test Creation TimeMinutes – plain English, or auto-generated from production data
Test TypesRegression, E2E, production monitoring
PlatformsWeb, mobile web, native mobile, desktop, API

Pick it if you are moving manual testers into automation, want plain-English tests that survive UI refactors, or want coverage generated from what real users do in production.

Skip it if you want checks worked out from each change, or exploratory coverage of paths no user has taken yet – the steps are fixed before the run.

Category 2: AI-Assisted Platforms

Tools in this group are covered in more depth in our roundup of AI-assisted testing platforms.

3. Momentic

Momentic's differentiator is its intent-based locator system: rather than storing a CSS selector, the AI finds the matching element on each run by understanding layout, context and purpose. It now runs on mobile emulators and simulators as well as the web, and its AI test selection picks the existing tests most likely to catch a regression from a code diff. Humans still review and author each test step in a low-code editor, which is what separates it from Category 1. The execution is resilient, and a person drives the authoring.

Pick it if you want intent-based locators that survive layout changes and you are fine with a person authoring every step in a low-code editor. It is a common pick for teams replacing Playwright or Cypress.

Skip it if you want the agent to decide what to test from the change. Diff-based selection still chooses from tests someone already wrote, so a change nobody wrote a test for gets nothing new.

4. mabl

mabl was one of the first platforms to apply machine learning to test maintenance, and its auto-healing has been around long enough to be mature. But mabl is still selector-aware underneath. Auto-healing handles element IDs, class renames and positioning shifts well; structural refactors still need manual intervention. The maintenance burden goes down, and it doesn't go away.

Pick it if you have automation experience and want web, mobile and API coverage in one mature platform.

Skip it if structural UI refactors are frequent – auto-healing handles renamed IDs and shifted positions, not redesigned flows – or you want the run scoped to the change rather than the whole suite.

5. Katalon

Katalon is the most complete all-in-one platform in this category: manual, automated web, mobile, API, desktop and performance testing, with AI agents for authoring and failure analysis layered on top. But the AI is an enhancement layer, not the foundation. Tests execute what you defined and heal when selectors break. They don't explore, and they don't reason about your product.

Pick it if you are consolidating manual, web, mobile, API and performance testing into one platform and want to own the test strategy yourself.

Skip it if you are buying for the AI – it is an enhancement layer on a conventional platform, and it does not explore or reason about your product.

6. KaneAI (TestMu AI)

KaneAI, from TestMu AI (formerly LambdaTest), takes a plain-English description, a Jira ticket or a PRD and plans, writes and runs the test across web and mobile. Tests export to Selenium, Playwright and Appium code, and the Kane CLI runs them locally or in CI. A GitHub command that validates a pull request and posts results back is in beta.

Pick it if you already run on TestMu AI's browser and device cloud and want plain-English authoring that exports to code you can take with you.

Skip it if you want PR-scoped verification you can rely on today – it is a beta – or you want to stop maintaining scripts. Exported code is a script suite again, and its upkeep moves to your team.

7. Testim

Testim, now part of Tricentis, is a recorder-based, low-code platform with AI locators and newer "agentic test automation" that creates tests from natural language. It covers web, native and hybrid mobile, and has a dedicated Salesforce offering. Tests run in Testim's cloud or on any Selenium Grid, and the Professional plan exports to Puppeteer, Selenium and Playwright.

Pick it if you test Salesforce, or you have a recorder-based team that wants AI-stabilised locators.

Skip it if you want testing that reasons about each change. The agentic features generate the same kind of fixed-step tests the recorder does.

8. BrowserStack AI agents

BrowserStack has layered a set of agents on its browser and device grid: a Test Case Generator Agent that reads PRDs and user stories, a Low-Code Authoring Agent, a Self-Healing Agent and test failure analysis. The real-device coverage is the draw. A quality gate that blocks PR merges sits in a separate reporting add-on sold through sales.

Pick it if you already run on BrowserStack and need real-device and cross-browser coverage with AI help on authoring and triage.

Skip it if you want the agent to do the testing. The agents speed up writing and repairing tests for the grid; the tests themselves are still fixed steps.

9. Autify Nexus

Autify Nexus turns plain English into recorded test steps on top of Playwright, and its Genesis AI drafts test cases from Jira and Figma requirements. Tests export as editable Playwright scripts and run locally, on-prem or in the cloud. "Fix with AI" repairs broken locators.

Pick it if you want plain-English recording with an exit to Playwright code, plus on-prem execution.

Skip it if you need mobile or API testing from the same tool, or anything scoped to a pull request. The steps are fixed at record time.

10. Functionize

Functionize Studio builds a test from a description of what to check, runs it and keeps it passing. A Functionize MCP server lets a coding agent drive verification in Studio. It is a web UI testing platform with built-in SMS, MFA and email checks.

Pick it if you test web flows with heavy MFA, SMS or email steps and want tests built from descriptions.

Skip it if you need mobile, API or PR-scoped runs. None of the three is described on its product pages.

11. Virtuoso QA

Virtuoso's natural-language authoring converts plain English into executable automation in real time, with reliable self-healing on locator changes. Scope is the limitation: it's primarily a web platform, oriented toward structured enterprise QA organisations rather than fast-shipping product teams.

Pick it if you run a structured enterprise QA organisation with non-programmer testers and a stable web application.

Skip it if you ship product changes weekly or need anything beyond web.

Category 3: Coding-Agent and Open-Source Tooling

12. Shiplight

Shiplight installs into coding agents such as Claude Code, Cursor and Codex through MCP and Skills. Your coding agent writes intent-based YAML tests that live in your repo and run on Shiplight's hosted runners. When the UI changes, larger repairs arrive as pull-request diffs for your team to review. It is web-only by its own account.

Pick it if you want test files in git that your coding agent writes and your engineers review line by line.

Skip it if you want verification independent of the code. The agent that wrote the change also writes and runs its test, so a wrong assumption in the code tends to reappear in the test. Every heal is another diff your team has to review, and mobile is out of scope.

13. Playwright Test Agents

Playwright now ships its own agents – one plans coverage by exploring your app, one writes the Playwright code, one digs into failures and suggests repairs. They run through MCP-capable coding agents, and what you get is ordinary Playwright code sitting in your repo, owned by your team.

The catch: it's still selector-bound Playwright code. The agents make authoring and repair faster, but you're still the one operating a script suite – selectors, waits, CI, infrastructure, all of it. An agent writing the scripts doesn't change what the scripts are.

Pick it if you have a Playwright suite you intend to keep and want first-party agents to plan, write and repair it faster.

Skip it if script upkeep is the problem you are trying to remove – an agent writing the scripts does not change what the scripts are. Free and open source, excluding the engineering hours.

14. Playwright MCP

Playwright MCP is the open-source server that lets any MCP-capable coding agent drive a real browser – navigate, click, type, read the page. For a lot of teams, the first taste of agentic QA is a coding agent clicking through a flow to check its own change. But it's a building block, not a platform: there's no test format, no suite management, no reporting. Once the agent can drive a browser, everything else is still on you.

Pick it if you want a coding agent to click through its own change during development, or you are building an agent workflow and need the browser layer.

Skip it if you expect a test format, suite management or reporting – it is a primitive, and everything above it is yours to build. Free and open source.

15. BrowserUse (and Stagehand)

BrowserUse is an open-source framework where an LLM-driven agent navigates web apps from natural-language goals, with no pre-authored scripts at all – the agentic idea with nothing else around it. Stagehand, built on Playwright, lets you write normal deterministic code and hand the parts of the UI that keep changing over to the model.

The trade-off: an agent that re-plans on every run gives you flexibility, but regression testing wants the opposite – the same check, the same verdict, every time. Per-run LLM cost adds up too, and assertions, CI wiring and reporting all land on your team.

Pick it if you want exploratory or smoke coverage inside an agent workflow your engineers already run, and per-run model cost is acceptable.

Skip it if you need the same check to give the same verdict every run – regression wants a stable verdict, and an agent that re-plans from scratch each time is the opposite. Free and open source; model usage billed by your provider.

Category 4: Agents + Managed Service

16. QA Wolf

QA Wolf now describes its offering as agents. They explore your app, map test cases and write them as Playwright and Appium code that runs in QA Wolf's cloud, and the code can be exported. On a pull request, agents pick the existing tests the change needs and run only those. Pricing is per run, with a coverage service and volume deals through sales.

The output is still a script suite. When a flow changes, a script gets rewritten, and every run is billed. PR runs choose from tests that already exist, so new behaviour waits until someone adds a test for it.

Pick it if you want a large Playwright and Appium suite built for you on web, mobile and desktop, and you are comfortable paying per run.

Skip it if your suite size is what you're trying to shrink. Per-run billing grows with it, and the understanding of how your product should behave builds up in a vendor's suite rather than with your team.

Category 5: Enterprise Codeless Suites

17. Tricentis Tosca

Tosca has been the reference point for model-based testing in the enterprise for years: your application's screens become reusable modules, tests are built from those modules, and a change made to a module flows through every test that uses it. It reaches deep into packaged enterprise landscapes (SAP, Oracle) where browser-first tools don't go. The agentic features are recent additions on top of that model-based core – and the core is what you're buying.

Pick it if you are a global enterprise testing SAP-class or Oracle estates with a large QA organisation and a model-based approach already in place.

Skip it if you are a product team shipping a web app – the agentic features are recent additions on a model-based core, and the core is what you are buying.

18. ACCELQ

ACCELQ covers web, mobile, API, desktop and mainframe in one codeless platform, and its Autopilot feature pushes toward autonomous test discovery. In practice, most teams use it as a powerful codeless platform with AI assistance rather than agent-driven testing.

Pick it if you need codeless automation across web, mobile, API, desktop and mainframe in one platform and have the budget and timeline to implement it.

Skip it if you expect Autopilot to run your testing for you – in practice teams use ACCELQ as a codeless platform with AI assistance.

Which agentic QA tools handle dynamic UI changes?

Every tool on this list claims to survive UI changes. They do it in four different ways, and the difference decides how much maintenance you still own.

ApproachWhat happens when the UI changesTools
Goal-based agentThe agent reads the new screen and works out the steps from the goal at runtimeQA.tech
Intent or visual element matchingThe element is found by meaning or appearance on every run; the steps stay fixedtestRigor, Momentic
Locator repair ("self-healing")A broken selector is swapped for a new guess and the script runs againmabl, Katalon, Testim, BrowserStack, KaneAI, Autify Nexus, Virtuoso QA, ACCELQ
Repair as a code changeAn agent proposes edits to the test code for a person to reviewShiplight, Playwright Test Agents

Locator repair handles renamed IDs and moved buttons. It struggles when a flow is redesigned, because then the steps themselves are wrong. It also carries a quieter risk: a test that heals when it should have failed. If a tool rewrites your test every time the app changes, each release asks you to trust two changes – the one to the product, and the one to the test meant to verify it.

What do you get when a test fails?

A failed run is only useful if it tells you what broke. This is what each vendor's own pages say you get, as of November 2026.

ToolWhat a failure gives you
QA.techExpected versus actual for the failed goal, and a pass, fail or unable-to-verify verdict posted on the pull request in GitHub or GitLab
mablFailure triage with root-cause insights
MomenticFailure classification and a triage agent
KatalonAI agents for failure analysis
BrowserStackTest failure analysis
QA WolfAgent failure investigation and bug reports
KaneAIResults posted back to the pull request (beta)
Other tools on this listPass or fail with logs and recordings; deeper failure analysis isn't described on the pages we read

Where agentic QA still falls short

These limits apply to every tool on this list, QA.tech included.

  • It needs a running app. Dynamic testing runs against a live build: a preview environment before merge, or staging after. A team with neither has to set one up first.
  • Agent runs cost more than replaying a script. Most tools here bill by usage – credits, runs or minutes – so heavy suites cost more to run.
  • An agent that decides what to test also decides what to skip. Ask any vendor to show you the reasoning behind a run, and whether you can see why a journey was left out.
  • Some journeys should stay pinned. A regulated checkout or a consent screen should run the same fixed check every time, whatever tool you use.

What do agentic QA tools cost?

The pricing model matters more than the headline number: per-run pricing grows with suite size and per-seat pricing with team size, while quote-only usually means an enterprise sales cycle.

ToolPricing model (November 2026)
QA.techFree trial, then a public self-serve Starter plan at $89 a month; Growth and Enterprise priced to volume
testRigorFree tier for public projects; 14-day trial; paid and enterprise plans by quote
MomenticFree plan; public pay-as-you-go plan; enterprise by quote
mabl14-day trial; pricing by quote
KatalonFree plan and 30-day trial; public per-seat plan; enterprise by quote
KaneAI (TestMu AI)Public self-serve plans; enterprise by quote
TestimFree community plan after trial; paid tiers by quote
BrowserStackFree trial; public plans; enterprise by quote
Autify Nexus14-day trial; pricing by quote
FunctionizeFree plan; public paid plans; enterprise by quote
Virtuoso QAFree trial; capacity-based plans by quote
ShiplightFree plan; public paid plan
QA WolfFree starter runs; public per-run pricing; volume and service tiers by quote
Tricentis Tosca, ACCELQBy quote
Playwright Test Agents, Playwright MCP, BrowserUse, StagehandFree and open source; model usage billed by your provider

How to Choose an Agentic QA Tool

The right tool depends less on feature lists and more on two questions: what's your biggest bottleneck, and how much of the testing work do you want the agent to own? (For a full evaluation framework with demo questions and scoring criteria, see our buyer's guide to evaluating agentic testing tools.)

If this is youBest fit
You ship with AI coding agents and pull requests pile up faster than anyone can test themQA.tech
You want a check on agent-written code from an agent that never saw the codeQA.tech
Non-engineers need to write tests in plain EnglishQA.tech, or testRigor if steps should stay fixed
You want test code in git that your engineers ownShiplight or Playwright Test Agents, with the maintenance owned in-house
You need one platform for web, mobile, API and desktop, run by a QA teamKatalon
You already run on a browser and device cloudKaneAI (TestMu AI) or BrowserStack
You test SalesforceTestim
You want a vendor to build and run a large script suiteQA Wolf
You test SAP, Oracle or mainframe estatesTricentis Tosca or ACCELQ

If verification is your bottleneck – you ship with AI coding agents and pull requests pile up faster than anyone can test them – you need dynamic testing: an agent that reads the change, decides what it can break, and verifies that by goal before merge. That is what QA.tech is built for. Running the full static suite on every commit is the alternative, and it is the reason "the tests take forty minutes" is the most common complaint in the category. Diff-based test selection, which Momentic and QA Wolf now offer, shortens the run, but it still chooses from tests someone already wrote.

If maintenance is your bottleneck – Category 1 tools remove it by architecture: no selectors, nothing to heal. Category 2 tools reduce it. Category 3 hands it to your engineers and your coding agent. Category 4 hands it to the vendor and bills every run.

If coverage is your bottleneck – autonomous agents generate and explore beyond what anyone scripted: edge cases, empty states, all the functionality that never earns a ticket. In practice the split that works is to keep a handful of pinned end-to-end tests, maybe five or ten, for journeys that must never drift – a regulated checkout, a consent screen – and take those seriously when they break. Let agentic testing carry everything else.

If ownership matters – decide where you want testing knowledge to live. With QA Wolf it lives in their suite. With vendor consoles it lives in their cloud. With Shiplight and the open-source stack it lives in your repo, along with all the maintenance. QA.tech keeps test logic, coverage strategy and quality insight inside your team, described in plain English anyone can review. (Especially relevant for B2B SaaS teams where product knowledge is the moat.)

If you need web and native mobile – QA.tech, testRigor, Momentic, mabl, Katalon, KaneAI, Testim, BrowserStack, ACCELQ and QA Wolf cover both. Autify Nexus, Functionize, Virtuoso, Shiplight and the open-source stack are web-first.

If the API layer is in scope too – QA.tech runs it with the same agents that test the UI. testRigor, mabl, Katalon, KaneAI, BrowserStack and ACCELQ include API testing in their platforms. The rest stop at the user interface.

If you are verifying code a coding agent wrote – the newest reason people search for this category, and the subject of our roundup of QA tools for coding agents – the question is whether you want the same agent to test its own change, or a second one that never saw the code and tests the running product by goal. The first is convenient. The second is the one that catches what the coding agent got wrong about its own change.

The clearest trend in 2026, I would say: the teams moving fastest stopped maintaining scripts and started describing goals.

Frequently Asked Questions

What is agentic QA?

Agentic QA is a testing model where an AI agent handles the quality loop itself – deciding what to test, running it against the real application through the UI, verifying outcomes, and adapting as the product changes – with humans reviewing results rather than authoring steps. It is dynamic testing: the steps are worked out at runtime, not fixed in a script. In AI-assisted testing, by contrast, a person writes and maintains the tests and AI makes that work faster; the test is still static and the human is still the one doing the testing.

What are the best agentic QA tools in 2026?

QA.tech for dynamic testing – the agent decides what to test from each change and verifies by goal. testRigor for plain-English tests with no selectors, if coverage from production behaviour matters more than change-scoped verification. Momentic, mabl, Katalon, KaneAI, Testim, BrowserStack, Autify Nexus, Functionize and Virtuoso for AI-assisted authoring with reduced maintenance. Shiplight and Playwright Test Agents for agent-written test code in your repo, with Playwright MCP and BrowserUse as the open-source stack you assemble yourself. QA Wolf for agent-written scripts run in a vendor cloud; Tosca and ACCELQ for packaged enterprise estates.

What are the best autonomous testing tools?

Autonomous testing tools generate and maintain coverage themselves instead of assisting a person who writes tests. QA.tech is the autonomous option that also scopes each run to the change in front of it. testRigor generates tests from production behaviour but replays fixed steps. Most tools marketed as autonomous are AI-assisted platforms: a person still authors, and AI speeds up writing and repair.

How is agentic QA different from self-healing tests?

Self-healing is a repair layer on scripts: when a selector breaks, a model re-guesses the locator. The script still encodes implementation, and implementation still changes every sprint. An agentic tool has no rigid locator to break in the first place – it tests by goal, so when the UI changes it re-reasons the journey the way a human tester would. If a vendor's agentic story is fundamentally about locators, it's a patch, not a tester.

Which agentic QA tools handle dynamic UI changes?

All of them claim to, in four ways. QA.tech uses a goal-based agent that works out the steps from the new screen. testRigor and Momentic match elements by meaning or appearance while the steps stay fixed. mabl, Katalon, Testim, BrowserStack, KaneAI and others repair broken locators. Shiplight and Playwright Test Agents propose code edits for a person to review. Only the first removes maintenance; the others reduce it or move it.

Do agentic QA tools work with Claude Code, Cursor or Codex?

Many now ship an MCP server, including QA.tech, testRigor, Shiplight, QA Wolf, KaneAI, Katalon, Functionize and BrowserStack. The bigger question is who does the checking. Tools that install into your coding agent let the same agent test its own change. QA.tech's MCP server lets Claude Code, Cursor or Codex start runs and read results, while the testing itself is done by QA.tech's agent, which never saw the code and tests the running product by goal.

Do agentic QA tools need engineers to set them up?

It depends on the category. QA.tech tests are written in plain English in about five minutes each, and PR testing starts once you install the GitHub App or connect GitLab. Coding-agent tools such as Shiplight and Playwright Test Agents assume engineers, because the tests are code in your repo. Enterprise suites usually come with an implementation project.

How much do agentic QA tools cost?

Pricing models range from free open-source tools to quote-only enterprise suites. QA.tech has a free trial and a public Starter plan at $89 a month with 50 credits, where only agent runs use credits. Several vendors publish self-serve plans, while mabl, Autify Nexus, Virtuoso, Tosca and ACCELQ are sold by quote. Check whether you pay per seat, per run or per credit, because that decides how the bill grows.

Are agentic QA tools reliable enough for production use in 2026?

Yes – though it helps to know what you're actually getting. Goal-based agents are deterministic about outcomes (did the user complete signup?) rather than click-paths, which is what you actually want from regression coverage. Serious platforms also let you pin the journeys that must never drift and fail loudly when they do. What to check in any evaluation: does it report expected-versus-actual on failure, and can you review what the agent did?

Can agentic QA tools test pull requests automatically?

Several now do something on a pull request, in different ways. QA.tech's agent picks up a PR via a GitHub App, reads the intended change and connected issue requirements, and runs dynamic tests against a preview environment before merge, including cases nobody wrote. Momentic and QA Wolf pick existing tests to run from the diff. KaneAI has PR validation in beta. Most other platforms run a pre-authored suite in CI/CD rather than reasoning about the change itself.

What is the difference between dynamic testing and self-healing tests?

Self-healing keeps a static script alive: when a selector breaks, a model re-guesses the locator so the recorded steps can run again. Dynamic testing has no recorded steps to keep alive. The agent reads what changed, decides which journeys to check, works out the steps from the screen at runtime, and verifies the outcome by goal. One repairs the test; the other decides what the test should be.

Your team moves fast. Can your testing keep up?

Our QA agents test your product autonomously, so moving fast never means shipping broken. Start free or get a 30-minute demo.