From requirement
to proof.
Inside RITS's AI Test Agent: it reads a requirement, plans the testing, prepares the data, writes the cases, runs them, and reports every result and defect back into Jira, where the team already works.
Resource Innovative Technologies · November 2026 · 7 min read
Every software team knows it.
A requirement is written, code is shipped, and somewhere in between someone has to prove that what was asked for actually works. That proof is usually slow, manual and easy to skip: test plans written after the fact, test cases that drift from the requirement, test data invented on the spot, and defects that arrive in Jira without a clear link back to what they break.
We asked a simple question: what if the proof could start the moment the requirement exists?
It starts from either of two places
Type an application's URL into the Live Demo Control Center. The agent explores the site the way a tester would, opening its main pages, menus and dialogs, and writes its own requirements from what it finds.
Raise a requirement in Jira as you normally would. Attach a Word document with the detailed requirements and an Excel sheet with test data if you have them. Within a minute the agent picks it up on its own.
From there it produces a complete, traceable test cycle: requirements, a test plan, test data, test cases, an execution run and defect reports. Each piece is written to Jira and shown live on a single page, so a client can watch the work happen rather than read about it afterwards.
Five steps, each building on the last
Reads the requirement and any attached document, or explores the website, then writes clear user stories with numbered, testable acceptance criteria.
→ User stories + acceptance criteriaBefore a single case is written, it produces one plan: objective, scope and out-of-scope, approach, test types, environment, entry and exit criteria, and risks.
→ One plan, linked to the storyPrepares valid, invalid, boundary and edge values for every field it found, each with the expected outcome and the reason it matters.
→ Values with expected resultsWrites the cases for each requirement, following the plan, and turns every row of test data into its own data-driven case, so each value gets its own pass or fail.
→ Sub-tasks under the planRuns the automated checks on the live application and records the result of every case. Cases that would submit a form or sign in are marked for a person to run.
→ Results + bugs in JiraTests run by themselves as soon as the cases are ready, and again whenever new test data arrives.
Either way, teams can test with the AI's data, their own data, or both.
The AI's and yours, in one template
Good tests depend on good data, and the people who know a business best usually have that data already. So the agent works with one simple Excel template that both it and the client's team use.
| ID | Requirement | Field | Page | Kind | Value | Expected | Source |
|---|---|---|---|---|---|---|---|
| TD-01 | REQ-2 | Sign-in | valid | name+tag@example.com | accepted | AI | |
| TD-02 | REQ-2 | Sign-in | invalid | name@@example | rejected | AI | |
| TD-03 | REQ-4 | ZIP code | Address | edge | 02134 | accepted | Client |
| TD-04 | REQ-4 | Date of birth | Profile | boundary | 02/29/2024 | accepted | AI |
| TD-05 | REQ-5 | Full name | Profile | boundary | 255 characters | accepted | Client |
Built into Jira
The agent doesn't keep its own silo. Everything it produces lives in Jira, structured the way QA leads expect.
- After every run, each case is labelled with its result: passed, failed, blocked or needs a person.
- Every distinct failure becomes a Jira bug, labelled with the requirement's key so one filter shows every bug against it.
- A failure that persists gets a “still failing” note on its existing bug instead of a duplicate; a bug whose cases pass again gets “passed on retest”.
- Each requirement gets a run summary with insights: pass rate, risk level, and what the failures mean.
Read-only, on purpose
Testing someone's live website comes with responsibility.
Two runs, two starting points
Given nothing but a web address, the agent explored the site's home page, main navigation and sign-in dialog, and wrote six requirements of its own, from navigation to accessibility and mobile responsiveness. It raised them in Jira with a test plan and their test cases, ran the automated checks, and most passed. It also found a handful of genuine issues worth a conversation: an email field that doesn't bring up the email keyboard on phones, images without alt text, and pages missing a meta description. Each one arrived in Jira as a bug, tagged to the requirement it affects.
For a data-entry module of an internal application, the team raised a story with nothing but a title, a Word requirements document and an Excel sheet of 88 test values. The agent read the document and wrote twelve acceptance criteria covering workflow rules, role permissions and field validation, added 50 values of its own, and produced 149 test cases as sub-tasks under the test plan, each one tied to the exact value it checks. With no URL in the story, those cases were prepared for testers to run, with every step and expected result already written.
For delivery teams
What's next
See it on your own application.
The AI Test Agent is one part of the RITS Software Factory, our platform for AI-assisted software delivery, from intake to verified release. We're now taking it into client environments: connecting it to test accounts so approved cases can run end to end, and extending the same requirement-to-proof flow to APIs and internal applications.
Give us a URL or a single Jira story, and we'll show you the live demo: requirements, test plan, test data, test cases and results, built in front of you.
Book a live demo session