Agentic QA that checks its own work.
The AI proposes the tests. A fixed, rule-based gate decides whether they pass. From requirement to release, every result comes with a reason, and your people sign off anything risky.
- Nothing ships on AI confidence alone
- Every result comes with a reason
- One engine for every test type
- A full audit trail
Don't take our word for it. Run a requirement through Loop.
Pick a requirement and press run. You'll watch Loop write the test, run it, let the gate decide and file the result. In one of them, the run waits for you.
1 · Pick a requirement
A simulated run with example data, showing what Loop does on a real project.
Propose
Execute
Gate
Classify
Repair
Learn
The gaps aren't only in testing. They're at every stage.
Testing, release and production each break in their own way. What one stage learns never reaches the next, so the same gaps open on every release.
01 · Testing
- Test scripts are written by hand and break every time the app changes.
- Web, API, performance, security and regression live in separate tools.
- Coverage is ticked off a checklist, not traced to the requirement.
02 · Release and go-live
- Go or no-go is a gut call, not a decision backed by test evidence.
- Nothing links risk to what actually failed, and why.
- Late changes surface too late to react, and the date slips.
03 · After go-live
- Production issues surprise teams that had no warning.
- Every patch is retested from scratch, without knowing what changed.
- Nothing learned in production makes it back into the tests.
No loop back from production into testing
One closed loop, from requirement to verified test.
Follow one requirement round the loop. The AI writes and runs the test, a fixed rule decides, a person signs off anything risky, and what was learned comes back round.
- 01
Propose
The AI writes the testLoop reads the requirement and drafts the test. The AI writes it, but it never gets to grade it.
What happens
- test POST /orders
- expect 201 Created
- expect orderId exists
Next → 02 Execute
- 02
Execute
Runs against the real systemThe test runs against your actual app or API, not a mock. Every request and response is kept as evidence.
What happens
- POST /orders → 201 Created · 184 ms
- body.orderId = "ORD-1042"
- evidence saved
Next → 03 Verify gate
- 03
Verify gate
A rule decides, not the AIThe AI hands its test over and steps aside. A fixed rule on the server checks the result against the requirement and the contract. The AI's confidence plays no part.
What happens
- ✓ status is 201
- ✓ response matches the contract
- ✓ orderId is present
- – AI confidence 97% → ignored
Next → 04 Classify
- 04
Classify
A rule labels itEvery result gets one of five labels, and the reason behind it: passed, failed, contract violated, drifted or blocked.
What happens
- ● Passed status 201, contract met
- ○ Failed
- ○ Contract violated
- ○ Drifted · Blocked
Next → 05 Heal / repair
- 05
Heal / repair
A person approves riskWhen the app changes, Loop repairs only the tests the change touched. Anything risky waits for a named approver.
What happens
- drift: total → amount
- repair proposed for 2 tests
- approved by QA lead · reason logged
Next → 06 Learn
- 06
Learn
It learnsThe verified test is kept as a reusable asset, so the next run starts ahead instead of from zero.
What happens
- REQ-214 tests saved
- reused on the next release
- ↻ back to 01, with what it learned
Next → 01 Propose
One closed loop, from requirement to verified test.
Scroll and follow one requirement round the loop. The AI writes and runs the test, a fixed rule decides, a person signs off anything risky, and what was learned comes back round.
One engine writes every kind of test.
Point Loop at a requirement or at something that already exists. It writes, runs and verifies the tests, with no hand-written scripts and no separate tool for each type.
Web / UI
✓ verifiedWhole user journeys, checked against how the app really behaves.
journey cart → pay → confirmAPI
✓ verifiedContracts, schemas and endpoint behaviour, from the spec or from discovery.
POST /orders · contract v2Performance
✓ verifiedLatency and load, measured on successful responses only.
p95 counted on 2xx onlyOne engine
Loop
Writes · Runs · Verifies
Regression
✓ verifiedRe-runs on its own when the requirement or the app changes.
app changed → suite re-runsSecurity
✓ verifiedNegative and hostile cases, judged on how the API fails.
bad token → 401, not 500Change and patch
✓ verifiedEvery patch tested against the same verified baseline.
patch vs verified baselineThe AI never marks its own homework.
Every result passes through a deterministic gate that a person can audit. Confidence is never the reason something ships.
01 Proposer / verifier split
The model
Proposes the test. It never decides whether it passed.
test checkout returns 201
test orderId exists
own grade “looks fine, 97%”
Not allowed to grade itself
The gate
A fixed rule makes the pass or fail call.
Enforced on the server, not in the browser03 Outcome classification
Five outcomes. Each one with a reason.
- Passedreason status 201, contract met
- Failedreason status 500, expected 201
- Contract violatedreason orderId missing from the response
- Driftedreason field total renamed to amount in v2
- Blockedreason staging unreachable, run paused
- 11:02:32gatedriftedfield total → amount, repair proposed
- 11:02:25approverapprovedQA lead · repair on /payments · reason logged
- 11:02:18gatefailedrule: expected 201, got 500
- 11:02:11gatepassedrule: status = 201, contract v2 met
Test results become release intelligence, not just a checklist.
The same verified evidence that runs your tests also guides release and delivery, across the whole lifecycle, not only at the end.
Requirement churn
01 During development
Schedule risk predicted from requirement churn.
What actually changed
- /orders total → amountHigh
- checkout button textLow
- /payments new retryHigh
- profile page layoutLow
02 Before release
Risk and impact scored on what actually changed.
Go / no-go
Decided on test evidence, not gut feel.
● passed● 0 failed● 0 blocked
03 Go-live
Go or no-go decided on test evidence, not gut feel.
Live signals
Next issue likely in
/payments · retry path
04 After go-live
Live signals point to where the next issue will appear.
Most agentic QA tools trust the model. Loop doesn't have to.
The difference is who makes the call. In most tools the model writes the test and grades it too. In Loop a separate gate decides, and a person approves risk.
Better software. Safer releases. Happier customers.
Higher quality, faster, safer, together. Each one comes from a part of the loop you've already seen.
✓ status is 201
✓ contract met
✕ AI grade ignored
Higher quality
A fixed gate decides every result, so nothing ships on AI confidence alone.
From the gaterequirement
→ 6 test types
→ re-run on change
Faster
Tests are written, run and re-run for you, with no scripts to maintain by hand.
From one enginerepair touches payments
→ approver signs off
→ reason logged
Safer
Risky changes wait for a named approver, and every decision is on record.
From repair and auditAI proposes
Rule decides
Person approves risk
Together
The AI does the repetitive work. People decide what matters.
From proposer and verifierLoop: your questions.
What does Loop need to get started?
Your requirements in whatever form you have them: BRDs, user stories or existing documentation. Loop learns your application and business context from there and generates the tests.
What kinds of tests can Loop create?
Six kinds from one engine: Web/UI journeys, API contracts, performance, regression, security, and change and patch tests, run against your real systems.
Does Loop replace our QA team?
No. Loop takes the repetitive work, like writing routine tests and fixing broken ones, so your team can focus on quality strategy. It's autonomous where that helps, and a person can step in whenever they want.
Can we keep our data in-house?
Yes. Loop can be deployed privately or on premise, so sensitive data stays under your control.
Want to see it on your systems? Book a live demo.
Tell us a little about your setup. We'll reply within one business day to arrange a walkthrough.
- Weekly demos
- No lock-in
- You own the code
- 1 business day