Closing AI-generated test gaps with qTest & SeaLights

In today’s fast‑moving software world, release velocity keeps climbing, and AI is accelerating it even further. To keep quality teams aligned with rapid change, we’ve brought together two powerful capabilities: Tricentis SeaLights’ deep code-level insights and Tricentis qTest’s intelligent test management and AI-generated test creation.

Here’s how these technologies integrate to create a complete, AI-driven testing feedback loop.

Why SeaLights and qTest are a game-changing combination

Most organizations already use tools that generate tests directly from user stories. Tricentis qTest supports this through agentic test creation (ATC), which creates test cases from requirements in Jira. Those tests are then executed, and SeaLights monitors their behavior to understand:

• Which tests ran
• Which parts of the code they touched
• How test coverage aligns to the original user story

This gives teams immediate clarity into which modified code is covered and what remains untested.

What user-story-based tests miss

AI-generated tests are only as good as the user stories they’re built from. If a user story is vague, incomplete, or lacking edge cases, the resulting tests will be limited too.

This is where SeaLights comes in.

By capturing code coverage during test execution across qTest, SeaLights identifies exactly which methods remain untested. These untested methods are critical clues: they represent real gaps in your test suite that user-story-based AI alone cannot fill.

SeaLights then returns these untested areas back into the AI process, giving qTest’s agent more context to generate additional, richer tests.

How the integration works

This integration forms a closed-loop pipeline where requirements, code behavior, and AI work together. Instead of treating test creation and test execution as separate activities, qTest and SeaLights synchronize them so teams can automatically identify gaps and generate the exact tests needed to close them.

Here’s what that looks like.

1. Start with Jira

Teams begin with user stories, often created by product managers, and increasingly with support from AI. Those user stories lead to code changes and initial tests. This ensures the entire workflow is anchored to business intent from the very beginning. Every test downstream is automatically traceable to the requirement that triggered the code change.

2. qTest generates tests from user stories

Using ATC, qTest automatically converts user stories into structured test cases. ATC standardizes the structure and quality of initial tests, giving teams a consistent baseline before deeper coverage analysis begins. It also frees teams from manual test writing for straightforward requirements.

3. SeaLights captures code coverage

When those tests run, SeaLights tracks:

• Which methods were modified for that user story
• Which of those methods were covered by tests
• Which remain untouched

This goes beyond traditional unit test coverage. SeaLights captures full lifecycle coverage, across functional tests, integration tests, and more.

For example, in a given user story, SeaLights might detect 44 modified methods. It then breaks down exactly how many of those were exercised during testing and how many were not.

By correlating tests to the exact code they touch, SeaLights exposes gaps that would otherwise stay hidden until late in the release cycle. This provides engineering and QA with an objective, code‑driven view of test completeness, not just what was “expected” to be covered.

4. The AI agent generates additional test for the untested methods

This is where the integration becomes transformative.

The AI agent now pulls in:

• Jira user story details
• External documentation (like GitBook)
• SeaLights coverage data
• The untested methods themselves

Using this richer context, the agent analyzes the business intent of the untested code and automatically generates new test cases to expand coverage.

This step bridges the gap between requirement-based test creation and actual code behavior. Instead of relying solely on human-written stories, the AI grounds its new tests in real, observable code paths, dramatically improving accuracy and reducing risk.

5. qTest receives the newly generated tests

Once created, these new tests are pushed directly into qTest to complete the loop.

Teams now have:

• Tests from user stories
• Coverage insights from SeaLights
• New tests generated to cover remaining gaps

This is all connected, automated, and traceable back to business requirements.

Together, these steps turn your test suite into a living system — one that adapts to every code change, detects blind spots automatically, and continuously generates the tests required to maintain high confidence in release quality.

A complete AI-driven testing ecosystem

With this integration, Tricentis delivers truly end-to-end intelligence:

1. qTest creates tests from user stories.
2. SeaLights tells you what those tests actually covered.
3. The AI agent fills the remaining coverage gaps with new test cases.
4. qTest brings it all together for execution, management, and reporting.

This is the future of autonomous, intelligent quality — where test suites evolve automatically as code changes, and teams gain unprecedented visibility into release readiness.

Watch the full webinar

See the integration in action, from Jira to qTest to SeaLights and back again. Watch it here.