All insights
RITS Software Factory

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

live demo · requirement → proof
1Requirementsworking…
2Test plan
3Test data
4Test cases
5Execute
Jira
○Story picked up
○Test plan linked
○Test data prepared
○Cases added as sub-tasks
○Results labelled · bugs raised
The gap

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?

What the agent does

It starts from either of two places

🌐
Start from a URL
A web address

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.

🎫
Start from Jira
A Jira story or task

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.

How it works

Five steps, each building on the last

01
Explore & requirements

Reads the requirement and any attached document, or explores the website, then writes clear user stories with numbered, testable acceptance criteria.

→ User stories + acceptance criteria
02
Test plan

Before 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 story
03
Test data

Prepares valid, invalid, boundary and edge values for every field it found, each with the expected outcome and the reason it matters.

→ Values with expected results
04
Test cases

Writes 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 plan
05
Execute

Runs 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 Jira
Teams choose how execution starts
AUTO ON

Tests 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.

Test data

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.

test-data-template.xlsx · illustrative rowsvalidinvalidboundaryedge
IDRequirementFieldPageKindValueExpectedSource
TD-01REQ-2EmailSign-invalidname+tag@example.comacceptedAI
TD-02REQ-2EmailSign-ininvalidname@@examplerejectedAI
TD-03REQ-4ZIP codeAddressedge02134acceptedClient
TD-04REQ-4Date of birthProfileboundary02/29/2024acceptedAI
TD-05REQ-5Full nameProfileboundary255 charactersacceptedClient
Full template: ID, Requirement, Field, Page or screen, Opened by, Kind, Value, Expected, Purpose, Source. Kind and Expected are drop-down lists; only Field and Value are required.
📎
Attached automatically
The template is attached to every requirement in Jira. A tester fills it in and attaches it back, or uploads it on the page. The agent reads it within about two minutes and rewrites the test cases to use it.
🤖
The AI writes its own too
From plus-addressed and malformed email addresses to leading-zero ZIP codes, leap days and 255-character names.
🧪
One value, one result
Every value becomes its own test case, so a team that brings 88 values of its own gets 88 individual results, not one bundled verdict.
🛟
Only safe, made-up values. Because these are live systems: example.com email addresses, 555 phone numbers, no real people, no card numbers, and no script or SQL strings. Rows that break those rules are skipped and reported back.
Traceability

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.
How it sits in Jira
Requirement
the story
Test plan
linked to the requirement
Test case · sub-task
steps, expected result, test data
passed
Test case · sub-task
one per data value
failed
Test case · sub-task
would submit a form
needs a person
Bug
linked to the requirement and the failing case
Run summary · insights in plain language
● “Validation gap: invalid values were accepted”
● “Too strict: valid values were rejected; real customers could be turned away”
…with a recommendation to fix before release or plan the fix.
Safe by design

Read-only, on purpose

Testing someone's live website comes with responsibility.

What it does
✓Loads pages and follows links
✓Opens dialogs and menus
✓Types into fields to see how the page reacts
✓Paces its requests
What it never does
✗Submits a form, buys or orders
✗Deletes or sends anything
✗Signs in or out
✗Tries to solve a CAPTCHA
Needs approval
Anything that would need those actions is written as a case for a person and marked Needs approval, ready to run on a test account once the owner agrees.
Stops when refused
If a site shows a bot check or refuses it, the run stops and the remaining cases are marked blocked.
Separate workspaces
Each project's tickets stay on its own Jira site, so a demo for one client never writes into another's workspace.
In practice

Two runs, two starting points

A public website, from a single URL
6
requirements it wrote
1
URL given

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.

A business application, from a Jira story
149
test cases
88
client values
50
AI values
12
acceptance criteria

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.

Why it matters

For delivery teams

⏱️
Testing starts with the requirement
Not after the build. A plan, data and cases exist minutes after a story is raised.
🔗
Nothing is lost between tools
Requirement, plan, cases, results and bugs are linked in Jira, ready for audits, release sign-off and sprint reviews.
📊
Business knowledge is used, not replaced
Clients bring their own test data in a familiar Excel template; the AI fills the gaps and handles the volume.
🧭
Results come with meaning
Instead of a wall of red and green, each requirement gets a risk level and a plain-language recommendation.
🙋
People stay in control
The agent does the repeatable, read-only work. Anything that changes data waits for a person.

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