What Agentic Testing Changes for QA and Where It Still Falls Short
Scripted and self-healing suites break when the UI shifts. Intent-driven browser agents cut maintenance, but regulated flows and odd UIs still need care.
This article is published in English.
Sources: The Rise of Agentic Testing
With agentic testing, a browser agent receives the objective of a test and works out the individual steps itself. The tester describes the expected behavior and the pass criteria and skips scripting every click. A scripted suite falls over when the DOM moves, and self-healing tools just fix the broken locator before running the identical sequence again. The agent plans its path anew on every run, so a UI change no longer means selector repair. Deciding what correct means is beyond it, and that remains the job of whoever owns the release.
Why testing got harder
Back in 2019 an odd pattern showed up: spotless green pipelines kept shipping an infinite-scroll feed that repeated the same ten to twenty rows once a user got past page two. Most people who've led QA for a couple of years can tell a similar story.
Testing has been under strain for some time, and for a while teams simply patched things without asking what had changed. Several things had. Releases sped up. Interfaces moved from static HTML to React components that re-render on every state update. Feature flags meant half the users could be looking at a screen the test suite had never seen.
"Agentic testing" appeared as the industry's answer. What follows isn't meant to push the term. It looks at why testing got more difficult, what "agentic" should actually mean, why it matters to the people doing the work and where it falls short. It's aimed at anyone who writes and reviews tests, or who owns the release when something breaks at 2 a.m.
Release speed
A weekly release cycle leaves time to keep a test suite in shape. Daily deploys don't, and once a team ships whenever a PR merges, the suite can't wait for a Friday cleanup. It has to be production-ready all the time.
Harder interfaces
Complicated UIs keep getting harder to cope with, particularly when components are generated at speed. A selector that worked on a hand-built form may break the day MUI's Autocomplete replaces it, since the rendered DOM, focus behavior and event order all shift beneath it.
The maintenance bill
Then there's the cost people rarely discuss:
- A Playwright test that passes locally and times out in CI because a loading spinner stayed visible 100 ms longer.
- A locator tied to the third child of a flex container, which broke once a designer added one more button.
- Half a sprint lost to updating selectors after what was billed as "just a UI cleanup".
Someone always ends up doing that cleanup, though it was never really their job.
The instinctive reply is to write even more tests. That doesn't build confidence. More scripted tests means more to maintain, and every new flow becomes one more automation that has to survive the next UI change, which will probably make it obsolete. At some point it starts to feel like the test suite is working against you.
What "agentic" means
The word gets thrown around so loosely that it needs a definition before going further.
A scripted test follows a set of instructions in a fixed order. When circumstances stray from that map, the test is useless. Self-healing automation improves on it by repairing broken locators or retrying ambiguous clicks, but it still executes a script written in advance.
Agentic testing differs. Software agents watch the state of the app and decide what action to take next, with nobody supervising each step. In practice the tester supplies intentions and doesn't spell out every interaction. Instead of dozens of lines of Playwright or Selenium code, a prompt can ask the agent to verify that an existing customer can change their payment method without touching their address.
That doesn't mean the agent understands the product well. It means the agent has enough context to act inside it. It can't replace engineering judgment. It might finish a checkout without noticing that a loyalty discount never applied, or flag a legitimate $0.00 order as a pricing error when it was simply a redeemed gift card.
So people still decide what correct looks like, hunt down critical edge cases and judge whether a failure is a defect or just a misreading of how the app should behave. Day-to-day work shifts as well. Less time goes to writing and more goes to reviewing what the agent proposed and deciding where more coverage or a closer look is needed.
Drift in the UI
UI drift has long been among the biggest headaches. Renaming a button from "Continue" to "Next", or swapping a dropdown for a combobox during an accessibility pass, can trigger a cascade of failures even when the application works fine.
Some AI testing platforms approach this differently. They watch real user journeys and build a screen-by-screen model of how people move through the application, including what each page or action does. The tests are then generated from that model and not from a fragile snapshot of the DOM.
The tests themselves run on intent. A test is written as a statement of what should happen and what counts as correct, and the agent finds its way through the UI like a real person, clicking around and comparing the outcome with the stated expectation.
None of this removes people from the loop. Team members still choose which workflows matter most, define what "correct" means for the business and examine the areas that call for product knowledge and not merely interface knowledge.
How the work changes
When less time goes into repairing broken automation, the job itself changes. Hours once spent fixing locators or editing brittle scripts can move to expanding coverage, reviewing risk and finding problems that automation alone misses.
Writing accurate Selenium selectors or remembering Playwright APIs is no longer the scarce skill. Judgment is. That means knowing which user journeys deserve the most attention, understanding where a failure creates real business risk and noticing when a generated test technically passes yet misses what matters. Those were always the hardest parts of testing, and teams just never had the time for them.
The shift also alters what quality means to engineering managers. Tallying tests run or scripts written was never a reliable gauge of trust, and a larger suite doesn't guarantee better coverage, especially if half of it is flaky or gets ignored after UI changes. These questions serve better:
- How fast can a release be validated?
- How confident is the team before shipping?
- What will it cost to keep that confidence over time?
Where it falls short
Agentic testing doesn't replace every form of automation, and pretending it does causes harm. Three cases stand out.
Regulated environments. In healthcare and fintech, execution often has to be deterministic, with audit trails and evidence that a test acts the same on every run. Adaptive behavior can clash with that. Journeys that must never drift belong with explicit scripted steps that fail noisily on any change and leave readable traces of the agent's actions and reasons. A good platform lets the team set how far each test may adapt.
Production safety. Few teams want an autonomous agent roaming a live environment with permission to place orders, edit customer records or create test data in production. Most organizations handle this with isolated staging environments, disposable accounts and tightly controlled permissions.
Hard-to-read interfaces. Apps built around drag-and-drop, canvas rendering or heavily customized internal workflows don't always give an agent the cues it needs. Targeted automation and human oversight still help there.
Different testing problems need different tools, and these three aren't a fit for agentic testing, at least for now.
Getting started
The core problem is that software now ships faster than automation can follow, and QA agents change that. Engineers no longer script each action. They define intent, review what the agent proposes and step in when human judgment is needed, while the system adapts to whatever the UI does next.
Anyone considering it shouldn't begin by replacing the whole suite. Pick a business-critical workflow that changes often, such as checkout or onboarding, and compare maintenance effort across a few release cycles. That gives a realistic read on whether it works for the team.
Common questions
Is it the same as self-healing? No. Self-healing repairs scripted tests, whereas agentic testing pursues a goal and follows no pre-written script.
Does it replace QA engineers? No. It cuts test maintenance, but engineers still define business rules, validate outcomes and investigate failures.
Can it run next to an existing suite? Yes. Most teams start by running both and comparing maintenance effort over time.
Is it usable for compliance-critical flows? Yes, given suitable controls. Such flows can run explicit steps with complete traces of the agent's actions, so critical tests stay deterministic and auditable, and the remaining tests can adapt freely.