Figures from the Autonomous-QE version presented at SWARM 2

By Ramkumar Thulasidaran [Senior QA Architect ] | Autonomous QE | A SWARM #2 Show & Tell

What if testing a complex enterprise application didn't have to take months? What if AI could do more than generate test cases, what if it could understand an application, map its dependencies, design tests, build automation, and help teams identify defects, all within one connected workflow?

At SWARM #2: Show and Tell, we got a look at exactly this kind of engineering in action.

Ramkumar Thulasidaran took us through Galent AI's Autonomous-QE, a Claude Code plugin designed to rethink the quality engineering lifecycle. The demonstration wasn't just about using AI to speed up a task. It was about rethinking how the task itself gets done.

And the numbers from one particularly complex HR application module made for an interesting starting point.

The six-month and six-hour comparison was reported by the team and refers to test design, not end-to-end test execution.

The problem wasn't just testing. It was understanding what needed to be tested.

Enterprise applications are rarely simple collections of screens and forms. Behind every workflow sit business rules, dependencies, permissions, validations, data conditions, and interconnected processes.

Consider a seemingly straightforward HR function: employee investment declarations.

A change in an employee's tax regime could affect the proofs required, approval workflows, payroll calculations, and submission cut-off dates. Testing one screen in isolation would not be enough. The team needs to understand how all these elements interact and what could break when something changes.

Now multiply that complexity across dozens of screens and hundreds of dependencies.

For the Payroll - Investment Declaration module, the team had to account for 88 screens and functions, connected through 200 dependencies. Designing comprehensive test coverage manually meant extensive analysis, documentation, review cycles, and repeated validation.

The challenge was clear: How do you make quality engineering faster without making it less reliable?

That's where Autonomous-QE comes in.

Meet Autonomous-QE: More than an AI test-case generator

Traditional AI-assisted testing often involves assembling different agents, configuring tools, providing application context, and connecting the various stages of the testing process.

Autonomous-QE takes a different approach.

It's designed as a ready-to-use Claude Code plugin that brings the key components of quality engineering together in one connected workflow. Rather than asking an engineer to build and coordinate multiple AI agents from scratch, it provides the skills, hooks, agents, and tool connections needed to carry out the work.

The idea is simple: give AI the context to understand the application, the structure to perform the work, and the checks to validate what it produces.

What's under the hood?

Figures from the Autonomous-QE version presented at SWARM #2:

The difference is that these components work together, rather than operating as disconnected AI experiments.

So, how does it actually work?

The interesting part of the demonstration was how Autonomous-QE approaches the application before it starts generating tests.

It doesn't simply read a requirement and start writing test cases. First, it builds an understanding of the application itself.

At the centre of this is something called the Design Structure Matrix (DSM).

Think of the DSM as a map of the application. It captures screens, elements, navigation paths, and dependencies between them. It helps the system understand not just what each screen does, but how different parts of the application connect.

Only after this map is established does test generation begin.

The journey from application to quality reports

Engineers retain control at key decision points, including reviewing the application map, approving test cases, selecting environments, and triaging defects.

The important distinction? AI does the heavy lifting, but people remain part of the decision-making process.

The real differentiator: AI that knows when not to guess

Here's where the story gets particularly interesting.

Anyone who has experimented with AI-generated test cases knows the problem: AI can produce convincing-looking output that isn't necessarily accurate.

A test might refer to a screen that doesn't exist, use a field that isn't part of the application, or describe an expected result that cannot actually be verified.

In quality engineering, that's not a small problem. An inaccurate test can create false confidence, waste debugging time, and allow defects to slip through.

Autonomous-QE addresses this through evidence-based validation.

Every screen, element, navigation step, business rule, and test scenario must be traceable to actual application evidence. If the system cannot establish that connection, the content is rejected rather than presented as a verified result.

The philosophy is simple: AI should not fill gaps in its understanding with plausible-sounding answers. It should identify what it can prove, flag what it cannot, and leave critical decisions to people.

This is enforced through automated quality gates that check test cases and scripts against defined standards. It is not a guarantee that AI can never make mistakes; it is a mechanism for catching unsupported output before it moves forward.

What does this mean in numbers?

The Investment Declaration example is one part of a larger HR365 quality engineering programme.

The same approach was applied across six business-critical modules, covering everything from employee onboarding to payroll and offboarding.

Here's a snapshot of the work:

The programme also demonstrated how AI-assisted quality engineering can contribute beyond test generation.

For example:

• In Onboarding, 41 new cases were run live. The team recorded 15 defects with root causes following the test and analysis process.

• In Payroll – CTC, eight grounded web scenarios were run on QA, with all eight passing.

• In Offboarding, eight probable defects were flagged through code analysis.

The wider efficiency opportunity

The team also presented a worked reference scenario to compare the effort involved in a conventional testing lifecycle with Autonomous-QE. The estimated model-token usage fell from 7.41 million to 3.04 million - a 59% reduction.

Why? Because the plugin moves much of the work to deterministic tools rather than repeatedly asking an AI model to rediscover application context, analyse raw code, or recreate information it has already processed.

The Design Structure Matrix, reusable application knowledge, automated validation, and targeted reporting all help reduce unnecessary model interactions.

The bigger lesson: building efficient AI isn't simply about using fewer prompts. It's about designing smarter workflows that make every interaction count.

And what happens after the first release?

One of the most interesting aspects of Autonomous-QE is its potential for reuse.

Traditional testing often involves repeating much of the discovery and analysis process whenever an application changes. Screens need to be reviewed, dependencies understood, locators updated, and test suites revisited.

With Autonomous-QE, the application map, knowledge skills, and automation assets can be refreshed as the application evolves.

The Impact Matrix helps identify which screens and tests are affected by code changes, allowing teams to focus on what needs attention rather than rebuilding everything from scratch.

That creates an opportunity for recurring efficiency gains across subsequent releases.

And that's where the real value of AI in quality engineering could lie not just accelerating one testing cycle, but making every cycle that follows more intelligent.

Built for the way engineering teams actually work

Another useful aspect of the demonstration was its approach to integration.

Autonomous-QE is designed to work with existing engineering environments rather than requiring teams to abandon their preferred tools or frameworks.

It can work with automation frameworks built using TypeScript, JavaScript, Java, C#, and Python, and supports integration with tools including Jira, Azure DevOps, GitLab, and Confluence through read-only connections.

The plugin is also designed to extend beyond Claude Code, with export support for environments such as OpenAI Codex, Cursor, Kiro, Gemini CLI, Google Antigravity, and VS Code Copilot.

Security and governance are built into the workflow too. Credentials are stored in an encrypted vault, integrations follow least-privilege principles, repositories and connected sources are read-only, and production execution requires explicit confirmation.

For enterprise teams, these considerations are as important as speed and efficiency.

The bigger takeaway: Better engineering, not just faster testing

AI in engineering is moving beyond isolated productivity tools and one-off automation experiments. The next opportunity lies in building connected, context-aware workflows that can take on complex tasks while maintaining the discipline, traceability, and human oversight that enterprise environments demand.

Quality engineering is a particularly interesting place to see this shift because the outcomes are tangible. Tests need to be accurate. Defects need evidence. Results need to be explainable. And every release needs confidence behind it.

Autonomous-QE offers one example of how that future could take shape.

And this thinking is precisely what SWARM is about: bringing builders together to share what they're experimenting with, demonstrate what works, discuss what doesn't, and learn from the process.

Because some of the most valuable AI conversations don't happen around what technology might do someday.

They happen when someone shows you what they've actually built.

Have an interesting AI experiment or engineering innovation to share? We'd love to see it at the next SWARM.

JOIN THE SWARM COMMUNITY →

SWARM is a community for people building with AI, powered by Galent.

About the contributor

Ramkumar Thulasidaran presented Autonomous-QE at SWARM #2: Show and Tell, sharing how Galent AI is exploring evidence-based, AI-assisted quality engineering.

‍